//! Error handling.

pub use failure::{Error, Fail};

use std::fmt;

macro_rules! ok {
   ($v:expr, $msg:expr) => {
      match $v {
         Some(v) => Ok(v),
         None => Err(err_msg($msg)),
      }
   };
}

macro_rules! flag_ok {
   ($t:ident, $v:expr) => {
      match $t::from_bits($v) {
         Some(v) => Ok(v),
         None => Err(err_msg(concat!("bad ", stringify!($t)))),
      }
   };
}

macro_rules! bail {
   ($e:expr) => {
      return Err(err_msg($e));
   };
}

pub fn err_msg(msg: &'static str) -> Error {Error::from(ErrMsg(msg))}

impl Fail for ReprError {}
impl Fail for ErrMsg {}

impl fmt::Display for ReprError
{
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
   {
      write!(f, "representation error (got {})", self.0)
   }
}

impl fmt::Debug for ReprError
{
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
   {
      fmt::Display::fmt(self, f)
   }
}

impl fmt::Display for ErrMsg
{
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {f.write_str(self.0)}
}

impl fmt::Debug for ErrMsg
{
   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
   {
      fmt::Display::fmt(self, f)
   }
}

#[derive(PartialEq)]
pub struct ReprError(pub i64);

struct ErrMsg(&'static str);

pub type ResultS<T> = Result<T, Error>;

// EOF