From cac9301615f0b515dd70221b871223470f085111 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lena=20Hellstr=C3=B6m?= Date: Fri, 10 Feb 2017 12:19:58 -0600 Subject: [PATCH] Remove InvalidEncoding struct (#111) --- src/serde/mod.rs | 32 ++++++++++---------------------- src/serde/reader.rs | 18 +++++++++--------- tests/test.rs | 2 +- 3 files changed, 20 insertions(+), 32 deletions(-) diff --git a/src/serde/mod.rs b/src/serde/mod.rs index 48f99b4..3ac623a 100644 --- a/src/serde/mod.rs +++ b/src/serde/mod.rs @@ -39,7 +39,10 @@ pub enum ErrorKind { /// encoding, this error will be returned. This error is only possible /// if a stream is corrupted. A stream produced from `encode` or `encode_into` /// should **never** produce an InvalidEncoding error. - InvalidEncoding(InvalidEncoding), + InvalidEncoding{ + desc: &'static str, + detail: Option + }, /// If (de)serializing a message takes more than the provided size limit, this /// error is returned. SizeLimit, @@ -51,7 +54,7 @@ impl error::Error for ErrorKind { fn description(&self) -> &str { match *self { ErrorKind::IoError(ref err) => error::Error::description(err), - ErrorKind::InvalidEncoding(ref ib) => ib.desc, + ErrorKind::InvalidEncoding{desc, ..} => desc, ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences", ErrorKind::SizeLimit => "the size limit for decoding has been reached", ErrorKind::Custom(ref msg) => msg, @@ -62,7 +65,7 @@ impl error::Error for ErrorKind { fn cause(&self) -> Option<&error::Error> { match *self { ErrorKind::IoError(ref err) => err.cause(), - ErrorKind::InvalidEncoding(_) => None, + ErrorKind::InvalidEncoding{..} => None, ErrorKind::SequenceMustHaveLength => None, ErrorKind::SizeLimit => None, ErrorKind::Custom(_) => None, @@ -81,8 +84,10 @@ impl fmt::Display for ErrorKind { match *self { ErrorKind::IoError(ref ioerr) => write!(fmt, "IoError: {}", ioerr), - ErrorKind::InvalidEncoding(ref ib) => - write!(fmt, "InvalidEncoding: {}", ib), + ErrorKind::InvalidEncoding{desc, detail: None}=> + write!(fmt, "InvalidEncoding: {}", desc), + ErrorKind::InvalidEncoding{desc, detail: Some(ref detail)}=> + write!(fmt, "InvalidEncoding: {} ({})", desc, detail), ErrorKind::SequenceMustHaveLength => write!(fmt, "Bincode can only encode sequences and maps that have a knowable size ahead of time."), ErrorKind::SizeLimit => @@ -105,23 +110,6 @@ impl serde::ser::Error for Error { } } -#[derive(Eq, PartialEq, Clone, Debug)] -pub struct InvalidEncoding { - pub desc: &'static str, - pub detail: Option, -} - -impl fmt::Display for InvalidEncoding { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - match *self { - InvalidEncoding { detail: None, desc } => - write!(fmt, "{}", desc), - InvalidEncoding { detail: Some(ref detail), desc } => - write!(fmt, "{} ({})", desc, detail) - } - } -} - /// Serializes an object directly into a `Writer`. /// /// If the serialization would take more bytes than allowed by `size_limit`, an error diff --git a/src/serde/reader.rs b/src/serde/reader.rs index e563202..cc7c0a5 100644 --- a/src/serde/reader.rs +++ b/src/serde/reader.rs @@ -5,7 +5,7 @@ use serde_crate as serde; use serde_crate::de::value::ValueDeserializer; use serde_crate::de::Error as DeError; use ::SizeLimit; -use super::{Result, Error, ErrorKind, InvalidEncoding}; +use super::{Result, Error, ErrorKind}; /// A Deserializer that reads bytes from a buffer. /// @@ -59,10 +59,10 @@ impl Deserializer { try!(self.reader.by_ref().take(len as u64).read_to_end(&mut buffer)); String::from_utf8(buffer).map_err(|err| - ErrorKind::InvalidEncoding(InvalidEncoding { + ErrorKind::InvalidEncoding{ desc: "error while decoding utf8 string", detail: Some(format!("Deserialize error: {}", err)) - }).into()) + }.into()) } } @@ -99,10 +99,10 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { 1 => visitor.visit_bool(true), 0 => visitor.visit_bool(false), value => { - Err(ErrorKind::InvalidEncoding(InvalidEncoding { + Err(ErrorKind::InvalidEncoding{ desc: "invalid u8 when decoding bool", detail: Some(format!("Expected 0 or 1, got {}", value)) - }).into()) + }.into()) } } } @@ -144,10 +144,10 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { { use std::str; - let error = ErrorKind::InvalidEncoding(InvalidEncoding { + let error = ErrorKind::InvalidEncoding{ desc: "Invalid char encoding", detail: None - }).into(); + }.into(); let mut buf = [0]; @@ -280,10 +280,10 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { match value { 0 => visitor.visit_none(), 1 => visitor.visit_some(&mut *self), - _ => Err(ErrorKind::InvalidEncoding(InvalidEncoding { + _ => Err(ErrorKind::InvalidEncoding{ desc: "invalid tag when decoding Option", detail: Some(format!("Expected 0 or 1, got {}", value)) - }).into()), + }.into()), } } diff --git a/tests/test.rs b/tests/test.rs index db9747b..2d109e3 100644 --- a/tests/test.rs +++ b/tests/test.rs @@ -213,7 +213,7 @@ fn test_fixed_size_array() { fn deserializing_errors() { fn isize_invalid_deserialize(res: Result) { match res.map_err(|e| *e) { - Err(ErrorKind::InvalidEncoding(_)) => {}, + Err(ErrorKind::InvalidEncoding{..}) => {}, Err(ErrorKind::Custom(ref s)) if s.contains("invalid encoding") => {}, Err(ErrorKind::Custom(ref s)) if s.contains("invalid value") => {}, other => panic!("Expecting InvalidEncoding, got {:?}", other),