rmpv/decode/
mod.rs

1use std::error;
2use std::fmt::{self, Display, Formatter};
3use std::io::{self, ErrorKind};
4
5use rmp::decode::{MarkerReadError, ValueReadError};
6
7pub mod value;
8pub mod value_ref;
9
10pub use self::value::read_value;
11pub use self::value_ref::read_value_ref;
12
13/// This type represents all possible errors that can occur when deserializing a value.
14#[derive(Debug)]
15pub enum Error {
16    /// Error while reading marker byte.
17    InvalidMarkerRead(io::Error),
18    /// Error while reading data.
19    InvalidDataRead(io::Error),
20}
21
22impl Error {
23    pub fn kind(&self) -> ErrorKind {
24        match *self {
25            Error::InvalidMarkerRead(ref err) => err.kind(),
26            Error::InvalidDataRead(ref err) => err.kind(),
27        }
28    }
29}
30
31impl error::Error for Error {
32    fn description(&self) -> &str {
33        match *self {
34            Error::InvalidMarkerRead(..) => "I/O error while reading marker byte",
35            Error::InvalidDataRead(..) => "I/O error while reading non-marker bytes",
36        }
37    }
38
39    fn cause(&self) -> Option<&dyn error::Error> {
40        match *self {
41            Error::InvalidMarkerRead(ref err) => Some(err),
42            Error::InvalidDataRead(ref err) => Some(err),
43        }
44    }
45}
46
47impl Display for Error {
48    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
49        match *self {
50            Error::InvalidMarkerRead(ref err) => {
51                write!(fmt, "I/O error while reading marker byte: {}", err)
52            }
53            Error::InvalidDataRead(ref err) => {
54                write!(fmt, "I/O error while reading non-marker bytes: {}", err)
55            }
56        }
57    }
58}
59
60impl From<MarkerReadError> for Error {
61    fn from(err: MarkerReadError) -> Error {
62        Error::InvalidMarkerRead(err.0)
63    }
64}
65
66impl From<ValueReadError> for Error {
67    fn from(err: ValueReadError) -> Error {
68        match err {
69            ValueReadError::InvalidMarkerRead(err) => Error::InvalidMarkerRead(err),
70            ValueReadError::InvalidDataRead(err) => Error::InvalidDataRead(err),
71            ValueReadError::TypeMismatch(..) => {
72                Error::InvalidMarkerRead(io::Error::new(ErrorKind::Other, "type mismatch"))
73            }
74        }
75    }
76}
77
78impl Into<io::Error> for Error {
79    fn into(self) -> io::Error {
80        match self {
81            Error::InvalidMarkerRead(err) |
82            Error::InvalidDataRead(err) => err,
83        }
84    }
85}