Source code
Revision control
Copy as Markdown
Other Tools
use std::error::Error as StdError;↩
use std::io;↩
use std::str::Utf8Error;↩
use std::{error, fmt};↩
↩
use serde;↩
↩
/// The result of a serialization or deserialization operation.↩
pub type Result<T> = ::std::result::Result<T, Error>;↩
↩
/// An error that can be produced during (de)serializing.↩
pub type Error = Box<ErrorKind>;↩
↩
/// The kind of error that can be produced during a serialization or deserialization.↩
#[derive(Debug)]↩
pub enum ErrorKind {↩
/// If the error stems from the reader/writer that is being used↩
/// during (de)serialization, that error will be stored and returned here.↩
Io(io::Error),↩
/// Returned if the deserializer attempts to deserialize a string that is not valid utf8↩
InvalidUtf8Encoding(Utf8Error),↩
/// Returned if the deserializer attempts to deserialize a bool that was↩
/// not encoded as either a 1 or a 0↩
InvalidBoolEncoding(u8),↩
/// Returned if the deserializer attempts to deserialize a char that is not in the correct format.↩
InvalidCharEncoding,↩
/// Returned if the deserializer attempts to deserialize the tag of an enum that is↩
/// not in the expected ranges↩
InvalidTagEncoding(usize),↩
/// Serde has a deserialize_any method that lets the format hint to the↩
/// object which route to take in deserializing.↩
DeserializeAnyNotSupported,↩
/// If (de)serializing a message takes more than the provided size limit, this↩
/// error is returned.↩
SizeLimit,↩
/// Bincode can not encode sequences of unknown length (like iterators).↩
SequenceMustHaveLength,↩
/// A custom error message from Serde.↩
Custom(String),↩
}↩
↩
impl StdError for ErrorKind {↩
fn description(&self) -> &str {↩
match *self {↩
ErrorKind::Io(ref err) => error::Error::description(err),↩
ErrorKind::InvalidUtf8Encoding(_) => "string is not valid utf8",↩
ErrorKind::InvalidBoolEncoding(_) => "invalid u8 while decoding bool",↩
ErrorKind::InvalidCharEncoding => "char is not valid",↩
ErrorKind::InvalidTagEncoding(_) => "tag for enum is not valid",↩
ErrorKind::SequenceMustHaveLength => {↩
"Bincode can only encode sequences and maps that have a knowable size ahead of time"↩
}↩
ErrorKind::DeserializeAnyNotSupported => {↩
"Bincode doesn't support serde::Deserializer::deserialize_any"↩
}↩
ErrorKind::SizeLimit => "the size limit has been reached",↩
ErrorKind::Custom(ref msg) => msg,↩
}↩
}↩
↩
fn cause(&self) -> Option<&error::Error> {↩
match *self {↩
ErrorKind::Io(ref err) => Some(err),↩
ErrorKind::InvalidUtf8Encoding(_) => None,↩
ErrorKind::InvalidBoolEncoding(_) => None,↩
ErrorKind::InvalidCharEncoding => None,↩
ErrorKind::InvalidTagEncoding(_) => None,↩
ErrorKind::SequenceMustHaveLength => None,↩
ErrorKind::DeserializeAnyNotSupported => None,↩
ErrorKind::SizeLimit => None,↩
ErrorKind::Custom(_) => None,↩
}↩
}↩
}↩
↩
impl From<io::Error> for Error {↩
fn from(err: io::Error) -> Error {↩
ErrorKind::Io(err).into()↩
}↩
}↩
↩
impl fmt::Display for ErrorKind {↩
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {↩
match *self {↩
ErrorKind::Io(ref ioerr) => write!(fmt, "io error: {}", ioerr),↩
ErrorKind::InvalidUtf8Encoding(ref e) => write!(fmt, "{}: {}", self.description(), e),↩
ErrorKind::InvalidBoolEncoding(b) => {↩
write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b)↩
}↩
ErrorKind::InvalidCharEncoding => write!(fmt, "{}", self.description()),↩
ErrorKind::InvalidTagEncoding(tag) => {↩
write!(fmt, "{}, found {}", self.description(), tag)↩
}↩
ErrorKind::SequenceMustHaveLength => write!(fmt, "{}", self.description()),↩
ErrorKind::SizeLimit => write!(fmt, "{}", self.description()),↩
ErrorKind::DeserializeAnyNotSupported => write!(↩
fmt,↩
"Bincode does not support the serde::Deserializer::deserialize_any method"↩
),↩
ErrorKind::Custom(ref s) => s.fmt(fmt),↩
}↩
}↩
}↩
↩
impl serde::de::Error for Error {↩
fn custom<T: fmt::Display>(desc: T) -> Error {↩
ErrorKind::Custom(desc.to_string()).into()↩
}↩
}↩
↩
impl serde::ser::Error for Error {↩
fn custom<T: fmt::Display>(msg: T) -> Self {↩
ErrorKind::Custom(msg.to_string()).into()↩
}↩
}↩