From 492690669eb696849f592b70a4f9b1e443c60ace Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 28 Jul 2016 11:01:22 -0700 Subject: [PATCH] Update to serde 0.8.0 --- Cargo.toml | 2 +- src/decoder/serde.rs | 124 +++++++++++++++++++++++++++++++++++++++++++ src/encoder/serde.rs | 22 +++++--- 3 files changed, 139 insertions(+), 9 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f180731..ed0cc3a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,7 +17,7 @@ facilitate deserializing and serializing Rust structures. [dependencies] rustc-serialize = { optional = true, version = "0.3.0" } -serde = { optional = true, version = "0.7" } +serde = { optional = true, version = "0.8" } [features] default = ["rustc-serialize"] diff --git a/src/decoder/serde.rs b/src/decoder/serde.rs index 91bc8ac..d854046 100644 --- a/src/decoder/serde.rs +++ b/src/decoder/serde.rs @@ -3,6 +3,43 @@ use Value; use super::{Decoder, DecodeError, DecodeErrorKind}; use std::collections::BTreeMap; +macro_rules! forward_to_deserialize { + ($( + $name:ident ( $( $arg:ident : $ty:ty ),* ); + )*) => { + $( + forward_to_deserialize!{ + func: $name ( $( $arg: $ty ),* ); + } + )* + }; + + (func: deserialize_enum ( $( $arg:ident : $ty:ty ),* );) => { + fn deserialize_enum( + &mut self, + $(_: $ty,)* + _visitor: V, + ) -> ::std::result::Result + where V: ::serde::de::EnumVisitor + { + Err(::serde::de::Error::invalid_type(::serde::de::Type::Enum)) + } + }; + + (func: $name:ident ( $( $arg:ident : $ty:ty ),* );) => { + #[inline] + fn $name( + &mut self, + $(_: $ty,)* + visitor: V, + ) -> ::std::result::Result + where V: ::serde::de::Visitor + { + self.deserialize(visitor) + } + }; +} + impl de::Deserializer for Decoder { type Error = DecodeError; @@ -186,6 +223,28 @@ impl de::Deserializer for Decoder { let mut d = <() as ValueDeserializer>::into_deserializer(()); d.deserialize(visitor) } + + forward_to_deserialize!{ + deserialize_usize(); + deserialize_u8(); + deserialize_u16(); + deserialize_u32(); + deserialize_isize(); + deserialize_i8(); + deserialize_i16(); + deserialize_i32(); + deserialize_f32(); + deserialize_string(); + deserialize_unit(); + deserialize_seq_fixed_size(len: usize); + deserialize_bytes(); + deserialize_unit_struct(name: &'static str); + deserialize_newtype_struct(name: &'static str); + deserialize_tuple_struct(name: &'static str, len: usize); + deserialize_struct(name: &'static str, fields: &'static [&'static str]); + deserialize_struct_field(); + deserialize_tuple(len: usize); + } } struct VariantVisitor { @@ -270,6 +329,39 @@ impl<'a, I> de::Deserializer for SeqDeserializer<'a, I> { visitor.visit_seq(self) } + + forward_to_deserialize!{ + deserialize_bool(); + deserialize_usize(); + deserialize_u8(); + deserialize_u16(); + deserialize_u32(); + deserialize_u64(); + deserialize_isize(); + deserialize_i8(); + deserialize_i16(); + deserialize_i32(); + deserialize_i64(); + deserialize_f32(); + deserialize_f64(); + deserialize_char(); + deserialize_str(); + deserialize_string(); + deserialize_unit(); + deserialize_option(); + deserialize_seq(); + deserialize_seq_fixed_size(len: usize); + deserialize_bytes(); + deserialize_map(); + deserialize_unit_struct(name: &'static str); + deserialize_newtype_struct(name: &'static str); + deserialize_tuple_struct(name: &'static str, len: usize); + deserialize_struct(name: &'static str, fields: &'static [&'static str]); + deserialize_struct_field(); + deserialize_tuple(len: usize); + deserialize_enum(name: &'static str, variants: &'static [&'static str]); + deserialize_ignored_any(); + } } impl<'a, I> de::SeqVisitor for SeqDeserializer<'a, I> @@ -492,6 +584,38 @@ impl de::Deserializer for UnitDeserializer { { visitor.visit_none() } + + forward_to_deserialize!{ + deserialize_bool(); + deserialize_usize(); + deserialize_u8(); + deserialize_u16(); + deserialize_u32(); + deserialize_u64(); + deserialize_isize(); + deserialize_i8(); + deserialize_i16(); + deserialize_i32(); + deserialize_i64(); + deserialize_f32(); + deserialize_f64(); + deserialize_char(); + deserialize_str(); + deserialize_string(); + deserialize_unit(); + deserialize_seq(); + deserialize_seq_fixed_size(len: usize); + deserialize_bytes(); + deserialize_map(); + deserialize_unit_struct(name: &'static str); + deserialize_newtype_struct(name: &'static str); + deserialize_tuple_struct(name: &'static str, len: usize); + deserialize_struct(name: &'static str, fields: &'static [&'static str]); + deserialize_struct_field(); + deserialize_tuple(len: usize); + deserialize_enum(name: &'static str, variants: &'static [&'static str]); + deserialize_ignored_any(); + } } impl de::Deserialize for Value { diff --git a/src/encoder/serde.rs b/src/encoder/serde.rs index 9c2f602..fcccc3d 100644 --- a/src/encoder/serde.rs +++ b/src/encoder/serde.rs @@ -128,12 +128,15 @@ impl ser::Serializer for Encoder { fn serialize_map(&mut self, _len: Option) -> Result { self.table_begin() } - fn serialize_map_elt(&mut self, _state: &mut Encoder, key: K, value: V) -> Result<(), Error> - where K: ser::Serialize, V: ser::Serialize + fn serialize_map_key(&mut self, _state: &mut Encoder, key: K) -> Result<(), Error> + where K: ser::Serialize { - try!(self.table_key(|me| key.serialize(me))); - try!(value.serialize(self)); - Ok(()) + self.table_key(|me| key.serialize(me)) + } + fn serialize_map_value(&mut self, _state: &mut Encoder, value: V) -> Result<(), Error> + where V: ser::Serialize + { + value.serialize(self) } fn serialize_map_end(&mut self, state: Self) -> Result<(), Error> { self.table_end(state) @@ -144,7 +147,8 @@ impl ser::Serializer for Encoder { fn serialize_struct_elt(&mut self, state: &mut Encoder, key: &'static str, value: V) -> Result<(), Error> where V: ser::Serialize { - self.serialize_map_elt(state, key, value) + try!(self.serialize_map_key(state, key)); + self.serialize_map_value(state, value) } fn serialize_struct_end(&mut self, state: Self) -> Result<(), Error> { self.serialize_map_end(state) @@ -155,7 +159,8 @@ impl ser::Serializer for Encoder { fn serialize_struct_variant_elt(&mut self, state: &mut Encoder, key: &'static str, value: V) -> Result<(), Error> where V: ser::Serialize { - self.serialize_map_elt(state, key, value) + try!(self.serialize_map_key(state, key)); + self.serialize_map_value(state, value) } fn serialize_struct_variant_end(&mut self, state: Self) -> Result<(), Error> { self.serialize_map_end(state) @@ -208,7 +213,8 @@ impl ser::Serialize for Value { Value::Table(ref t) => { let mut state = try!(e.serialize_map(Some(t.len()))); for (k, v) in t.iter() { - try!(e.serialize_map_elt(&mut state, k, v)); + try!(e.serialize_map_key(&mut state, k)); + try!(e.serialize_map_value(&mut state, v)); } e.serialize_map_end(state) }