Add Value::into_str and Value::into_array

Other changes inside of Deserializer

2 files changed, 42 insertions, 158 deletions

diff --git a/lib/src/de.rs b/lib/src/de.rs
index a59d950..d1673d5 100644
--- a/lib/src/de.rs
+++ b/lib/src/de.rs
@@ -1,6 +1,7 @@
 use serde::de;
 use value::{Value, ValueKind};
 use error::*;
+use std::borrow::Cow;
 use std::iter::Peekable;
 use std::collections::HashMap;
 use std::collections::hash_map::Drain;
@@ -12,169 +13,20 @@ impl de::Deserializer for Value {
     fn deserialize<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
         // Deserialize based on the underlying type
         match self.kind {
-            ValueKind::Boolean(value) => {
-                visitor.visit_bool(value)
-            }
-
-            ValueKind::Table(map) => {
-                visitor.visit_map(MapVisitor::new(map))
-            }
-
+            ValueKind::Integer(i) => visitor.visit_i64(i),
+            ValueKind::Boolean(b) => visitor.visit_bool(b),
+            ValueKind::Float(f) => visitor.visit_f64(f),
+            // ValueKind::String(Cow::Borrowed(s)) => visitor.visit_str(s),
+            // ValueKind::String(Cow::Owned(s)) => visitor.visit_string(s),
+            ValueKind::Table(map) => visitor.visit_map(MapVisitor::new(map)),
             _ => { unimplemented!(); }
         }
     }
 
-    #[inline]
-    fn deserialize_bool<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        visitor.visit_bool(self.into_bool()?)
-    }
-
-    #[inline]
-    fn deserialize_u8<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_u16<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_u32<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_u64<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_i8<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_i16<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_i32<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_i64<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        visitor.visit_i64(self.into_int()?)
-    }
-
-    #[inline]
-    fn deserialize_f32<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_f64<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        visitor.visit_f64(self.into_float()?)
-    }
-
-    #[inline]
-    fn deserialize_char<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_str<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_string<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_bytes<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_byte_buf<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_option<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_unit<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_unit_struct<V: de::Visitor>(self,
-                                               name: &'static str,
-                                               visitor: V)
-                                               -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V: de::Visitor>(self,
-                                                  name: &'static str,
-                                                  visitor: V)
-                                                  -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_seq<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_seq_fixed_size<V: de::Visitor>(self,
-                                                  len: usize,
-                                                  visitor: V)
-                                                  -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_tuple<V: de::Visitor>(self, len: usize, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_tuple_struct<V: de::Visitor>(self,
-                                                name: &'static str,
-                                                len: usize,
-                                                visitor: V)
-                                                -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_enum<V: de::Visitor>(self,
-                                        name: &'static str,
-                                        variants: &'static [&'static str],
-                                        visitor: V)
-                                        -> Result<V::Value> {
-        unimplemented!();
-    }
-
-    #[inline]
-    fn deserialize_ignored_any<V: de::Visitor>(self, visitor: V) -> Result<V::Value> {
-        unimplemented!();
-    }
-
     forward_to_deserialize! {
-        map
-        struct
-        struct_field
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+        seq_fixed_size bytes byte_buf map struct unit enum newtype_struct
+        struct_field ignored_any unit_struct tuple_struct tuple option
     }
 }
 
diff --git a/lib/src/value.rs b/lib/src/value.rs
index 87e45bc..455e951 100644
--- a/lib/src/value.rs
+++ b/lib/src/value.rs
@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fmt::Display;
 use error::*;
@@ -187,6 +188,37 @@ impl Value {
             ValueKind::Array(_) => Err(ConfigError::invalid_type(self.origin.clone(), Unexpected::Seq, &"a floating point")),
         }
     }
+
+    /// Returns `self` into a str, if possible.
+    pub fn into_str(self) -> Result<String> {
+        match self.kind {
+            ValueKind::String(value) => Ok(value),
+
+            // Cannot convert
+            ValueKind::Float(value) => Err(ConfigError::invalid_type(self.origin, Unexpected::Float(value), &"a string")),
+            ValueKind::Integer(value) => Err(ConfigError::invalid_type(self.origin, Unexpected::Integer(value), &"a string")),
+            ValueKind::Boolean(value) => Err(ConfigError::invalid_type(self.origin, Unexpected::Bool(value), &"a string")),
+            ValueKind::Nil => Err(ConfigError::invalid_type(self.origin, Unexpected::Unit, &"a string")),
+            ValueKind::Table(_) => Err(ConfigError::invalid_type(self.origin, Unexpected::Map, &"a string")),
+            ValueKind::Array(_) => Err(ConfigError::invalid_type(self.origin, Unexpected::Seq, &"a string")),
+        }
+    }
+
+    /// Returns `self` into an array, if possible
+    pub fn into_array(self) -> Result<Vec<Value>> {
+        match self.kind {
+            ValueKind::Array(value) => Ok(value),
+            
+            // Cannot convert
+            ValueKind::Float(value) => Err(ConfigError::invalid_type(self.origin, Unexpected::Float(value), &"an array")),
+            ValueKind::String(value) => Err(ConfigError::invalid_type(self.origin, Unexpected::Str(value), &"an array")),
+            ValueKind::Integer(value) => Err(ConfigError::invalid_type(self.origin, Unexpected::Integer(value), &"an array")),
+            ValueKind::Boolean(value) => Err(ConfigError::invalid_type(self.origin, Unexpected::Bool(value), &"an array")),
+            ValueKind::Nil => Err(ConfigError::invalid_type(self.origin, Unexpected::Unit, &"an array")),
+            ValueKind::Table(_) => Err(ConfigError::invalid_type(self.origin, Unexpected::Map, &"an array")),            
+        }
+    }
+
     /// If the `Value` is a Table, returns the associated Map.
     pub fn into_table(self) -> Result<HashMap<String, Value>> {
         match self.kind {