Add json value deserializer

serde2/src/de.rs

@@ -518,10 +518,18 @@ impl<T> Deserialize for Option<T> where T: Deserialize {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct VecVisitor<T> {
+pub struct VecVisitor<T> {
     marker: PhantomData<T>,
 }
 
+impl<T> VecVisitor<T> {
+    pub fn new() -> Self {
+        VecVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
 impl<T> Visitor for VecVisitor<T> where T: Deserialize {
     type Value = Vec<T>;
 
@@ -544,7 +552,7 @@ impl<T: Deserialize> Deserialize for Vec<T> {
     fn deserialize<D>(deserializer: &mut D) -> Result<Vec<T>, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit(VecVisitor { marker: PhantomData })
+        deserializer.visit(VecVisitor::new())
     }
 }
 
@@ -612,10 +620,19 @@ tuple_impls! {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct HashMapVisitor<K, V> {
+pub struct HashMapVisitor<K, V> {
     marker: PhantomData<HashMap<K, V>>,
 }
 
+impl<K, V> HashMapVisitor<K, V> {
+    #[inline]
+    pub fn new() -> Self {
+        HashMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
 impl<K, V> Visitor for HashMapVisitor<K, V>
     where K: Deserialize + Eq + Hash,
           V: Deserialize,
@@ -644,16 +661,25 @@ impl<K, V> Deserialize for HashMap<K, V>
     fn deserialize<D>(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit(HashMapVisitor { marker: PhantomData })
+        deserializer.visit(HashMapVisitor::new())
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct BTreeMapVisitor<K, V> {
+pub struct BTreeMapVisitor<K, V> {
     marker: PhantomData<BTreeMap<K, V>>,
 }
 
+impl<K, V> BTreeMapVisitor<K, V> {
+    #[inline]
+    pub fn new() -> Self {
+        BTreeMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
 impl<K, V> Visitor for BTreeMapVisitor<K, V>
     where K: Deserialize + Ord,
           V: Deserialize
@@ -681,6 +707,6 @@ impl<
     fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
         where D: Deserializer,
     {
-        deserializer.visit(BTreeMapVisitor { marker: PhantomData })
+        deserializer.visit(BTreeMapVisitor::new())
     }
 }

serde2/src/json/value.rs

@@ -36,6 +36,69 @@ impl ser::Serialize for Value {
     }
 }
 
+impl de::Deserialize for Value {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
+        where D: de::Deserializer,
+    {
+        struct ValueVisitor;
+
+        impl de::Visitor for ValueVisitor {
+            type Value = Value;
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<Value, E> {
+                Ok(Value::Null)
+            }
+
+            #[inline]
+            fn visit_bool<E>(&mut self, value: bool) -> Result<Value, E> {
+                Ok(Value::Bool(value))
+            }
+
+            #[inline]
+            fn visit_i64<E>(&mut self, value: i64) -> Result<Value, E> {
+                Ok(Value::I64(value))
+            }
+
+            #[inline]
+            fn visit_f64<E>(&mut self, value: f64) -> Result<Value, E> {
+                Ok(Value::F64(value))
+            }
+
+            #[inline]
+            fn visit_str<E>(&mut self, value: &str) -> Result<Value, E>
+                where E: de::Error,
+            {
+                self.visit_string(value.to_string())
+            }
+
+            #[inline]
+            fn visit_string<E>(&mut self, value: String) -> Result<Value, E> {
+                Ok(Value::String(value))
+            }
+
+            #[inline]
+            fn visit_seq<V>(&mut self, visitor: V) -> Result<Value, V::Error>
+                where V: de::SeqVisitor,
+            {
+                let values = try!(de::VecVisitor::new().visit_seq(visitor));
+                Ok(Value::Array(values))
+            }
+
+            #[inline]
+            fn visit_map<V>(&mut self, visitor: V) -> Result<Value, V::Error>
+                where V: de::MapVisitor,
+            {
+                let values = try!(de::BTreeMapVisitor::new().visit_map(visitor));
+                Ok(Value::Object(values))
+            }
+        }
+
+        deserializer.visit(ValueVisitor)
+    }
+}
+
 struct WriterFormatter<'a, 'b: 'a> {
     inner: &'a mut fmt::Formatter<'b>,
 }