From 8ec54e562a77ccf9cf6cb7f2658fe6a7d59f3e0b Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Wed, 29 Jul 2015 13:13:21 -0700 Subject: [PATCH] Update to serde 0.5.0 --- src/reader_serde.rs | 83 +++++++++++---------------------------------- src/writer_serde.rs | 70 +++++++++++++++----------------------- 2 files changed, 48 insertions(+), 105 deletions(-) diff --git a/src/reader_serde.rs b/src/reader_serde.rs index 8f53322..ec8ab7e 100644 --- a/src/reader_serde.rs +++ b/src/reader_serde.rs @@ -346,13 +346,18 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> { } } - fn visit_enum(&mut self, _enum: &str, mut visitor: V) -> Result + fn visit_enum(&mut self, + _enum: &'static str, + _variants: &'static [&'static str], + mut visitor: V) -> Result where V: serde::de::EnumVisitor, { visitor.visit(self) } - fn visit_tuple(&mut self, mut visitor: V) -> DeserializeResult + fn visit_tuple(&mut self, + _len: usize, + mut visitor: V) -> DeserializeResult where V: serde::de::Visitor, { struct TupleVisitor<'a, 'b: 'a, R: Read + 'b>(&'a mut Deserializer<'b, R>); @@ -375,12 +380,6 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> { visitor.visit_seq(TupleVisitor(self)) } - fn visit_named_seq(&mut self, _name: &str, visitor: V) -> DeserializeResult - where V: serde::de::Visitor, - { - self.visit_tuple(visitor) - } - fn visit_option(&mut self, mut visitor: V) -> DeserializeResult where V: serde::de::Visitor, { @@ -476,56 +475,13 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> { visitor.visit_map(MapVisitor { deserializer: self, len: len }) } - fn visit_named_map(&mut self, - _name: &str, - fields: &'static [&'static str], - mut visitor: V) -> DeserializeResult + fn visit_struct(&mut self, + _name: &str, + fields: &'static [&'static str], + visitor: V) -> DeserializeResult where V: serde::de::Visitor, { - struct StructVisitor<'a, 'b: 'a, R: Read + 'b> { - deserializer: &'a mut Deserializer<'b, R>, - index: usize, - fields: &'static [&'static str], - } - - impl<'a, 'b: 'a, R: Read + 'b> serde::de::MapVisitor for StructVisitor<'a, 'b, R> { - type Error = DeserializeError; - - fn visit_key(&mut self) -> Result, Self::Error> - where K: serde::de::Deserialize, - { - if self.index < self.fields.len() { - let mut deserializer = self.index.into_deserializer(); - self.index += 1; - - let key = try!(serde::Deserialize::deserialize(&mut deserializer)); - Ok(Some(key)) - } else { - Ok(None) - } - } - - fn visit_value(&mut self) -> Result - where V: serde::de::Deserialize, - { - let value = try!(serde::Deserialize::deserialize(self.deserializer)); - Ok(value) - } - - fn end(&mut self) -> Result<(), Self::Error> { - if self.index < self.fields.len() { - Err(serde::de::Error::missing_field_error(self.fields[self.index])) - } else { - Ok(()) - } - } - } - - visitor.visit_map(StructVisitor { - deserializer: self, - index: 0, - fields: fields, - }) + self.visit_tuple(fields.len(), visitor) } } @@ -544,20 +500,21 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> { Ok(()) } - fn visit_seq(&mut self, visitor: V) -> Result + fn visit_tuple(&mut self, + len: usize, + visitor: V) -> Result where V: serde::de::Visitor, { - serde::de::Deserializer::visit_named_seq(self, "", visitor) + serde::de::Deserializer::visit_tuple(self, len, visitor) } - fn visit_map(&mut self, - fields: &'static [&'static str], - visitor: V) -> Result + fn visit_struct(&mut self, + fields: &'static [&'static str], + visitor: V) -> Result where V: serde::de::Visitor, { - serde::de::Deserializer::visit_named_map(self, "", fields, visitor) + serde::de::Deserializer::visit_tuple(self, fields.len(), visitor) } - } pub fn from_reader(reader: &mut R, size_limit: SizeLimit) -> DeserializeResult diff --git a/src/writer_serde.rs b/src/writer_serde.rs index 7ece01c..abace1f 100644 --- a/src/writer_serde.rs +++ b/src/writer_serde.rs @@ -174,14 +174,6 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> { Ok(()) } - fn visit_named_seq(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> - where V: serde::ser::SeqVisitor, - { - while let Some(()) = try!(visitor.visit(self)) { } - - Ok(()) - } - fn visit_seq_elt(&mut self, value: V) -> SerializeResult<()> where V: serde::Serialize, { @@ -211,7 +203,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> { value.serialize(self) } - fn visit_named_map(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> + fn visit_struct(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> where V: serde::ser::MapVisitor, { while let Some(()) = try!(visitor.visit(self)) { } @@ -219,25 +211,25 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> { Ok(()) } - fn visit_named_map_elt(&mut self, _key: K, value: V) -> SerializeResult<()> + fn visit_struct_elt(&mut self, _key: K, value: V) -> SerializeResult<()> where K: serde::Serialize, V: serde::Serialize, { value.serialize(self) } - fn visit_enum_unit(&mut self, - _name: &str, - variant_index: usize, - _variant: &str) -> SerializeResult<()> { + fn visit_unit_variant(&mut self, + _name: &str, + variant_index: usize, + _variant: &str) -> SerializeResult<()> { self.add_enum_tag(variant_index) } - fn visit_enum_seq(&mut self, - _name: &str, - variant_index: usize, - _variant: &str, - mut visitor: V) -> SerializeResult<()> + fn visit_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)); @@ -247,11 +239,11 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> { Ok(()) } - fn visit_enum_map(&mut self, - _name: &str, - variant_index: usize, - _variant: &str, - mut visitor: V) -> SerializeResult<()> + fn visit_struct_variant(&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)); @@ -386,12 +378,6 @@ impl serde::Serializer for SizeChecker { Ok(()) } - fn visit_named_seq(&mut self, _name: &str, visitor: V) -> SerializeResult<()> - where V: serde::ser::SeqVisitor, - { - self.visit_tuple(visitor) - } - fn visit_seq_elt(&mut self, value: V) -> SerializeResult<()> where V: serde::Serialize, { @@ -421,7 +407,7 @@ impl serde::Serializer for SizeChecker { value.serialize(self) } - fn visit_named_map(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> + fn visit_struct(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> where V: serde::ser::MapVisitor, { while let Some(()) = try!(visitor.visit(self)) { } @@ -429,21 +415,21 @@ impl serde::Serializer for SizeChecker { Ok(()) } - fn visit_named_map_elt(&mut self, _key: K, value: V) -> SerializeResult<()> + fn visit_struct_elt(&mut self, _key: K, value: V) -> SerializeResult<()> where K: serde::Serialize, V: serde::Serialize, { value.serialize(self) } - fn visit_enum_unit(&mut self, - _name: &str, - variant_index: usize, - _variant: &str) -> SerializeResult<()> { + fn visit_unit_variant(&mut self, + _name: &str, + variant_index: usize, + _variant: &str) -> SerializeResult<()> { self.add_enum_tag(variant_index) } - fn visit_enum_seq(&mut self, + fn visit_tuple_variant(&mut self, _name: &str, variant_index: usize, _variant: &str, @@ -457,11 +443,11 @@ impl serde::Serializer for SizeChecker { Ok(()) } - fn visit_enum_map(&mut self, - _name: &str, - variant_index: usize, - _variant: &str, - mut visitor: V) -> SerializeResult<()> + fn visit_struct_variant(&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));