Merge pull request #34 from kyeah/master

zonyitoo · zonyitoo · commit adbbc97b4a56 · 2016-03-06T17:25:19.000+08:00
Update serde to 0.7
diff --git a/Cargo.toml b/Cargo.toml
@@ -17,7 +17,7 @@ libc = "0.1"
 rand = "0.3"
 rust-crypto = "0.2.31"
 rustc-serialize = "0.3"
-serde = "~0.6.1"
+serde = "0.7"
 time = "0.1"
 
 [dependencies.num]
diff --git a/serde-tests/Cargo.toml b/serde-tests/Cargo.toml
@@ -6,12 +6,12 @@ build = "build.rs"
 
 
 [dependencies]
-serde = "0.6"
+serde = "0.7"
 bson = { path = "..", features = ["serde"] }
 
 [build-dependencies]
-syntex = "0.22"
-serde_codegen = "0.6"
+syntex = "^0.29.0"
+serde_codegen = "0.7"
 
 [lib]
 name = "serde_tests"
diff --git a/serde-tests/test.rs.in b/serde-tests/test.rs.in
@@ -121,7 +121,7 @@ fn application_decode_error() {
          fn deserialize<D: Deserializer>(d: &mut D) -> Result<Range10, D::Error> {
              let x: usize = try!(Deserialize::deserialize(d));
              if x > 10 {
-                 Err(serde::de::Error::syntax("more than 10"))
+                 Err(serde::de::Error::invalid_value("more than 10"))
              } else {
                  Ok(Range10(x))
              }
diff --git a/src/decoder/error.rs b/src/decoder/error.rs
@@ -14,9 +14,10 @@ pub enum DecoderError {
     // An unexpected field was found.
     UnknownField(String),
     // There was an error with the syntactical structure of the BSON.
-    SyntaxError,
+    SyntaxError(String),
     // The end of the BSON input was reached too soon.
     EndOfStream,
+    Unknown(String),
 }
 
 impl From<io::Error> for DecoderError {
@@ -52,8 +53,9 @@ impl fmt::Display for DecoderError {
                 write!(fmt, "expected a field of type `{}`", field_type)
             }
             DecoderError::UnknownField(ref field) => write!(fmt, "unknown field `{}`", field),
-            DecoderError::SyntaxError => write!(fmt, "syntax error"),
+            DecoderError::SyntaxError(ref inner) => inner.fmt(fmt),
             DecoderError::EndOfStream => write!(fmt, "end of stream"),
+            DecoderError::Unknown(ref inner) => inner.fmt(fmt),
         }
     }
 }
@@ -67,8 +69,9 @@ impl error::Error for DecoderError {
             DecoderError::InvalidArrayKey(_, _) => "invalid array key",
             DecoderError::ExpectedField(_) => "expected a field",
             DecoderError::UnknownField(_) => "found an unknown field",
-            DecoderError::SyntaxError => "syntax error",
+            DecoderError::SyntaxError(ref inner) => inner,
             DecoderError::EndOfStream => "end of stream",
+            DecoderError::Unknown(ref inner) => inner,
         }
     }
     fn cause(&self) -> Option<&error::Error> {
@@ -81,8 +84,12 @@ impl error::Error for DecoderError {
 }
 
 impl de::Error for DecoderError {
-    fn syntax(_: &str) -> DecoderError {
-        DecoderError::SyntaxError
+    fn custom<T: Into<String>>(msg: T) -> DecoderError {
+        DecoderError::Unknown(msg.into())
+    }
+
+    fn invalid_value(msg: &str) -> DecoderError {
+        DecoderError::SyntaxError(msg.to_owned())
     }
 
     fn end_of_stream() -> DecoderError {
diff --git a/src/decoder/serde.rs b/src/decoder/serde.rs
@@ -15,11 +15,11 @@ impl Deserialize for ObjectId {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit_map(BsonVisitor)
+        deserializer.deserialize_map(BsonVisitor)
             .and_then(|bson| if let Bson::ObjectId(oid) = bson {
                 Ok(oid)
             } else {
-                Err(de::Error::syntax(&format!("expected objectId extended document, found {}", bson)))
+                Err(de::Error::invalid_value(&format!("expected objectId extended document, found {}", bson)))
             })
     }
 }
@@ -29,11 +29,11 @@ impl Deserialize for OrderedDocument {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit_map(BsonVisitor)
+        deserializer.deserialize_map(BsonVisitor)
             .and_then(|bson| if let Bson::Document(doc) = bson {
                 Ok(doc)
             } else {
-                Err(de::Error::syntax(&format!("expected document, found extended JSON data type: {}", bson)))
+                Err(de::Error::invalid_value(&format!("expected document, found extended JSON data type: {}", bson)))
             })
     }
 }
@@ -43,7 +43,7 @@ impl Deserialize for Bson {
     fn deserialize<D>(deserializer: &mut D) -> Result<Bson, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit(BsonVisitor)
+        deserializer.deserialize(BsonVisitor)
     }
 }
 
@@ -149,7 +149,7 @@ impl Deserializer for Decoder {
     type Error = DecoderError;
 
     #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         let value = match self.value.take() {
@@ -195,7 +195,7 @@ impl Deserializer for Decoder {
     }
 
     #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         match self.value {
@@ -206,28 +206,28 @@ impl Deserializer for Decoder {
     }
 
     #[inline]
-    fn visit_enum<V>(&mut self,
+    fn deserialize_enum<V>(&mut self,
                      _name: &str,
                      _variants: &'static [&'static str],
                      mut visitor: V) -> DecoderResult<V::Value>
         where V: EnumVisitor,
     {
         let value = match self.value.take() {
             Some(Bson::Document(value)) => value,
-            Some(_) => { return Err(de::Error::syntax("expected an enum")); }
+            Some(_) => { return Err(de::Error::invalid_value("expected an enum")); }
             None => { return Err(de::Error::end_of_stream()); }
         };
 
         let mut iter = value.into_iter();
 
         let (variant, value) = match iter.next() {
             Some(v) => v,
-            None => return Err(de::Error::syntax("expected a variant name")),
+            None => return Err(de::Error::invalid_value("expected a variant name")),
         };
 
         // enums are encoded in json as maps with a single key:value pair
         match iter.next() {
-            Some(_) => Err(de::Error::syntax("expected map")),
+            Some(_) => Err(de::Error::invalid_value("expected map")),
             None => visitor.visit(VariantDecoder {
                 de: self,
                 val: Some(value),
@@ -237,18 +237,13 @@ impl Deserializer for Decoder {
     }
 
     #[inline]
-    fn visit_newtype_struct<V>(&mut self,
+    fn deserialize_newtype_struct<V>(&mut self,
                                _name: &'static str,
                                mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         visitor.visit_newtype_struct(self)
     }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
 }
 
 struct VariantDecoder<'a> {
@@ -286,7 +281,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
     {
         if let Bson::Array(fields) = try!(self.val.take()
                                           .ok_or(DecoderError::EndOfStream)) {
-            Deserializer::visit(
+            Deserializer::deserialize(
                 &mut SeqDecoder {
                     de: self.de,
                     len: fields.len(),
@@ -295,7 +290,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
                 visitor,
             )
         } else {
-            Err(de::Error::syntax("expected a tuple"))
+            Err(de::Error::invalid_value("expected a tuple"))
         }
     }
 
@@ -306,7 +301,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
     {
         if let Bson::Document(fields) = try!(self.val.take()
                                              .ok_or(DecoderError::EndOfStream)) {
-            Deserializer::visit(
+            Deserializer::deserialize(
                 &mut MapDecoder {
                     de: self.de,
                     len: fields.len(),
@@ -316,7 +311,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {
                 visitor,
             )
         } else {
-            Err(de::Error::syntax("expected a struct"))
+            Err(de::Error::invalid_value("expected a struct"))
         }
     }
 }
@@ -331,7 +326,7 @@ impl<'a> Deserializer for SeqDecoder<'a> {
     type Error = DecoderError;
 
     #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         if self.len == 0 {
@@ -362,7 +357,7 @@ impl<'a> SeqVisitor for SeqDecoder<'a> {
         if self.len == 0 {
             Ok(())
         } else {
-            Err(de::Error::length_mismatch(self.len))
+            Err(de::Error::invalid_length(self.len))
         }
     }
 
@@ -422,13 +417,13 @@ impl<'a> MapVisitor for MapDecoder<'a> {
         impl Deserializer for UnitDecoder {
             type Error = DecoderError;
 
-            fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+            fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
                 where V: Visitor,
             {
                 visitor.visit_unit()
             }
 
-            fn visit_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+            fn deserialize_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
                 where V: Visitor,
             {
                 visitor.visit_none()
@@ -447,7 +442,7 @@ impl<'a> Deserializer for MapDecoder<'a> {
     type Error = DecoderError;
 
     #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
+    fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>
         where V: Visitor,
     {
         visitor.visit_map(self)
diff --git a/src/encoder/error.rs b/src/encoder/error.rs
@@ -1,5 +1,6 @@
 use std::{io, error, fmt};
 use byteorder;
+use serde::ser;
 use super::serde::State;
 
 /// Possible errors that can arise during encoding.
@@ -9,6 +10,7 @@ pub enum EncoderError {
     InvalidMapKeyType(State),
     InvalidState(State),
     EmptyState,
+    Unknown(String),
 }
 
 impl From<io::Error> for EncoderError {
@@ -30,6 +32,7 @@ impl fmt::Display for EncoderError {
             &EncoderError::InvalidMapKeyType(ref inner) => write!(fmt, "Invalid map key type: {:?}", inner),
             &EncoderError::InvalidState(ref inner) => write!(fmt, "Invalid state emitted: {:?}", inner),
             &EncoderError::EmptyState => write!(fmt, "No state emitted"),
+            &EncoderError::Unknown(ref inner) => inner.fmt(fmt),
         }
     }
 }
@@ -41,6 +44,7 @@ impl error::Error for EncoderError {
             &EncoderError::InvalidMapKeyType(_) => "Invalid map key type",
             &EncoderError::InvalidState(_) => "Invalid state emitted",
             &EncoderError::EmptyState => "No state emitted",
+            &EncoderError::Unknown(ref inner) => inner,
         }
     }
     fn cause(&self) -> Option<&error::Error> {
@@ -51,5 +55,11 @@ impl error::Error for EncoderError {
     }
 }
 
+impl ser::Error for EncoderError {
+    fn custom<T: Into<String>>(msg: T) -> EncoderError {
+        EncoderError::Unknown(msg.into())
+    }
+}
+
 /// Alias for `Result<T, EncoderError>`.
 pub type EncoderResult<T> = Result<T, EncoderError>;
diff --git a/src/encoder/serde.rs b/src/encoder/serde.rs

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ fn application_decode_error() {`
`121`	`121`	`fn deserialize<D: Deserializer>(d: &mut D) -> Result<Range10, D::Error> {`
`122`	`122`	`let x: usize = try!(Deserialize::deserialize(d));`
`123`	`123`	`if x > 10 {`
`124`		`- Err(serde::de::Error::syntax("more than 10"))`
	`124`	`+ Err(serde::de::Error::invalid_value("more than 10"))`
`125`	`125`	`} else {`
`126`	`126`	`Ok(Range10(x))`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,10 @@ pub enum DecoderError {`
`14`	`14`	`// An unexpected field was found.`
`15`	`15`	`UnknownField(String),`
`16`	`16`	`// There was an error with the syntactical structure of the BSON.`
`17`		`- SyntaxError,`
	`17`	`+ SyntaxError(String),`
`18`	`18`	`// The end of the BSON input was reached too soon.`
`19`	`19`	`EndOfStream,`
	`20`	`+ Unknown(String),`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`impl From<io::Error> for DecoderError {`
`@@ -52,8 +53,9 @@ impl fmt::Display for DecoderError {`
`52`	`53`	write!(fmt, "expected a field of type `{}`", field_type)
`53`	`54`	`}`
`54`	`55`	DecoderError::UnknownField(ref field) => write!(fmt, "unknown field `{}`", field),
`55`		`- DecoderError::SyntaxError => write!(fmt, "syntax error"),`
	`56`	`+ DecoderError::SyntaxError(ref inner) => inner.fmt(fmt),`
`56`	`57`	`DecoderError::EndOfStream => write!(fmt, "end of stream"),`
	`58`	`+ DecoderError::Unknown(ref inner) => inner.fmt(fmt),`
`57`	`59`	`}`
`58`	`60`	`}`
`59`	`61`	`}`
`@@ -67,8 +69,9 @@ impl error::Error for DecoderError {`
`67`	`69`	`DecoderError::InvalidArrayKey(_, _) => "invalid array key",`
`68`	`70`	`DecoderError::ExpectedField(_) => "expected a field",`
`69`	`71`	`DecoderError::UnknownField(_) => "found an unknown field",`
`70`		`- DecoderError::SyntaxError => "syntax error",`
	`72`	`+ DecoderError::SyntaxError(ref inner) => inner,`
`71`	`73`	`DecoderError::EndOfStream => "end of stream",`
	`74`	`+ DecoderError::Unknown(ref inner) => inner,`
`72`	`75`	`}`
`73`	`76`	`}`
`74`	`77`	`fn cause(&self) -> Option<&error::Error> {`
`@@ -81,8 +84,12 @@ impl error::Error for DecoderError {`
`81`	`84`	`}`
`82`	`85`
`83`	`86`	`impl de::Error for DecoderError {`
`84`		`- fn syntax(_: &str) -> DecoderError {`
`85`		`- DecoderError::SyntaxError`
	`87`	`+ fn custom<T: Into<String>>(msg: T) -> DecoderError {`
	`88`	`+ DecoderError::Unknown(msg.into())`
	`89`	`+ }`
	`90`	`+`
	`91`	`+ fn invalid_value(msg: &str) -> DecoderError {`
	`92`	`+ DecoderError::SyntaxError(msg.to_owned())`
`86`	`93`	`}`
`87`	`94`
`88`	`95`	`fn end_of_stream() -> DecoderError {`
Original file line number	Diff line number	Diff line change
`@@ -15,11 +15,11 @@ impl Deserialize for ObjectId {`
`15`	`15`	`fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>`
`16`	`16`	`where D: Deserializer,`
`17`	`17`	`{`
`18`		`- deserializer.visit_map(BsonVisitor)`
	`18`	`+ deserializer.deserialize_map(BsonVisitor)`
`19`	`19`	`.and_then(\|bson\| if let Bson::ObjectId(oid) = bson {`
`20`	`20`	`Ok(oid)`
`21`	`21`	`} else {`
`22`		`- Err(de::Error::syntax(&format!("expected objectId extended document, found {}", bson)))`
	`22`	`+ Err(de::Error::invalid_value(&format!("expected objectId extended document, found {}", bson)))`
`23`	`23`	`})`
`24`	`24`	`}`
`25`	`25`	`}`
`@@ -29,11 +29,11 @@ impl Deserialize for OrderedDocument {`
`29`	`29`	`fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>`
`30`	`30`	`where D: Deserializer,`
`31`	`31`	`{`
`32`		`- deserializer.visit_map(BsonVisitor)`
	`32`	`+ deserializer.deserialize_map(BsonVisitor)`
`33`	`33`	`.and_then(\|bson\| if let Bson::Document(doc) = bson {`
`34`	`34`	`Ok(doc)`
`35`	`35`	`} else {`
`36`		`- Err(de::Error::syntax(&format!("expected document, found extended JSON data type: {}", bson)))`
	`36`	`+ Err(de::Error::invalid_value(&format!("expected document, found extended JSON data type: {}", bson)))`
`37`	`37`	`})`
`38`	`38`	`}`
`39`	`39`	`}`
`@@ -43,7 +43,7 @@ impl Deserialize for Bson {`
`43`	`43`	`fn deserialize<D>(deserializer: &mut D) -> Result<Bson, D::Error>`
`44`	`44`	`where D: Deserializer,`
`45`	`45`	`{`
`46`		`- deserializer.visit(BsonVisitor)`
	`46`	`+ deserializer.deserialize(BsonVisitor)`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`@@ -149,7 +149,7 @@ impl Deserializer for Decoder {`
`149`	`149`	`type Error = DecoderError;`
`150`	`150`
`151`	`151`	`#[inline]`
`152`		`- fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
	`152`	`+ fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
`153`	`153`	`where V: Visitor,`
`154`	`154`	`{`
`155`	`155`	`let value = match self.value.take() {`
`@@ -195,7 +195,7 @@ impl Deserializer for Decoder {`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`#[inline]`
`198`		`- fn visit_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
	`198`	`+ fn deserialize_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
`199`	`199`	`where V: Visitor,`
`200`	`200`	`{`
`201`	`201`	`match self.value {`
`@@ -206,28 +206,28 @@ impl Deserializer for Decoder {`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`#[inline]`
`209`		`- fn visit_enum<V>(&mut self,`
	`209`	`+ fn deserialize_enum<V>(&mut self,`
`210`	`210`	`_name: &str,`
`211`	`211`	`_variants: &'static [&'static str],`
`212`	`212`	`mut visitor: V) -> DecoderResult<V::Value>`
`213`	`213`	`where V: EnumVisitor,`
`214`	`214`	`{`
`215`	`215`	`let value = match self.value.take() {`
`216`	`216`	`Some(Bson::Document(value)) => value,`
`217`		`- Some(_) => { return Err(de::Error::syntax("expected an enum")); }`
	`217`	`+ Some(_) => { return Err(de::Error::invalid_value("expected an enum")); }`
`218`	`218`	`None => { return Err(de::Error::end_of_stream()); }`
`219`	`219`	`};`
`220`	`220`
`221`	`221`	`let mut iter = value.into_iter();`
`222`	`222`
`223`	`223`	`let (variant, value) = match iter.next() {`
`224`	`224`	`Some(v) => v,`
`225`		`- None => return Err(de::Error::syntax("expected a variant name")),`
	`225`	`+ None => return Err(de::Error::invalid_value("expected a variant name")),`
`226`	`226`	`};`
`227`	`227`
`228`	`228`	`// enums are encoded in json as maps with a single key:value pair`
`229`	`229`	`match iter.next() {`
`230`		`- Some(_) => Err(de::Error::syntax("expected map")),`
	`230`	`+ Some(_) => Err(de::Error::invalid_value("expected map")),`
`231`	`231`	`None => visitor.visit(VariantDecoder {`
`232`	`232`	`de: self,`
`233`	`233`	`val: Some(value),`
`@@ -237,18 +237,13 @@ impl Deserializer for Decoder {`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`#[inline]`
`240`		`- fn visit_newtype_struct<V>(&mut self,`
	`240`	`+ fn deserialize_newtype_struct<V>(&mut self,`
`241`	`241`	`_name: &'static str,`
`242`	`242`	`mut visitor: V) -> DecoderResult<V::Value>`
`243`	`243`	`where V: Visitor,`
`244`	`244`	`{`
`245`	`245`	`visitor.visit_newtype_struct(self)`
`246`	`246`	`}`
`247`		`-`
`248`		`- #[inline]`
`249`		`- fn format() -> &'static str {`
`250`		`- "json"`
`251`		`- }`
`252`	`247`	`}`
`253`	`248`
`254`	`249`	`struct VariantDecoder<'a> {`
`@@ -286,7 +281,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {`
`286`	`281`	`{`
`287`	`282`	`if let Bson::Array(fields) = try!(self.val.take()`
`288`	`283`	`.ok_or(DecoderError::EndOfStream)) {`
`289`		`- Deserializer::visit(`
	`284`	`+ Deserializer::deserialize(`
`290`	`285`	`&mut SeqDecoder {`
`291`	`286`	`de: self.de,`
`292`	`287`	`len: fields.len(),`
`@@ -295,7 +290,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {`
`295`	`290`	`visitor,`
`296`	`291`	`)`
`297`	`292`	`} else {`
`298`		`- Err(de::Error::syntax("expected a tuple"))`
	`293`	`+ Err(de::Error::invalid_value("expected a tuple"))`
`299`	`294`	`}`
`300`	`295`	`}`
`301`	`296`
`@@ -306,7 +301,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {`
`306`	`301`	`{`
`307`	`302`	`if let Bson::Document(fields) = try!(self.val.take()`
`308`	`303`	`.ok_or(DecoderError::EndOfStream)) {`
`309`		`- Deserializer::visit(`
	`304`	`+ Deserializer::deserialize(`
`310`	`305`	`&mut MapDecoder {`
`311`	`306`	`de: self.de,`
`312`	`307`	`len: fields.len(),`
`@@ -316,7 +311,7 @@ impl<'a> VariantVisitor for VariantDecoder<'a> {`
`316`	`311`	`visitor,`
`317`	`312`	`)`
`318`	`313`	`} else {`
`319`		`- Err(de::Error::syntax("expected a struct"))`
	`314`	`+ Err(de::Error::invalid_value("expected a struct"))`
`320`	`315`	`}`
`321`	`316`	`}`
`322`	`317`	`}`
`@@ -331,7 +326,7 @@ impl<'a> Deserializer for SeqDecoder<'a> {`
`331`	`326`	`type Error = DecoderError;`
`332`	`327`
`333`	`328`	`#[inline]`
`334`		`- fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
	`329`	`+ fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
`335`	`330`	`where V: Visitor,`
`336`	`331`	`{`
`337`	`332`	`if self.len == 0 {`
`@@ -362,7 +357,7 @@ impl<'a> SeqVisitor for SeqDecoder<'a> {`
`362`	`357`	`if self.len == 0 {`
`363`	`358`	`Ok(())`
`364`	`359`	`} else {`
`365`		`- Err(de::Error::length_mismatch(self.len))`
	`360`	`+ Err(de::Error::invalid_length(self.len))`
`366`	`361`	`}`
`367`	`362`	`}`
`368`	`363`
`@@ -422,13 +417,13 @@ impl<'a> MapVisitor for MapDecoder<'a> {`
`422`	`417`	`impl Deserializer for UnitDecoder {`
`423`	`418`	`type Error = DecoderError;`
`424`	`419`
`425`		`- fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
	`420`	`+ fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
`426`	`421`	`where V: Visitor,`
`427`	`422`	`{`
`428`	`423`	`visitor.visit_unit()`
`429`	`424`	`}`
`430`	`425`
`431`		`- fn visit_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
	`426`	`+ fn deserialize_option<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
`432`	`427`	`where V: Visitor,`
`433`	`428`	`{`
`434`	`429`	`visitor.visit_none()`
`@@ -447,7 +442,7 @@ impl<'a> Deserializer for MapDecoder<'a> {`
`447`	`442`	`type Error = DecoderError;`
`448`	`443`
`449`	`444`	`#[inline]`
`450`		`- fn visit<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
	`445`	`+ fn deserialize<V>(&mut self, mut visitor: V) -> DecoderResult<V::Value>`
`451`	`446`	`where V: Visitor,`
`452`	`447`	`{`
`453`	`448`	`visitor.visit_map(self)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`use std::{io, error, fmt};`
`2`	`2`	`use byteorder;`
	`3`	`+use serde::ser;`
`3`	`4`	`use super::serde::State;`
`4`	`5`
`5`	`6`	`/// Possible errors that can arise during encoding.`
`@@ -9,6 +10,7 @@ pub enum EncoderError {`
`9`	`10`	`InvalidMapKeyType(State),`
`10`	`11`	`InvalidState(State),`
`11`	`12`	`EmptyState,`
	`13`	`+ Unknown(String),`
`12`	`14`	`}`
`13`	`15`
`14`	`16`	`impl From<io::Error> for EncoderError {`
`@@ -30,6 +32,7 @@ impl fmt::Display for EncoderError {`
`30`	`32`	`&EncoderError::InvalidMapKeyType(ref inner) => write!(fmt, "Invalid map key type: {:?}", inner),`
`31`	`33`	`&EncoderError::InvalidState(ref inner) => write!(fmt, "Invalid state emitted: {:?}", inner),`
`32`	`34`	`&EncoderError::EmptyState => write!(fmt, "No state emitted"),`
	`35`	`+ &EncoderError::Unknown(ref inner) => inner.fmt(fmt),`
`33`	`36`	`}`
`34`	`37`	`}`
`35`	`38`	`}`
`@@ -41,6 +44,7 @@ impl error::Error for EncoderError {`
`41`	`44`	`&EncoderError::InvalidMapKeyType(_) => "Invalid map key type",`
`42`	`45`	`&EncoderError::InvalidState(_) => "Invalid state emitted",`
`43`	`46`	`&EncoderError::EmptyState => "No state emitted",`
	`47`	`+ &EncoderError::Unknown(ref inner) => inner,`
`44`	`48`	`}`
`45`	`49`	`}`
`46`	`50`	`fn cause(&self) -> Option<&error::Error> {`
`@@ -51,5 +55,11 @@ impl error::Error for EncoderError {`
`51`	`55`	`}`
`52`	`56`	`}`
`53`	`57`
	`58`	`+impl ser::Error for EncoderError {`
	`59`	`+ fn custom<T: Into<String>>(msg: T) -> EncoderError {`
	`60`	`+ EncoderError::Unknown(msg.into())`
	`61`	`+ }`
	`62`	`+}`
	`63`	`+`
`54`	`64`	/// Alias for `Result<T, EncoderError>`.
`55`	`65`	`pub type EncoderResult<T> = Result<T, EncoderError>;`