Merge branch 'master' of github.com:TyOverby/bincode

Cargo.toml

@@ -14,10 +14,10 @@ description = "A binary serialization / deserialization strategy and implementat
 rustc-serialize = { version = "0.3.*", optional = true }
 byteorder = "0.5.*"
 num-traits = "0.1.32"
-serde = { version = "0.7.*", optional = true }
+serde = { version = "0.8.*", optional = true }
 
 [dev-dependencies]
-serde_macros = "0.7.*"
+serde_macros = "0.8.*"
 
 [features]
 default = ["rustc-serialize", "serde"]

src/serde/reader.rs

@@ -138,9 +138,7 @@ impl<'a, R: Read> Deserializer<'a, R> {
     pub fn bytes_read(&self) -> u64 {
         self.read
     }
-}
 
-impl <'a, A> Deserializer<'a, A> {
     fn read_bytes(&mut self, count: u64) -> Result<(), DeserializeError> {
         self.read += count;
         match self.size_limit {
@@ -154,6 +152,20 @@ impl <'a, A> Deserializer<'a, A> {
         use std::mem::size_of;
         self.read_bytes(size_of::<T>() as u64)
     }
+
+    fn read_string(&mut self) -> DeserializeResult<String> {
+        let len = try!(serde::Deserialize::deserialize(self));
+        try!(self.read_bytes(len));
+
+        let mut buffer = Vec::new();
+        try!(self.reader.by_ref().take(len as u64).read_to_end(&mut buffer));
+
+        String::from_utf8(buffer).map_err(|err|
+            DeserializeError::InvalidEncoding(InvalidEncoding {
+                desc: "error while decoding utf8 string",
+                detail: Some(format!("Deserialize error: {}", err))
+            }))
+    }
 }
 
 macro_rules! impl_nums {
@@ -291,22 +303,22 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         visitor.visit_char(res)
     }
 
+    fn deserialize_str<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
+        visitor.visit_str(&try!(self.read_string()))
+    }
+
     fn deserialize_string<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
-        let len = try!(serde::Deserialize::deserialize(self));
+        visitor.visit_string(try!(self.read_string()))
-        try!(self.read_bytes(len));
-
-        let mut buffer = Vec::new();
-        try!(self.reader.by_ref().take(len as u64).read_to_end(&mut buffer));
-
-        match String::from_utf8(buffer) {
-            Ok(s) => visitor.visit_string(s),
-            Err(err) => Err(DeserializeError::InvalidEncoding(InvalidEncoding {
-                desc: "error while decoding utf8 string",
-                detail: Some(format!("Deserialize error: {}", err))
-            })),
     }
+
+    fn deserialize_bytes<V>(&mut self, visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
+        self.deserialize_seq(visitor)
     }
 
     fn deserialize_enum<V>(&mut self,
@@ -343,7 +355,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         visitor.visit_seq(TupleVisitor(self))
     }
 
-    fn deserialize_fixed_size_array<V>(&mut self,
+    fn deserialize_seq_fixed_size<V>(&mut self,
                             _: usize,
                             visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
@@ -455,13 +467,46 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
         self.deserialize_tuple(fields.len(), visitor)
     }
 
+    fn deserialize_struct_field<V>(&mut self,
+                                   _visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
+        let message = "bincode does not support Deserializer::deserialize_struct_field";
+        Err(DeserializeError::Serde(serde::de::value::Error::Custom(message.into())))
+    }
+
     fn deserialize_newtype_struct<V>(&mut self,
                                _name: &str,
-                               mut visitor: V) -> Result<V::Value, Self::Error>
+                               mut visitor: V) -> DeserializeResult<V::Value>
         where V: serde::de::Visitor,
     {
         visitor.visit_newtype_struct(self)
     }
+
+    fn deserialize_unit_struct<V>(&mut self,
+                                  _name: &'static str,
+                                  mut visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_tuple_struct<V>(&mut self,
+                                   _name: &'static str,
+                                   len: usize,
+                                   visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
+        self.deserialize_tuple(len, visitor)
+    }
+
+    fn deserialize_ignored_any<V>(&mut self,
+                                  _visitor: V) -> DeserializeResult<V::Value>
+        where V: serde::de::Visitor,
+    {
+        let message = "bincode does not support Deserializer::deserialize_ignored_any";
+        Err(DeserializeError::Serde(serde::de::value::Error::Custom(message.into())))
+    }
 }
 
 impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {

src/serde/writer.rs

@@ -89,9 +89,18 @@ impl<'a, W: Write> Serializer<'a, W> {
 
 impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
     type Error = SerializeError;
+    type SeqState = ();
+    type TupleState = ();
+    type TupleStructState = ();
+    type TupleVariantState = ();
+    type MapState = ();
+    type StructState = ();
+    type StructVariantState = ();
 
     fn serialize_unit(&mut self) -> SerializeResult<()> { Ok(()) }
 
+    fn serialize_unit_struct(&mut self, _: &'static str) -> SerializeResult<()> { Ok(()) }
+
     fn serialize_bool(&mut self, v: bool) -> SerializeResult<()> {
         self.writer.write_u8(if v {1} else {0}).map_err(wrap_io)
     }
@@ -112,6 +121,10 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         self.writer.write_u64::<BigEndian>(v).map_err(wrap_io)
     }
 
+    fn serialize_usize(&mut self, v: usize) -> SerializeResult<()> {
+        self.serialize_u64(v as u64)
+    }
+
     fn serialize_i8(&mut self, v: i8) -> SerializeResult<()> {
         self.writer.write_i8(v).map_err(wrap_io)
     }
@@ -128,6 +141,10 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         self.writer.write_i64::<BigEndian>(v).map_err(wrap_io)
     }
 
+    fn serialize_isize(&mut self, v: isize) -> SerializeResult<()> {
+        self.serialize_i64(v as i64)
+    }
+
     fn serialize_f32(&mut self, v: f32) -> SerializeResult<()> {
         self.writer.write_f32::<BigEndian>(v).map_err(wrap_io)
     }
@@ -145,6 +162,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         self.writer.write_all(encode_utf8(c).as_slice()).map_err(SerializeError::IoError)
     }
 
+    fn serialize_bytes(&mut self, v: &[u8]) -> SerializeResult<()> {
+        let mut state = try!(self.serialize_seq(Some(v.len())));
+        for c in v {
+            try!(self.serialize_seq_elt(&mut state, c));
+        }
+        self.serialize_seq_end(state)
+    }
+
     fn serialize_none(&mut self) -> SerializeResult<()> {
         self.writer.write_u8(0).map_err(wrap_io)
     }
@@ -156,114 +181,151 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         v.serialize(self)
     }
 
-    fn serialize_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq(&mut self, len: Option<usize>) -> SerializeResult<()> {
-        where V: serde::ser::SeqVisitor,
+        let len = len.expect("do not know how to serialize a sequence with no length");
-    {
+        self.serialize_usize(len)
-        let len = match visitor.len() {
-            Some(len) => len,
-            None => panic!("do not know how to serialize a sequence with no length"),
-        };
-
-        try!(self.serialize_usize(len));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
     }
 
-    fn serialize_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
-        where V: serde::ser::SeqVisitor,
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
-    }
-
-    fn serialize_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq_end(&mut self, _: ()) -> SerializeResult<()> {
-        where V: serde::ser::MapVisitor,
-    {
-        let len = match visitor.len() {
-            Some(len) => len,
-            None => panic!("do not know how to serialize a map with no length"),
-        };
-
-        try!(self.serialize_usize(len));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
         Ok(())
     }
 
-    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
+    fn serialize_seq_fixed_size(&mut self, len: usize) -> SerializeResult<()> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple(&mut self, _len: usize) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_tuple_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_tuple_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_tuple_struct(&mut self, _name: &'static str, _len: usize) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_tuple_struct_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_tuple_struct_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_tuple_variant(&mut self,
+                              _name: &'static str,
+                              variant_index: usize,
+                              _variant: &'static str,
+                              _len: usize) -> SerializeResult<()>
+    {
+        self.add_enum_tag(variant_index)
+    }
+
+    fn serialize_tuple_variant_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_tuple_variant_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_map(&mut self, len: Option<usize>) -> SerializeResult<()> {
+        let len = len.expect("do not know how to serialize a map with no length");
+        self.serialize_usize(len)
+    }
+
+    fn serialize_map_key<K>(&mut self, _: &mut (), key: K) -> SerializeResult<()>
         where K: serde::Serialize,
-              V: serde::Serialize,
     {
-        try!(key.serialize(self));
+        key.serialize(self)
-        value.serialize(self)
     }
 
-    fn serialize_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
+    fn serialize_map_value<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
-        where V: serde::ser::MapVisitor,
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
-    }
-
-    fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
+    fn serialize_map_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_struct(&mut self, _name: &'static str, _len: usize) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_struct_elt<V>(&mut self, _: &mut (), _key: &'static str, value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_struct_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_struct_variant(&mut self,
+                               _name: &'static str,
+                               variant_index: usize,
+                               _variant: &'static str,
+                               _len: usize) -> SerializeResult<()>
+    {
+        self.add_enum_tag(variant_index)
+    }
+
+    fn serialize_struct_variant_elt<V>(&mut self, _: &mut (), _key: &'static str, value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_struct_variant_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
     fn serialize_newtype_struct<T>(&mut self,
-                               _name: &str,
+                               _name: &'static str,
                                value: T) -> SerializeResult<()>
         where T: serde::ser::Serialize,
     {
         value.serialize(self)
     }
 
+    fn serialize_newtype_variant<T>(&mut self,
+                               _name: &'static str,
+                               variant_index: usize,
+                               _variant: &'static str,
+                               value: T) -> SerializeResult<()>
+        where T: serde::ser::Serialize,
+    {
+        try!(self.add_enum_tag(variant_index));
+        value.serialize(self)
+    }
+
     fn serialize_unit_variant(&mut self,
-                          _name: &str,
+                          _name: &'static str,
                           variant_index: usize,
-                          _variant: &str) -> SerializeResult<()> {
+                          _variant: &'static str) -> SerializeResult<()> {
         self.add_enum_tag(variant_index)
     }
-
-    fn serialize_tuple_variant<V>(&mut self,
-                              _name: &str,
-                              variant_index: usize,
-                              _variant: &str,
-                              mut visitor: V) -> SerializeResult<()>
-        where V: serde::ser::SeqVisitor,
-    {
-        try!(self.add_enum_tag(variant_index));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
-    }
-
-    fn serialize_struct_variant<V>(&mut self,
-                               _name: &str,
-                               variant_index: usize,
-                               _variant: &str,
-                               mut visitor: V) -> SerializeResult<()>
-        where V: serde::ser::MapVisitor,
-    {
-        try!(self.add_enum_tag(variant_index));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
-    }
 }
 
 pub struct SizeChecker {
@@ -304,9 +366,18 @@ impl SizeChecker {
 
 impl serde::Serializer for SizeChecker {
     type Error = SerializeError;
+    type SeqState = ();
+    type TupleState = ();
+    type TupleStructState = ();
+    type TupleVariantState = ();
+    type MapState = ();
+    type StructState = ();
+    type StructVariantState = ();
 
     fn serialize_unit(&mut self) -> SerializeResult<()> { Ok(()) }
 
+    fn serialize_unit_struct(&mut self, _: &'static str) -> SerializeResult<()> { Ok(()) }
+
     fn serialize_bool(&mut self, _: bool) -> SerializeResult<()> {
         self.add_value(0 as u8)
     }
@@ -327,6 +398,10 @@ impl serde::Serializer for SizeChecker {
         self.add_value(v)
     }
 
+    fn serialize_usize(&mut self, v: usize) -> SerializeResult<()> {
+        self.serialize_u64(v as u64)
+    }
+
     fn serialize_i8(&mut self, v: i8) -> SerializeResult<()> {
         self.add_value(v)
     }
@@ -343,6 +418,10 @@ impl serde::Serializer for SizeChecker {
         self.add_value(v)
     }
 
+    fn serialize_isize(&mut self, v: isize) -> SerializeResult<()> {
+        self.serialize_i64(v as i64)
+    }
+
     fn serialize_f32(&mut self, v: f32) -> SerializeResult<()> {
         self.add_value(v)
     }
@@ -360,6 +439,14 @@ impl serde::Serializer for SizeChecker {
         self.add_raw(encode_utf8(c).as_slice().len())
     }
 
+    fn serialize_bytes(&mut self, v: &[u8]) -> SerializeResult<()> {
+        let mut state = try!(self.serialize_seq(Some(v.len())));
+        for c in v {
+            try!(self.serialize_seq_elt(&mut state, c));
+        }
+        self.serialize_seq_end(state)
+    }
+
     fn serialize_none(&mut self) -> SerializeResult<()> {
         self.add_value(0 as u8)
     }
@@ -371,105 +458,148 @@ impl serde::Serializer for SizeChecker {
         v.serialize(self)
     }
 
-    fn serialize_seq<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq(&mut self, len: Option<usize>) -> SerializeResult<()> {
-        where V: serde::ser::SeqVisitor,
+        let len = len.expect("do not know how to serialize a sequence with no length");
-    {
-        let len = match visitor.len() {
-            Some(len) => len,
-            None => panic!("do not know how to serialize a sequence with no length"),
-        };
 
-        try!(self.serialize_usize(len));
+        self.serialize_usize(len)
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
     }
 
-    fn serialize_tuple<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
-        where V: serde::ser::SeqVisitor,
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
-    }
-
-    fn serialize_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_map<V>(&mut self, mut visitor: V) -> SerializeResult<()>
+    fn serialize_seq_end(&mut self, _: ()) -> SerializeResult<()> {
-        where V: serde::ser::MapVisitor,
-    {
-        let len = match visitor.len() {
-            Some(len) => len,
-            None => panic!("do not know how to serialize a map with no length"),
-        };
-
-        try!(self.serialize_usize(len));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
         Ok(())
     }
 
-    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> SerializeResult<()>
+    fn serialize_seq_fixed_size(&mut self, len: usize) -> SerializeResult<()> {
-        where K: serde::Serialize,
+        self.serialize_seq(Some(len))
-              V: serde::Serialize,
-    {
-        try!(key.serialize(self));
-        value.serialize(self)
     }
 
-    fn serialize_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
+    fn serialize_tuple(&mut self, _len: usize) -> SerializeResult<()> {
-        where V: serde::ser::MapVisitor,
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
         Ok(())
     }
 
-    fn serialize_struct_elt<V>(&mut self, _key: &str, value: V) -> SerializeResult<()>
+    fn serialize_tuple_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
         where V: serde::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_unit_variant(&mut self,
+    fn serialize_tuple_end(&mut self, _: ()) -> SerializeResult<()> {
-                          _name: &str,
+        Ok(())
+    }
+
+    fn serialize_tuple_struct(&mut self, _name: &'static str, _len: usize) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_tuple_struct_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_tuple_struct_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_tuple_variant(&mut self,
+                         _name: &'static str,
                          variant_index: usize,
-                          _variant: &str) -> SerializeResult<()> {
+                         _variant: &'static str,
+                         _len: usize) -> SerializeResult<()>
+    {
         self.add_enum_tag(variant_index)
     }
 
-    fn serialize_tuple_variant<V>(&mut self,
+    fn serialize_tuple_variant_elt<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
-                         _name: &str,
+        where V: serde::Serialize,
-                         variant_index: usize,
-                         _variant: &str,
-                         mut visitor: V) -> SerializeResult<()>
-        where V: serde::ser::SeqVisitor,
     {
-        try!(self.add_enum_tag(variant_index));
+        value.serialize(self)
-
+    }
-        while let Some(()) = try!(visitor.visit(self)) { }
 
+    fn serialize_tuple_variant_end(&mut self, _: ()) -> SerializeResult<()> {
         Ok(())
     }
 
-    fn serialize_struct_variant<V>(&mut self,
+    fn serialize_map(&mut self, len: Option<usize>) -> SerializeResult<()>
-                               _name: &str,
+    {
+        let len = len.expect("do not know how to serialize a map with no length");
+
+        self.serialize_usize(len)
+    }
+
+    fn serialize_map_key<K>(&mut self, _: &mut (), key: K) -> SerializeResult<()>
+        where K: serde::Serialize,
+    {
+        key.serialize(self)
+    }
+
+    fn serialize_map_value<V>(&mut self, _: &mut (), value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_map_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_struct(&mut self, _name: &'static str, _len: usize) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_struct_elt<V>(&mut self, _: &mut (), _key: &'static str, value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_struct_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_struct_variant(&mut self,
+                               _name: &'static str,
                                variant_index: usize,
-                               _variant: &str,
+                               _variant: &'static str,
-                               mut visitor: V) -> SerializeResult<()>
+                               _len: usize) -> SerializeResult<()>
-        where V: serde::ser::MapVisitor,
+    {
+        self.add_enum_tag(variant_index)
+    }
+
+    fn serialize_struct_variant_elt<V>(&mut self, _: &mut (), _field: &'static str, value: V) -> SerializeResult<()>
+        where V: serde::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_struct_variant_end(&mut self, _: ()) -> SerializeResult<()> {
+        Ok(())
+    }
+
+    fn serialize_newtype_struct<V: serde::Serialize>(&mut self, _name: &'static str, v: V) -> SerializeResult<()> {
+        v.serialize(self)
+    }
+
+    fn serialize_unit_variant(&mut self,
+                          _name: &'static str,
+                          variant_index: usize,
+                          _variant: &'static str) -> SerializeResult<()> {
+        self.add_enum_tag(variant_index)
+    }
+
+    fn serialize_newtype_variant<V: serde::Serialize>(&mut self,
+                               _name: &'static str,
+                               variant_index: usize,
+                               _variant: &'static str,
+                               value: V) -> SerializeResult<()>
     {
         try!(self.add_enum_tag(variant_index));
-
+        value.serialize(self)
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        Ok(())
     }
 }