From 65eb116a85d8998f774b01d079a37340c5df37ad Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 20 Jul 2016 19:18:45 +0200 Subject: [PATCH] address comments --- serde/src/de/mod.rs | 54 +++++++++++++-------------------------------- 1 file changed, 15 insertions(+), 39 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index e4e68d13..668f5895 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -32,36 +32,42 @@ macro_rules! de_forward_to_deserialize { de_forward_to_deserialize!{tup_fn: deserialize_fixed_size_array} }; (func: deserialize_tuple_struct) => { + #[inline] fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (func: deserialize_struct) => { + #[inline] fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (func: deserialize_enum) => { + #[inline] fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::EnumVisitor { Err($crate::de::Error::invalid_type($crate::de::Type::Enum)) } }; (named: $func:ident) => { + #[inline] fn $func<__V>(&mut self, _: &str, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (tup_fn: $func: ident) => { + #[inline] fn $func<__V>(&mut self, _: usize, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (func: $func:ident) => { + #[inline] fn $func<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) @@ -305,115 +311,95 @@ pub trait Deserializer { where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `bool` value. - #[inline] fn deserialize_bool(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `usize` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_usize(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u8` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_u8(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u16` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_u16(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u32` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_u32(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u64` value. - #[inline] fn deserialize_u64(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `isize` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_isize(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i8` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_i8(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i16` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_i16(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i32` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_i32(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i64` value. - #[inline] fn deserialize_i64(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `f32` value. - /// A reasonable default is to forward to `deserialize_f64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_f64`. fn deserialize_f32(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `f64` value. - #[inline] fn deserialize_f64(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `char` value. - #[inline] fn deserialize_char(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `&str` value. - #[inline] fn deserialize_str(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `String` value. - #[inline] fn deserialize_string(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `unit` value. - #[inline] fn deserialize_unit(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `Option` value. This allows /// deserializers that encode an optional value as a nullable value to convert the null value /// into a `None`, and a regular value as `Some(value)`. - #[inline] fn deserialize_option(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a sequence value. This allows /// deserializers to parse sequences that aren't tagged as sequences. - #[inline] fn deserialize_seq(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a fixed size array. This allows /// deserializers to parse arrays that aren't tagged as arrays. - #[inline] fn deserialize_fixed_size_array(&mut self, _len: usize, visitor: V) -> Result @@ -422,19 +408,16 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a `Vec`. This allows /// deserializers that provide a custom byte vector serialization to properly deserialize the /// type. - #[inline] fn deserialize_bytes(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a map of values. This allows /// deserializers to parse sequences that aren't tagged as maps. - #[inline] fn deserialize_map(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a unit struct. This allows /// deserializers to a unit struct that aren't tagged as a unit struct. - #[inline] fn deserialize_unit_struct(&mut self, _name: &'static str, visitor: V) -> Result @@ -443,7 +426,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a newtype struct. This allows /// deserializers to a newtype struct that aren't tagged as a newtype struct. /// A reasonable default is to simply deserialize the expected value directly. - #[inline] fn deserialize_newtype_struct(&mut self, name: &'static str, visitor: V) -> Result @@ -451,7 +433,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a tuple struct. This allows /// deserializers to parse sequences that aren't tagged as sequences. - #[inline] fn deserialize_tuple_struct(&mut self, _name: &'static str, len: usize, @@ -460,7 +441,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a struct. This allows /// deserializers to parse sequences that aren't tagged as maps. - #[inline] fn deserialize_struct(&mut self, _name: &'static str, _fields: &'static [&'static str], @@ -470,20 +450,17 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting some sort of struct field /// name. This allows deserializers to choose between &str, usize, or &[u8] to properly /// deserialize a struct field. - #[inline] fn deserialize_struct_field(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a tuple value. This allows /// deserializers that provide a custom tuple serialization to properly deserialize the type. - #[inline] fn deserialize_tuple(&mut self, _len: usize, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an enum value. This allows /// deserializers that provide a custom enumeration serialization to properly deserialize the /// type. - #[inline] fn deserialize_enum(&mut self, _enum: &'static str, _variants: &'static [&'static str], @@ -492,7 +469,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type needs to deserialize a value whose type /// doesn't matter because it is ignored. - #[inline] fn deserialize_ignored_any(&mut self, visitor: V) -> Result where V: Visitor; }