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 :