From 95b414a1849f579891e64f29911e30a0649cb54c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 28 Jul 2016 12:23:18 -0700 Subject: [PATCH] Update to serde 0.8.0 (#84) --- Cargo.toml | 4 +- src/serde/reader.rs | 77 ++++++-- src/serde/writer.rs | 418 +++++++++++++++++++++++++++++--------------- 3 files changed, 337 insertions(+), 162 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 97f800a..b69cb55 100644 --- a/Cargo.toml +++ b/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"] diff --git a/src/serde/reader.rs b/src/serde/reader.rs index b5d1691..00ea18c 100644 --- a/src/serde/reader.rs +++ b/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::() as u64) } + + fn read_string(&mut self) -> DeserializeResult { + 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(&mut self, mut visitor: V) -> DeserializeResult + where V: serde::de::Visitor, + { + visitor.visit_str(&try!(self.read_string())) + } + fn deserialize_string(&mut self, mut visitor: V) -> DeserializeResult where V: serde::de::Visitor, { - let len = try!(serde::Deserialize::deserialize(self)); - try!(self.read_bytes(len)); + visitor.visit_string(try!(self.read_string())) + } - 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(&mut self, visitor: V) -> DeserializeResult + where V: serde::de::Visitor, + { + self.deserialize_seq(visitor) } fn deserialize_enum(&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(&mut self, + fn deserialize_seq_fixed_size(&mut self, _: usize, visitor: V) -> DeserializeResult 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(&mut self, + _visitor: V) -> DeserializeResult + 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(&mut self, _name: &str, - mut visitor: V) -> Result + mut visitor: V) -> DeserializeResult where V: serde::de::Visitor, { visitor.visit_newtype_struct(self) } + + fn deserialize_unit_struct(&mut self, + _name: &'static str, + mut visitor: V) -> DeserializeResult + where V: serde::de::Visitor, + { + visitor.visit_unit() + } + + fn deserialize_tuple_struct(&mut self, + _name: &'static str, + len: usize, + visitor: V) -> DeserializeResult + where V: serde::de::Visitor, + { + self.deserialize_tuple(len, visitor) + } + + fn deserialize_ignored_any(&mut self, + _visitor: V) -> DeserializeResult + 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> { diff --git a/src/serde/writer.rs b/src/serde/writer.rs index 6e1afb9..0c3ae3c 100644 --- a/src/serde/writer.rs +++ b/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::(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::(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::(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,113 +181,150 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> { v.serialize(self) } - fn serialize_seq(&mut self, mut visitor: V) -> SerializeResult<()> - where V: serde::ser::SeqVisitor, - { - 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_seq(&mut self, len: Option) -> SerializeResult<()> { + let len = len.expect("do not know how to serialize a sequence with no length"); + self.serialize_usize(len) } - fn serialize_tuple(&mut self, mut visitor: V) -> SerializeResult<()> - where V: serde::ser::SeqVisitor, - { - while let Some(()) = try!(visitor.visit(self)) { } - - Ok(()) - } - - fn serialize_seq_elt(&mut self, value: V) -> SerializeResult<()> + fn serialize_seq_elt(&mut self, _: &mut (), value: V) -> SerializeResult<()> where V: serde::Serialize, { value.serialize(self) } - fn serialize_map(&mut self, mut visitor: V) -> 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)) { } - + fn serialize_seq_end(&mut self, _: ()) -> SerializeResult<()> { Ok(()) } - fn serialize_map_elt(&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(&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(&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(&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) -> SerializeResult<()> { + let len = len.expect("do not know how to serialize a map with no length"); + self.serialize_usize(len) + } + + fn serialize_map_key(&mut self, _: &mut (), key: K) -> SerializeResult<()> where K: serde::Serialize, - V: serde::Serialize, { - try!(key.serialize(self)); - value.serialize(self) + key.serialize(self) } - fn serialize_struct(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> - where V: serde::ser::MapVisitor, - { - while let Some(()) = try!(visitor.visit(self)) { } - - Ok(()) - } - - fn serialize_struct_elt(&mut self, _key: &str, value: V) -> SerializeResult<()> + fn serialize_map_value(&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(&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(&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(&mut self, - _name: &str, + _name: &'static str, value: T) -> SerializeResult<()> where T: serde::ser::Serialize, { value.serialize(self) } - fn serialize_unit_variant(&mut self, - _name: &str, - variant_index: usize, - _variant: &str) -> SerializeResult<()> { - self.add_enum_tag(variant_index) - } - - fn serialize_tuple_variant(&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(&mut self, - _name: &str, + fn serialize_newtype_variant(&mut self, + _name: &'static str, variant_index: usize, - _variant: &str, - mut visitor: V) -> SerializeResult<()> - where V: serde::ser::MapVisitor, + _variant: &'static str, + value: T) -> SerializeResult<()> + where T: serde::ser::Serialize, { try!(self.add_enum_tag(variant_index)); + value.serialize(self) + } - while let Some(()) = try!(visitor.visit(self)) { } - - Ok(()) + fn serialize_unit_variant(&mut self, + _name: &'static str, + variant_index: usize, + _variant: &'static str) -> SerializeResult<()> { + self.add_enum_tag(variant_index) } } @@ -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(&mut self, mut visitor: V) -> SerializeResult<()> - where V: serde::ser::SeqVisitor, - { - let len = match visitor.len() { - Some(len) => len, - None => panic!("do not know how to serialize a sequence with no length"), - }; + fn serialize_seq(&mut self, len: Option) -> SerializeResult<()> { + let len = len.expect("do not know how to serialize a sequence with no length"); - try!(self.serialize_usize(len)); - - while let Some(()) = try!(visitor.visit(self)) { } - - Ok(()) + self.serialize_usize(len) } - fn serialize_tuple(&mut self, mut visitor: V) -> SerializeResult<()> - where V: serde::ser::SeqVisitor, - { - while let Some(()) = try!(visitor.visit(self)) { } - - Ok(()) - } - - fn serialize_seq_elt(&mut self, value: V) -> SerializeResult<()> + fn serialize_seq_elt(&mut self, _: &mut (), value: V) -> SerializeResult<()> where V: serde::Serialize, { value.serialize(self) } - fn serialize_map(&mut self, mut visitor: V) -> 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)) { } - + fn serialize_seq_end(&mut self, _: ()) -> SerializeResult<()> { Ok(()) } - fn serialize_map_elt(&mut self, key: K, value: V) -> SerializeResult<()> - where K: serde::Serialize, - V: serde::Serialize, - { - try!(key.serialize(self)); - value.serialize(self) + fn serialize_seq_fixed_size(&mut self, len: usize) -> SerializeResult<()> { + self.serialize_seq(Some(len)) } - fn serialize_struct(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> - where V: serde::ser::MapVisitor, - { - while let Some(()) = try!(visitor.visit(self)) { } - + fn serialize_tuple(&mut self, _len: usize) -> SerializeResult<()> { Ok(()) } - fn serialize_struct_elt(&mut self, _key: &str, value: V) -> SerializeResult<()> + fn serialize_tuple_elt(&mut self, _: &mut (), value: V) -> SerializeResult<()> where V: serde::Serialize, { value.serialize(self) } - fn serialize_unit_variant(&mut self, - _name: &str, - variant_index: usize, - _variant: &str) -> SerializeResult<()> { + 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(&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(&mut self, - _name: &str, - variant_index: usize, - _variant: &str, - mut visitor: V) -> SerializeResult<()> - where V: serde::ser::SeqVisitor, + fn serialize_tuple_variant_elt(&mut self, _: &mut (), value: V) -> SerializeResult<()> + where V: serde::Serialize, { - try!(self.add_enum_tag(variant_index)); - - while let Some(()) = try!(visitor.visit(self)) { } + value.serialize(self) + } + fn serialize_tuple_variant_end(&mut self, _: ()) -> SerializeResult<()> { Ok(()) } - fn serialize_struct_variant(&mut self, - _name: &str, + fn serialize_map(&mut self, len: Option) -> SerializeResult<()> + { + let len = len.expect("do not know how to serialize a map with no length"); + + self.serialize_usize(len) + } + + fn serialize_map_key(&mut self, _: &mut (), key: K) -> SerializeResult<()> + where K: serde::Serialize, + { + key.serialize(self) + } + + fn serialize_map_value(&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(&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, - mut visitor: V) -> SerializeResult<()> - where V: serde::ser::MapVisitor, + _variant: &'static str, + _len: usize) -> SerializeResult<()> + { + self.add_enum_tag(variant_index) + } + + fn serialize_struct_variant_elt(&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(&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(&mut self, + _name: &'static str, + variant_index: usize, + _variant: &'static str, + value: V) -> SerializeResult<()> { try!(self.add_enum_tag(variant_index)); - - while let Some(()) = try!(visitor.visit(self)) { } - - Ok(()) + value.serialize(self) } }