Rewrite de::ignore into a struct that impls Deserializable

de.rs

@@ -479,43 +479,25 @@ deserialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
 //////////////////////////////////////////////////////////////////////////////
 
-pub fn ignore<E, D: Deserializer<E>>(d: &mut D) -> Result<(), E> {
+/// Helper struct that will ignore tokens while taking in consideration
-    let token = match d.next() {
+/// recursive structures.
-        Some(Ok(token)) => token,
+pub struct IgnoreTokens;
-        Some(Err(err)) => { return Err(err); }
-        None => { return Err(d.end_of_stream_error()); }
-    };
 
-    ignore_token(d, token)
+impl<E, D: Deserializer<E>> Deserializable<E, D> for IgnoreTokens {
-}
+    #[inline]
-
+    fn deserialize_token(d: &mut D, token: Token) -> Result<IgnoreTokens, E> {
-pub fn ignore_token<E, D: Deserializer<E>>(d: &mut D, token: Token) -> Result<(), E> {
         match token {
-        Null => Ok(()),
+            Option(true) => {
-        Bool(_) => Ok(()),
+                Deserializable::deserialize(d)
-        Uint(_) => Ok(()),
+            }
-        U8(_) => Ok(()),
-        U16(_) => Ok(()),
-        U32(_) => Ok(()),
-        U64(_) => Ok(()),
-        Int(_) => Ok(()),
-        I8(_) => Ok(()),
-        I16(_) => Ok(()),
-        I32(_) => Ok(()),
-        I64(_) => Ok(()),
-        F32(_) => Ok(()),
-        F64(_) => Ok(()),
-        Char(_) => Ok(()),
-        Str(_) => Ok(()),
-        String(_) => Ok(()),
-        Option(true) => { ignore(d) }
-        Option(false) => { Ok(()) }
 
             EnumStart(_, _, _) => {
                 loop {
                     match try!(d.expect_token()) {
-                    End => { return Ok(()); }
+                        End => { return Ok(IgnoreTokens); }
-                    token => { try!(ignore_token(d, token)); }
+                        token => {
+                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
+                        }
                     }
                 }
             }
@@ -523,8 +505,10 @@ pub fn ignore_token<E, D: Deserializer<E>>(d: &mut D, token: Token) -> Result<()
             StructStart(_, _) => {
                 loop {
                     match try!(d.expect_token()) {
-                    End => { return Ok(()); }
+                        End => { return Ok(IgnoreTokens); }
-                    Str(_) | String(_) => { try!(ignore(d)); }
+                        Str(_) | String(_) => {
+                            let _: IgnoreTokens = try!(Deserializable::deserialize(d));
+                        }
                         token => { return Err(d.syntax_error()); }
                     }
                 }
@@ -533,8 +517,10 @@ pub fn ignore_token<E, D: Deserializer<E>>(d: &mut D, token: Token) -> Result<()
             TupleStart(_) => {
                 loop {
                     match try!(d.expect_token()) {
-                    End => { return Ok(()); }
+                        End => { return Ok(IgnoreTokens); }
-                    token => { try!(ignore_token(d, token)); }
+                        token => {
+                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
+                        }
                     }
                 }
             }
@@ -542,8 +528,10 @@ pub fn ignore_token<E, D: Deserializer<E>>(d: &mut D, token: Token) -> Result<()
             SeqStart(_) => {
                 loop {
                     match try!(d.expect_token()) {
-                    End => { return Ok(()); }
+                        End => { return Ok(IgnoreTokens); }
-                    token => { try!(ignore_token(d, token)); }
+                        token => {
+                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
+                        }
                     }
                 }
             }
@@ -551,16 +539,20 @@ pub fn ignore_token<E, D: Deserializer<E>>(d: &mut D, token: Token) -> Result<()
             MapStart(_) => {
                 loop {
                     match try!(d.expect_token()) {
-                    End => { return Ok(()); }
+                        End => { return Ok(IgnoreTokens); }
                         token => {
-                        try!(ignore_token(d, token));
+                            let _: IgnoreTokens = try!(Deserializable::deserialize_token(d, token));
-                        try!(ignore(d));
+                            let _: IgnoreTokens = try!(Deserializable::deserialize(d));
                         }
                     }
                 }
             }
 
             End => Err(d.syntax_error()),
+
+            _ => Ok(IgnoreTokens),
+
+        }
     }
 }