1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

//! Error values.

use std::fmt;

use tokio::io;

use blather::Params;

/// `ddmw-client` error values.
#[derive(Debug)]
pub enum Error {
  /// An error occurred in the Blather communications library.
  Blather(String),

  /// A `std::io` or `tokio::io` error occurred.
  IO(String),

  /// A DDMW core server return `Fail`.  The `Params` buffer contains details
  /// about the error.
  ServerError(Params),

  /// A state was entered which was unexpected.  This can mean that the client
  /// expected to receive something from the server, but received something
  /// else, which may technically have been okay under different
  /// circumstances.
  BadState(String),

  /// A server disconnected or the client is in a disconnected state.
  Disconnected,

  /// A function or method was called with an invalid/unknown input.
  BadInput(String),

  /// A function or method was called with incomplete or ambiguous parameters.
  BadParams(String),

  /// Authentication was requested, but the authentication context is invalid
  /// (missing or invalid data).
  InvalidCredentials(String),

  /// Some expected data is missing.
  MissingData(String),

  Parse(String),

  Figment(String)
}

impl Error {
  pub fn invalid_cred(e: &str) -> Self {
    Self::InvalidCredentials(e.to_string())
  }
  pub fn miss_data<S: ToString>(e: S) -> Self {
    Self::MissingData(e.to_string())
  }
  pub fn bad_state<S: ToString>(e: S) -> Self {
    Self::BadState(e.to_string())
  }
  pub fn parse<S: ToString>(e: S) -> Self {
    Self::Parse(e.to_string())
  }
}


impl std::error::Error for Error {}

impl fmt::Display for Error {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match &*self {
      Error::Blather(s) => write!(f, "Msg buffer error; {}", s),
      Error::IO(s) => write!(f, "I/O error; {}", s),
      Error::ServerError(p) => write!(f, "Server replied: {}", p),
      Error::BadState(s) => {
        write!(f, "Encountred an unexpected/bad state: {}", s)
      }
      Error::Disconnected => write!(f, "Disconnected"),
      Error::BadInput(s) => write!(f, "Bad input; {}", s),
      Error::BadParams(s) => write!(f, "Bad parameters; {}", s),
      Error::InvalidCredentials(s) => write!(f, "Invalid credentials; {}", s),
      Error::MissingData(s) => write!(f, "Missing data; {}", s),
      Error::Parse(s) => write!(f, "Parsing failed; {}", s),
      Error::Figment(s) => write!(f, "Figment error; {}", s)
    }
  }
}

impl From<blather::Error> for Error {
  fn from(err: blather::Error) -> Self {
    Error::Blather(err.to_string())
  }
}

impl From<io::Error> for Error {
  fn from(err: io::Error) -> Self {
    Error::IO(err.to_string())
  }
}

impl From<figment::Error> for Error {
  fn from(err: figment::Error) -> Self {
    Error::Figment(err.to_string())
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :