itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-02 15:25:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update serde_test for Deserializer changes

Browse Source
This commit is contained in:
David Tolnay 2017-01-14 13:22:10 -08:00
parent 738aa31733
commit 7372f152bd
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
1 changed files with 78 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
serde_test/src/de.rs
View File

@ -3,11 +3,13 @@ use std::iter;
use serde::de::{ use serde::de::{
self, self,
Deserialize, Deserialize,
EnumVisitor,
MapVisitor, MapVisitor,
SeqVisitor, SeqVisitor,
VariantVisitor, VariantVisitor,
Visitor, Visitor,
}; };
use serde::de::value::ValueDeserializer;
use error::Error; use error::Error;
use token::Token; use token::Token;
@ -44,7 +46,7 @@ impl<I> Deserializer<I>
} }
} }
fn visit_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error> fn visit_seq<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_seq(DeserializerSeqVisitor { let value = try!(visitor.visit_seq(DeserializerSeqVisitor {
@ -55,7 +57,7 @@ impl<I> Deserializer<I>
Ok(value) Ok(value)
} }
fn visit_array<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error> fn visit_array<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_seq(DeserializerArrayVisitor { let value = try!(visitor.visit_seq(DeserializerArrayVisitor {
@ -66,7 +68,7 @@ impl<I> Deserializer<I>
Ok(value) Ok(value)
} }
fn visit_tuple<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error> fn visit_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_seq(DeserializerTupleVisitor { let value = try!(visitor.visit_seq(DeserializerTupleVisitor {
@ -77,7 +79,7 @@ impl<I> Deserializer<I>
Ok(value) Ok(value)
} }
fn visit_tuple_struct<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error> fn visit_tuple_struct<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_seq(DeserializerTupleStructVisitor { let value = try!(visitor.visit_seq(DeserializerTupleStructVisitor {
@ -88,7 +90,7 @@ impl<I> Deserializer<I>
Ok(value) Ok(value)
} }
fn visit_variant_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error> fn visit_variant_seq<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_seq(DeserializerVariantSeqVisitor { let value = try!(visitor.visit_seq(DeserializerVariantSeqVisitor {
@ -99,7 +101,7 @@ impl<I> Deserializer<I>
Ok(value) Ok(value)
} }
fn visit_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error> fn visit_map<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_map(DeserializerMapVisitor { let value = try!(visitor.visit_map(DeserializerMapVisitor {
@ -110,7 +112,7 @@ impl<I> Deserializer<I>
Ok(value) Ok(value)
} }
fn visit_struct<V>(&mut self, fields: &'static [&'static str], mut visitor: V) -> Result<V::Value, Error> fn visit_struct<V>(&mut self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_map(DeserializerStructVisitor { let value = try!(visitor.visit_map(DeserializerStructVisitor {
@ -121,7 +123,7 @@ impl<I> Deserializer<I>
Ok(value) Ok(value)
} }
fn visit_variant_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error> fn visit_variant_map<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
let value = try!(visitor.visit_map(DeserializerVariantMapVisitor { let value = try!(visitor.visit_map(DeserializerVariantMapVisitor {
@ -133,101 +135,101 @@ impl<I> Deserializer<I>
} }
} }
impl<I> de::Deserializer for Deserializer<I> impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
where I: Iterator<Item=Token<'static>>, where I: Iterator<Item=Token<'static>>,
{ {
type Error = Error; type Error = Error;
fn deserialize_seq<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_seq<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_struct_field<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_struct_field<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_map<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_map<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_unit<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_unit<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_bytes<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_bytes<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_ignored_any<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_ignored_any<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_string<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_string<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_str<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_str<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_char<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_char<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_i64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_i64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_i32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_i32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_i16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_i16<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_i8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_i8<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_u64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_u64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_u32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_u32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_u16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_u16<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_u8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_u8<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_f32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_f32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_f64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_f64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_bool<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_bool<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_usize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_usize<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> fn deserialize_isize<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
where __V: de::Visitor { where __V: de::Visitor {
self.deserialize(visitor) self.deserialize(visitor)
} }
fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error> fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
match self.tokens.next() { match self.tokens.next() {
@ -271,7 +273,7 @@ impl<I> de::Deserializer for Deserializer<I>
/// Hook into `Option` deserializing so we can treat `Unit` as a /// Hook into `Option` deserializing so we can treat `Unit` as a
/// `None`, or a regular value as `Some(value)`. /// `None`, or a regular value as `Some(value)`.
fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error> fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
match self.tokens.peek() { match self.tokens.peek() {
@ -292,17 +294,17 @@ impl<I> de::Deserializer for Deserializer<I>
} }
} }
fn deserialize_enum<V>(&mut self, fn deserialize_enum<V>(self,
name: &str, name: &str,
_variants: &'static [&'static str], _variants: &'static [&'static str],
mut visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
match self.tokens.peek() { match self.tokens.peek() {
Some(&Token::EnumStart(n)) if name == n => { Some(&Token::EnumStart(n)) if name == n => {
self.tokens.next(); self.tokens.next();
visitor.visit_enum(DeserializerVariantVisitor { visitor.visit_enum(DeserializerEnumVisitor {
de: self, de: self,
}) })
} }
@ -310,7 +312,7 @@ impl<I> de::Deserializer for Deserializer<I>
| Some(&Token::EnumNewType(n, _)) | Some(&Token::EnumNewType(n, _))
| Some(&Token::EnumSeqStart(n, _, _)) | Some(&Token::EnumSeqStart(n, _, _))
| Some(&Token::EnumMapStart(n, _, _)) if name == n => { | Some(&Token::EnumMapStart(n, _, _)) if name == n => {
visitor.visit_enum(DeserializerVariantVisitor { visitor.visit_enum(DeserializerEnumVisitor {
de: self, de: self,
}) })
} }
@ -322,7 +324,7 @@ impl<I> de::Deserializer for Deserializer<I>
} }
} }
fn deserialize_unit_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error> fn deserialize_unit_struct<V>(self, name: &str, visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
match self.tokens.peek() { match self.tokens.peek() {
@ -339,9 +341,9 @@ impl<I> de::Deserializer for Deserializer<I>
} }
} }
fn deserialize_newtype_struct<V>(&mut self, fn deserialize_newtype_struct<V>(self,
name: &str, name: &str,
mut visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
match self.tokens.peek() { match self.tokens.peek() {
@ -358,7 +360,7 @@ impl<I> de::Deserializer for Deserializer<I>
} }
} }
fn deserialize_seq_fixed_size<V>(&mut self, fn deserialize_seq_fixed_size<V>(self,
len: usize, len: usize,
visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
@ -373,9 +375,9 @@ impl<I> de::Deserializer for Deserializer<I>
} }
} }
fn deserialize_tuple<V>(&mut self, fn deserialize_tuple<V>(self,
len: usize, len: usize,
mut visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
match self.tokens.peek() { match self.tokens.peek() {
@ -408,10 +410,10 @@ impl<I> de::Deserializer for Deserializer<I>
} }
} }
fn deserialize_tuple_struct<V>(&mut self, fn deserialize_tuple_struct<V>(self,
name: &str, name: &str,
len: usize, len: usize,
mut visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
{ {
match self.tokens.peek() { match self.tokens.peek() {
@ -452,7 +454,7 @@ impl<I> de::Deserializer for Deserializer<I>
} }
} }
fn deserialize_struct<V>(&mut self, fn deserialize_struct<V>(self,
name: &str, name: &str,
fields: &'static [&'static str], fields: &'static [&'static str],
visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
@ -496,7 +498,7 @@ impl<'a, I> SeqVisitor for DeserializerSeqVisitor<'a, I>
Some(&Token::SeqSep) => { Some(&Token::SeqSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len = self.len.map(|len| len - 1); self.len = self.len.map(|len| len - 1);
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::SeqEnd) => Ok(None), Some(&Token::SeqEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -532,7 +534,7 @@ impl<'a, I> SeqVisitor for DeserializerArrayVisitor<'a, I>
Some(&Token::SeqSep) => { Some(&Token::SeqSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len -= 1; self.len -= 1;
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::SeqEnd) => Ok(None), Some(&Token::SeqEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -567,7 +569,7 @@ impl<'a, I> SeqVisitor for DeserializerTupleVisitor<'a, I>
Some(&Token::TupleSep) => { Some(&Token::TupleSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len -= 1; self.len -= 1;
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::TupleEnd) => Ok(None), Some(&Token::TupleEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -602,7 +604,7 @@ impl<'a, I> SeqVisitor for DeserializerTupleStructVisitor<'a, I>
Some(&Token::TupleStructSep) => { Some(&Token::TupleStructSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len -= 1; self.len -= 1;
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::TupleStructEnd) => Ok(None), Some(&Token::TupleStructEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -637,7 +639,7 @@ impl<'a, I> SeqVisitor for DeserializerVariantSeqVisitor<'a, I>
Some(&Token::EnumSeqSep) => { Some(&Token::EnumSeqSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len = self.len.map(|len| len - 1); self.len = self.len.map(|len| len - 1);
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::EnumSeqEnd) => Ok(None), Some(&Token::EnumSeqEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -673,7 +675,7 @@ impl<'a, I> MapVisitor for DeserializerMapVisitor<'a, I>
Some(&Token::MapSep) => { Some(&Token::MapSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 }); self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 });
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::MapEnd) => Ok(None), Some(&Token::MapEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -687,7 +689,7 @@ impl<'a, I> MapVisitor for DeserializerMapVisitor<'a, I>
fn visit_value<V>(&mut self) -> Result<V, Error> fn visit_value<V>(&mut self) -> Result<V, Error>
where V: Deserialize, where V: Deserialize,
{ {
Ok(try!(Deserialize::deserialize(self.de))) Deserialize::deserialize(&mut *self.de)
} }
fn size_hint(&self) -> (usize, Option<usize>) { fn size_hint(&self) -> (usize, Option<usize>) {
@ -715,7 +717,7 @@ impl<'a, I> MapVisitor for DeserializerStructVisitor<'a, I>
Some(&Token::StructSep) => { Some(&Token::StructSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len = self.len.saturating_sub(1); self.len = self.len.saturating_sub(1);
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::StructEnd) => Ok(None), Some(&Token::StructEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -729,7 +731,7 @@ impl<'a, I> MapVisitor for DeserializerStructVisitor<'a, I>
fn visit_value<V>(&mut self) -> Result<V, Error> fn visit_value<V>(&mut self) -> Result<V, Error>
where V: Deserialize, where V: Deserialize,
{ {
Ok(try!(Deserialize::deserialize(self.de))) Deserialize::deserialize(&mut *self.de)
} }
fn size_hint(&self) -> (usize, Option<usize>) { fn size_hint(&self) -> (usize, Option<usize>) {
@ -739,16 +741,17 @@ impl<'a, I> MapVisitor for DeserializerStructVisitor<'a, I>
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
struct DeserializerVariantVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> { struct DeserializerEnumVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
de: &'a mut Deserializer<I>, de: &'a mut Deserializer<I>,
} }
impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I> impl<'a, I> EnumVisitor for DeserializerEnumVisitor<'a, I>
where I: Iterator<Item=Token<'static>>, where I: Iterator<Item=Token<'static>>,
{ {
type Error = Error; type Error = Error;
type Variant = Self;
fn visit_variant<V>(&mut self) -> Result<V, Error> fn visit_variant<V>(self) -> Result<(V, Self), Error>
where V: Deserialize, where V: Deserialize,
{ {
match self.de.tokens.peek() { match self.de.tokens.peek() {
@ -756,18 +759,25 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
| Some(&Token::EnumNewType(_, v)) | Some(&Token::EnumNewType(_, v))
| Some(&Token::EnumSeqStart(_, v, _)) | Some(&Token::EnumSeqStart(_, v, _))
| Some(&Token::EnumMapStart(_, v, _)) => { | Some(&Token::EnumMapStart(_, v, _)) => {
let mut de = de::value::ValueDeserializer::<Error>::into_deserializer(v); let de = v.into_deserializer();
let value = try!(Deserialize::deserialize(&mut de)); let value = try!(Deserialize::deserialize(de));
Ok(value) Ok((value, self))
} }
Some(_) => { Some(_) => {
Deserialize::deserialize(self.de) let value = try!(Deserialize::deserialize(&mut *self.de));
Ok((value, self))
} }
None => Err(Error::EndOfStream), None => Err(Error::EndOfStream),
} }
} }
}
fn visit_unit(&mut self) -> Result<(), Error> { impl<'a, I> VariantVisitor for DeserializerEnumVisitor<'a, I>
where I: Iterator<Item=Token<'static>>
{
type Error = Error;
fn visit_unit(self) -> Result<(), Error> {
match self.de.tokens.peek() { match self.de.tokens.peek() {
Some(&Token::EnumUnit(_, _)) => { Some(&Token::EnumUnit(_, _)) => {
self.de.tokens.next(); self.de.tokens.next();
@ -780,7 +790,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
} }
} }
fn visit_newtype<T>(&mut self) -> Result<T, Self::Error> fn visit_newtype<T>(self) -> Result<T, Self::Error>
where T: Deserialize, where T: Deserialize,
{ {
match self.de.tokens.peek() { match self.de.tokens.peek() {
@ -795,7 +805,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
} }
} }
fn visit_tuple<V>(&mut self, fn visit_tuple<V>(self,
len: usize, len: usize,
visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
@ -826,7 +836,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
} }
} }
fn visit_struct<V>(&mut self, fn visit_struct<V>(self,
fields: &'static [&'static str], fields: &'static [&'static str],
visitor: V) -> Result<V::Value, Error> visitor: V) -> Result<V::Value, Error>
where V: Visitor, where V: Visitor,
@ -877,7 +887,7 @@ impl<'a, I> MapVisitor for DeserializerVariantMapVisitor<'a, I>
Some(&Token::EnumMapSep) => { Some(&Token::EnumMapSep) => {
self.de.tokens.next(); self.de.tokens.next();
self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 }); self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 });
Ok(Some(try!(Deserialize::deserialize(self.de)))) Deserialize::deserialize(&mut *self.de).map(Some)
} }
Some(&Token::EnumMapEnd) => Ok(None), Some(&Token::EnumMapEnd) => Ok(None),
Some(_) => { Some(_) => {
@ -891,7 +901,7 @@ impl<'a, I> MapVisitor for DeserializerVariantMapVisitor<'a, I>
fn visit_value<V>(&mut self) -> Result<V, Error> fn visit_value<V>(&mut self) -> Result<V, Error>
where V: Deserialize, where V: Deserialize,
{ {
Ok(try!(Deserialize::deserialize(self.de))) Deserialize::deserialize(&mut *self.de)
} }
fn size_hint(&self) -> (usize, Option<usize>) { fn size_hint(&self) -> (usize, Option<usize>) {