blackhole_compress/
error.rs

1use std::{fmt, error, io};
2
3#[derive(Debug)]
4pub enum ReadError {
5    InvalidState(String),
6    IOError(io::Error),
7    UnexpectedEofError,
8    InvalidArgumentError(String)
9}
10impl fmt::Display for ReadError {
11    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
12        match *self {
13            ReadError::InvalidState(ref s) => write!(f, "Invalid State. ({})", s),
14            ReadError::IOError(ref e) => write!(f, "{}", e),
15            ReadError::UnexpectedEofError => write!(f, "Unexpected EOF."),
16            ReadError::InvalidArgumentError(ref s) => write!(f, "InvalidArgumentError ({})", s)
17        }
18    }
19}
20impl error::Error for ReadError {
21    fn description(&self) -> &str {
22        match *self {
23            ReadError::InvalidState(_) => "Invalid State.",
24            ReadError::IOError(_) => "IO Error.",
25            ReadError::UnexpectedEofError => "UnexpectedEOF.",
26            ReadError::InvalidArgumentError(_) => "Invalid argument."
27        }
28    }
29
30    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
31        match *self {
32            ReadError::InvalidState(_) => None,
33            ReadError::IOError(ref e) => Some(e),
34            ReadError::UnexpectedEofError => None,
35            ReadError::InvalidArgumentError(_) => None
36        }
37    }
38}
39impl From<io::Error> for ReadError {
40    fn from(e: io::Error) -> Self {
41        ReadError::IOError(e)
42    }
43}
44#[derive(Debug)]
45pub enum WriteError {
46    InvalidState(String),
47    IOError(io::Error),
48}
49impl fmt::Display for WriteError {
50    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
51        match *self {
52            WriteError::InvalidState(ref s) => write!(f, "Invalid State. ({})", s),
53            WriteError::IOError(ref e) => write!(f, "{}", e),
54        }
55    }
56}
57impl error::Error for WriteError {
58    fn description(&self) -> &str {
59        match *self {
60            WriteError::InvalidState(_) => "Invalid State.",
61            WriteError::IOError(_) => "IO Error.",
62        }
63    }
64
65    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
66        match *self {
67            WriteError::InvalidState(_) => None,
68            WriteError::IOError(ref e) => Some(e),
69        }
70    }
71}
72impl From<io::Error> for WriteError {
73    fn from(e: io::Error) -> Self {
74        WriteError::IOError(e)
75    }
76}
77#[derive(Debug)]
78pub enum CompressionError {
79    InvalidState(String),
80    ReadError(ReadError),
81    WriteError(WriteError),
82    LimitError(String)
83}
84impl fmt::Display for CompressionError {
85    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
86        match *self {
87            CompressionError::InvalidState(ref s) => write!(f, "Invalid State. ({})", s),
88            CompressionError::ReadError(ref e) => write!(f, "Read error ({})", e),
89            CompressionError::WriteError(ref e) => write!(f, "Write error ({})", e),
90            CompressionError::LimitError(ref s) => write!(f, "limit error. ({})", s)
91        }
92    }
93}
94impl error::Error for CompressionError {
95    fn description(&self) -> &str {
96        match *self {
97            CompressionError::InvalidState(_) => "Invalid State.",
98            CompressionError::ReadError(_) => "Read error.",
99            CompressionError::WriteError(_) => "Write error.",
100            CompressionError::LimitError(_) => "limit error.",
101        }
102    }
103
104    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
105        match *self {
106            CompressionError::InvalidState(_) => None,
107            CompressionError::ReadError(ref e) => Some(e),
108            CompressionError::WriteError(ref e) => Some(e),
109            CompressionError::LimitError(_) => None
110        }
111    }
112}
113impl From<ReadError> for CompressionError {
114    fn from(e: ReadError) -> Self {
115        CompressionError::ReadError(e)
116    }
117}
118impl From<WriteError> for CompressionError {
119    fn from(e: WriteError) -> Self {
120        CompressionError::WriteError(e)
121    }
122}
123#[derive(Debug)]
124pub enum UnCompressionError {
125    InvalidState(String),
126    ReadError(ReadError),
127    WriteError(WriteError),
128    FormatError
129}
130impl fmt::Display for UnCompressionError {
131    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
132        match *self {
133            UnCompressionError::InvalidState(ref s) => write!(f, "Invalid State. ({})", s),
134            UnCompressionError::ReadError(ref e) => write!(f, "Read error ({})", e),
135            UnCompressionError::WriteError(ref e) => write!(f, "Write error ({})", e),
136            UnCompressionError::FormatError => write!(f, "The format of the input is invalid.")
137        }
138    }
139}
140impl error::Error for UnCompressionError {
141    fn description(&self) -> &str {
142        match *self {
143            UnCompressionError::InvalidState(_) => "Invalid State.",
144            UnCompressionError::ReadError(_) => "Read error.",
145            UnCompressionError::WriteError(_) => "Write error.",
146            UnCompressionError::FormatError => "The format of the input is invalid."
147        }
148    }
149
150    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
151        match *self {
152            UnCompressionError::InvalidState(_) => None,
153            UnCompressionError::ReadError(ref e) => Some(e),
154            UnCompressionError::WriteError(ref e) => Some(e),
155            UnCompressionError::FormatError => None
156        }
157    }
158}
159impl From<ReadError> for UnCompressionError {
160    fn from(e: ReadError) -> Self {
161        UnCompressionError::ReadError(e)
162    }
163}
164impl From<WriteError> for UnCompressionError {
165    fn from(e: WriteError) -> Self {
166        UnCompressionError::WriteError(e)
167    }
168}
blackhole_compress/error.rs

blackhole_compress/
error.rs
