playing around with a de2 generic visitor

serde2/src/de2.rs

@@ -10,19 +10,25 @@ trait Deserialize<S, E> {
 ///////////////////////////////////////////////////////////////////////////////
 
 trait VisitorState<E> {
+    fn visit<
+        V: Visitor<Value, SeqValue, E>,
+        Value,
+        SeqValue,
+    >(&mut self, visitor: &mut V) -> Result<Value, E>;
+
+    fn visit_null(&mut self) -> Result<(), E>;
+
     fn visit_int(&mut self) -> Result<int, E>;
 
     fn visit_string(&mut self) -> Result<String, E>;
 
-    fn visit_seq<
+    fn visit_seq(&mut self) -> Result<uint, E>;
-        T: Deserialize<Self, E>,
-        V: Visitor<T, Self, E>
-    >(&mut self) -> Result<T, E>;
 
     fn visit_seq_elt<
         T: Deserialize<Self, E>,
-    >(&mut self) -> Result<T, E>;
+    >(&mut self) -> Option<Result<T, E>>;
 
+    /*
     fn visit_map<
         T: Deserialize<Self, E>,
         V: Visitor<T, Self, E>
@@ -32,8 +38,34 @@ trait VisitorState<E> {
         K: Deserialize<Self, E>,
         V: Deserialize<Self, E>
     >(&mut self) -> Result<(K, V), E>;
+    */
 }
 
+trait Visitor<Value, SeqValue, E> {
+    fn visit_null(&mut self) -> Result<Value, E>;
+
+    fn visit_int(&mut self, v: int) -> Result<Value, E>;
+
+    fn visit_string(&mut self, v: String) -> Result<Value, E>;
+
+    fn visit_seq(&mut self, len: uint) -> Result<SeqValue, E>;
+
+    fn visit_seq_elt(&mut self, values: &mut SeqValue, value: Value) -> Result<(), E>;
+
+    fn visit_seq_end(&mut self, values: SeqValue) -> Result<Value, E>;
+}
+
+/*
+trait Visitor<VS: VisitorState<Self, E>, E> {
+    fn next<
+        T: Deserialize<VS, E>,
+    >(&mut self) -> Option<Result<T, E>>;
+
+    fn size_hint(&self) -> (uint, Option<uint>);
+}
+*/
+
+/*
 trait Visitor<C, S, E> {
     fn new(len: uint) -> Self;
 
@@ -41,16 +73,23 @@ trait Visitor<C, S, E> {
 
     fn unwrap(self) -> Result<C, E>;
 }
+*/
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl<S: VisitorState<E>, E> Deserialize<S, E> for int {
+impl<
+    S: VisitorState<E>,
+    E,
+> Deserialize<S, E> for int {
     fn deserialize(state: &mut S) -> Result<int, E> {
         state.visit_int()
     }
 }
 
-impl<S: VisitorState<E>, E> Deserialize<S, E> for String {
+impl<
+    S: VisitorState<E>,
+    E,
+> Deserialize<S, E> for String {
     fn deserialize(state: &mut S) -> Result<String, E> {
         state.visit_string()
     }
@@ -61,36 +100,33 @@ impl<S: VisitorState<E>, E> Deserialize<S, E> for String {
 impl<
     T: Deserialize<S, E>,
     S: VisitorState<E>,
-    E
+    E,
 > Deserialize<S, E> for Vec<T> {
     fn deserialize(state: &mut S) -> Result<Vec<T>, E> {
-        struct Visitor<T> {
+        let len = try!(state.visit_seq());
-            value: Vec<T>,
+        let mut value = Vec::with_capacity(len);
-        }
 
-        impl<
+        loop {
-            T: Deserialize<S, E>,
+            match state.visit_seq_elt() {
-            S: VisitorState<E>,
+                Some(Ok(v)) => { value.push(v); }
-            E
+                Some(Err(err)) => { return Err(err); }
-        > ::Visitor<Vec<T>, S, E> for Visitor<T> {
+                None => { break; }
-            fn new(len: uint) -> Visitor<T> {
-                Visitor {
-                    value: Vec::with_capacity(len),
-                }
-            }
-
-            fn visit(&mut self, state: &mut S) -> Result<(), E> {
-                let value = try!(state.visit_seq_elt());
-                self.value.push(value);
-                Ok(())
-            }
-
-            fn unwrap(self) -> Result<Vec<T>, E> {
-                Ok(self.value)
             }
         }
 
-        state.visit_seq::<Vec<T>, Visitor<T>>()
+        Ok(value)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+impl<
+    S: VisitorState<E>,
+    E
+> Deserialize<S, E> for () {
+    fn deserialize(state: &mut S) -> Result<(), E> {
+        state.visit_null()
     }
 }
 
@@ -103,6 +139,29 @@ impl<
     E
 > Deserialize<S, E> for (T0, T1) {
     fn deserialize(state: &mut S) -> Result<(T0, T1), E> {
+        let _ = try!(state.visit_seq());
+
+        let t0 = match state.visit_seq_elt() {
+            Some(Ok(v)) => v,
+            Some(Err(err)) => { return Err(err); }
+            None => { fail!(); }
+        };
+
+        let t1 = match state.visit_seq_elt() {
+            Some(Ok(v)) => v,
+            Some(Err(err)) => { return Err(err); }
+            None => { fail!(); }
+        };
+
+        match state.visit_seq_elt() {
+            Some(Ok(())) => { fail!(); }
+            Some(Err(err)) => { return Err(err); }
+            None => { }
+        }
+
+        Ok((t0, t1))
+
+        /*
         struct Visitor<T0, T1> {
             state: uint,
             t0: Option<T0>,
@@ -155,9 +214,11 @@ impl<
         }
 
         state.visit_seq::<(T0, T1), Visitor<T0, T1>>()
+        */
     }
 }
 
+/*
 ///////////////////////////////////////////////////////////////////////////////
 
 impl<
@@ -197,6 +258,58 @@ impl<
         state.visit_map::<HashMap<K, V>, Visitor<K, V>>()
     }
 }
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+
+mod json {
+    enum Value {
+        Null,
+        Bool(bool),
+        Int(int),
+        String(String),
+        Vec(Vec<Value>),
+    }
+
+    impl<
+        S: super::VisitorState<E>,
+        E
+    > super::Deserialize<S, E> for Value {
+        fn deserialize(state: &mut S) -> Result<Value, E> {
+            struct Visitor;
+
+            impl<E> super::Visitor<Value, Vec<Value>, E> for Visitor {
+                fn visit_null(&mut self) -> Result<Value, E> {
+                    Ok(Null)
+                }
+
+                fn visit_int(&mut self, v: int) -> Result<Value, E> {
+                    Ok(Int(v))
+                }
+
+                fn visit_string(&mut self, v: String) -> Result<Value, E> {
+                    Ok(String(v))
+                }
+
+                fn visit_seq(&mut self, len: uint) -> Result<Vec<Value>, E> {
+                    Ok(Vec::with_capacity(len))
+                }
+
+                fn visit_seq_elt(&mut self, values: &mut Vec<Value>, value: Value) -> Result<(), E> {
+                    values.push(value);
+                    Ok(())
+                }
+
+                fn visit_seq_end(&mut self, values: Vec<Value>) -> Result<Value, E> {
+                    Ok(Vec(values))
+                }
+            }
+
+            state.visit(&mut Visitor)
+        }
+    }
+
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -207,6 +320,7 @@ trait Deserializer<S, E> {
 ///////////////////////////////////////////////////////////////////////////////
 
 enum Token {
+    Null,
     Int(int),
     String(String),
     SeqStart(uint),
@@ -214,6 +328,8 @@ enum Token {
     End,
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
 struct MyDeserializerState<Iter> {
     tokens: Iter,
     peeked: Option<Token>,
@@ -235,9 +351,79 @@ impl<Iter: Iterator<Token>> MyDeserializerState<Iter> {
 
         self.tokens.next()
     }
+
+    fn peek<'a>(&'a mut self) -> Option<&'a Token> {
+        match self.peeked {
+            Some(_) => { }
+            None => { self.peeked = self.tokens.next(); }
+        }
+
+        self.peeked.as_ref()
+    }
 }
 
-impl<Iter: Iterator<Token>> VisitorState<()> for MyDeserializerState<Iter> {
+impl<
+    'a,
+    Iter: Iterator<Token>,
+> VisitorState<
+    (),
+> for MyDeserializerState<Iter> {
+    fn visit<
+        V: Visitor<Value, SeqValue, ()>,
+        Value,
+        SeqValue,
+    >(&mut self, visitor: &mut V) -> Result<Value, ()> {
+        match self.next() {
+            Some(Null) => {
+                visitor.visit_null()
+            }
+            Some(Int(v)) => {
+                visitor.visit_int(v)
+            }
+            Some(String(v)) => {
+                visitor.visit_string(v)
+            }
+            Some(SeqStart(len)) => {
+                let mut state = try!(visitor.visit_seq(len));
+
+                loop {
+                    match self.peek() {
+                        Some(&End) => {
+                            self.next();
+                            break;
+                        }
+                        Some(_) => {
+                            let value = try!(self.visit(visitor));
+                            try!(visitor.visit_seq_elt(&mut state, value));
+                        }
+                        None => {
+                            return Err(());
+                        }
+                    }
+                }
+
+                visitor.visit_seq_end(state)
+            }
+            Some(MapStart(len)) => {
+                Err(())
+            }
+            Some(End) => {
+                Err(())
+            }
+            None => {
+                Err(())
+            }
+        }
+
+    }
+
+    fn visit_null(&mut self) -> Result<(), ()> {
+        match self.next() {
+            Some(Null) => Ok(()),
+            _ => Err(())
+        }
+    }
+
     fn visit_int(&mut self) -> Result<int, ()> {
         match self.next() {
             Some(Int(v)) => Ok(v),
@@ -252,37 +438,31 @@ impl<Iter: Iterator<Token>> VisitorState<()> for MyDeserializerState<Iter> {
         }
     }
 
-    fn visit_seq<
+    fn visit_seq(&mut self) -> Result<uint, ()> {
-        T: Deserialize<MyDeserializerState<Iter>, ()>,
+        match self.next() {
-        V: Visitor<T, MyDeserializerState<Iter>, ()>
+            Some(SeqStart(len)) => Ok(len),
-    >(&mut self) -> Result<T, ()> {
+            _ => Err(()),
-        let len = match self.next() {
-            Some(SeqStart(len)) => len,
-            _ => { return Err(()); }
-        };
-
-        let mut visitor: V = Visitor::new(len);
-
-        loop {
-            match self.next() {
-                Some(End) => { break; }
-                Some(token) => {
-                    self.peeked = Some(token);
-                    try!(visitor.visit(self));
-                }
-                _ => { return Err(()); }
-            }
         }
-
-        visitor.unwrap()
     }
 
     fn visit_seq_elt<
         T: Deserialize<MyDeserializerState<Iter>, ()>,
-    >(&mut self) -> Result<T, ()> {
+    >(&mut self) -> Option<Result<T, ()>> {
-        Deserialize::deserialize(self)
+        match self.peek() {
+            Some(&End) => {
+                self.next();
+                None
+            }
+            Some(_) => {
+                Some(Deserialize::deserialize(self))
+            }
+            None => {
+                Some(Err(()))
+            }
+        }
     }
 
+    /*
     fn visit_map<
         T: Deserialize<MyDeserializerState<Iter>, ()>,
         V: Visitor<T, MyDeserializerState<Iter>, ()>
@@ -316,6 +496,7 @@ impl<Iter: Iterator<Token>> VisitorState<()> for MyDeserializerState<Iter> {
         let v = try!(Deserialize::deserialize(self));
         Ok((k, v))
     }
+    */
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -343,6 +524,7 @@ fn main() {
     let v: Result<(int, int), ()> = Deserialize::deserialize(&mut state);
     println!("{}", v);
 
+    /*
     let tokens = vec!(
         MapStart(2),
         String("a".to_string()),
@@ -355,4 +537,5 @@ fn main() {
 
     let v: Result<HashMap<String, int>, ()> = Deserialize::deserialize(&mut state);
     println!("{}", v);
+    */
 }