Implement From/Into traits for Value (#63)

Implement From/Into traits for Value

Author: kyeah

src/bson.rs

@@ -263,103 +263,119 @@ impl From<DateTime<UTC>> for Bson {
     }
 }
 
-impl Bson {
-    /// Get the `ElementType` of this value.
-    pub fn element_type(&self) -> ElementType {
-        match self {
-            &Bson::FloatingPoint(..) => ElementType::FloatingPoint,
-            &Bson::String(..) => ElementType::Utf8String,
-            &Bson::Array(..) => ElementType::Array,
-            &Bson::Document(..) => ElementType::EmbeddedDocument,
-            &Bson::Boolean(..) => ElementType::Boolean,
-            &Bson::Null => ElementType::NullValue,
-            &Bson::RegExp(..) => ElementType::RegularExpression,
-            &Bson::JavaScriptCode(..) => ElementType::JavaScriptCode,
-            &Bson::JavaScriptCodeWithScope(..) => ElementType::JavaScriptCodeWithScope,
-            &Bson::I32(..) => ElementType::Integer32Bit,
-            &Bson::I64(..) => ElementType::Integer64Bit,
-            &Bson::TimeStamp(..) => ElementType::TimeStamp,
-            &Bson::Binary(..) => ElementType::Binary,
-            &Bson::ObjectId(..) => ElementType::ObjectId,
-            &Bson::UtcDatetime(..) => ElementType::UtcDatetime,
-            &Bson::Symbol(..) => ElementType::Symbol,
+impl From<Value> for Bson {
+    fn from(a: Value) -> Bson {
+        match a {
+            Value::Number(x) =>
+                x.as_i64().map(Bson::from)
+                .or(x.as_u64().map(Bson::from))
+                .expect(&format!("Invalid number value: {}", x)),
+            Value::String(x) => x.into(),
+            Value::Bool(x) => x.into(),
+            Value::Array(x) => Bson::Array(x.into_iter().map(Bson::from).collect()),
+            Value::Object(x) => {
+                Bson::from_extended_document(x.into_iter()
+                                             .map(|(k, v)| (k.clone(), v.into()))
+                                             .collect())
+            }
+            Value::Null => Bson::Null,
         }
     }
+}
 
-    /// Convert this value to the best approximate `Json`.
-    pub fn to_json(&self) -> Value {
+impl Into<Value> for Bson {
+    fn into(self) -> Value {
         match self {
-            &Bson::FloatingPoint(v) => json!(v),
-            &Bson::String(ref v) => json!(v),
-            &Bson::Array(ref v) => json!(v),
-            &Bson::Document(ref v) => json!(v),
-            &Bson::Boolean(v) => json!(v),
-            &Bson::Null => Value::Null,
-            &Bson::RegExp(ref pat, ref opt) => {
-                json!({
-                    "$regex": pat,
-                    "$options": opt
-                })
-            }
-            &Bson::JavaScriptCode(ref code) => json!({"$code": code}),
-            &Bson::JavaScriptCodeWithScope(ref code, ref scope) => {
+            Bson::FloatingPoint(v) => json!(v),
+            Bson::String(v) => json!(v),
+            Bson::Array(v) => json!(v),
+            Bson::Document(v) => json!(v),
+            Bson::Boolean(v) => json!(v),
+            Bson::Null => Value::Null,
+            Bson::RegExp(pat, opt) => json!({
+                "$regex": pat,
+                "$options": opt
+            }),
+            Bson::JavaScriptCode(code) => json!({"$code": code}),
+            Bson::JavaScriptCodeWithScope(code, scope) => {
                 json!({
                     "$code": code,
                     "scope": scope
                 })
             }
-            &Bson::I32(v) => v.into(),
-            &Bson::I64(v) => v.into(),
-            &Bson::TimeStamp(v) => {
+            Bson::I32(v) => v.into(),
+            Bson::I64(v) => v.into(),
+            Bson::TimeStamp(v) => {
                 let time = v >> 32;
                 let inc = v & 0x0000FFFF;
-
                 json!({
                     "t": time,
                     "i": inc
                 })
             }
-            &Bson::Binary(t, ref v) => {
+            Bson::Binary(t, ref v) => {
                 let tval: u8 = From::from(t);
                 json!({
                     "type": tval,
                     "$binary": v.to_hex()
                 })
             }
-            &Bson::ObjectId(ref v) => json!({"$oid": v.to_string()}),
-            &Bson::UtcDatetime(ref v) => {
-                json!({
+            Bson::ObjectId(v) => json!({"$oid": v.to_string()}),
+            Bson::UtcDatetime(v) => json!({
                 "$date": {
                     "$numberLong": (v.timestamp() * 1000) + ((v.nanosecond() / 1000000) as i64)
                 }
-            })
-            }
+            }),
             // FIXME: Don't know what is the best way to encode Symbol type
-            &Bson::Symbol(ref v) => json!({"$symbol": v}),
+            Bson::Symbol(v) => json!({"$symbol": v})
         }
     }
+}
 
-    /// Create a `Bson` from a `Json`.
-    pub fn from_json(j: &Value) -> Bson {
-        match j {
-            &Value::Number(ref x) => {
-                x.as_i64()
-                    .map(Bson::from)
-                    .or_else(|| x.as_f64().map(Bson::from))
-                    .expect(&format!("Invalid number value: {}", x))
-            }
-            &Value::String(ref x) => x.into(),
-            &Value::Bool(x) => x.into(),
-            &Value::Array(ref x) => Bson::Array(x.iter().map(Bson::from_json).collect()),
-            &Value::Object(ref x) => {
-                Bson::from_extended_document(x.iter()
-                    .map(|(k, v)| (k.clone(), Bson::from_json(v)))
-                    .collect())
-            }
-            &Value::Null => Bson::Null,
+impl Bson {
+    /// Get the `ElementType` of this value.
+    pub fn element_type(&self) -> ElementType {
+        match self {
+            &Bson::FloatingPoint(..) => ElementType::FloatingPoint,
+            &Bson::String(..) => ElementType::Utf8String,
+            &Bson::Array(..) => ElementType::Array,
+            &Bson::Document(..) => ElementType::EmbeddedDocument,
+            &Bson::Boolean(..) => ElementType::Boolean,
+            &Bson::Null => ElementType::NullValue,
+            &Bson::RegExp(..) => ElementType::RegularExpression,
+            &Bson::JavaScriptCode(..) => ElementType::JavaScriptCode,
+            &Bson::JavaScriptCodeWithScope(..) => ElementType::JavaScriptCodeWithScope,
+            &Bson::I32(..) => ElementType::Integer32Bit,
+            &Bson::I64(..) => ElementType::Integer64Bit,
+            &Bson::TimeStamp(..) => ElementType::TimeStamp,
+            &Bson::Binary(..) => ElementType::Binary,
+            &Bson::ObjectId(..) => ElementType::ObjectId,
+            &Bson::UtcDatetime(..) => ElementType::UtcDatetime,
+            &Bson::Symbol(..) => ElementType::Symbol,
         }
     }
 
+    /// Clones the bson and returns the representative serde_json Value.
+    /// The json will be in [extended JSON format](https://docs.mongodb.com/manual/reference/mongodb-extended-json/).
+    #[deprecated(since="0.5.1", note="use bson.clone().into() instead")]
+    pub fn to_json(&self) -> Value {
+        self.clone().into()
+    }
+
+    /// Consumes the bson and returns the representative serde_json Value.
+    /// The json will be in [extended JSON format](https://docs.mongodb.com/manual/reference/mongodb-extended-json/).
+    #[deprecated(since="0.5.1", note="use bson.into() instead")]
+    pub fn into_json(self) -> Value {
+        self.into()
+    }
+
+    /// Consumes the serde_json Value and returns the representative bson.
+    /// The json should be in [extended JSON format](https://docs.mongodb.com/manual/reference/mongodb-extended-json/).
+    #[deprecated(since="0.5.1", note="use json.into() instead")]
+    pub fn from_json(val: Value) -> Bson {
+        val.into()
+    }
+
     /// Converts to extended format.
     /// This function mainly used for [extended JSON format](https://docs.mongodb.com/manual/reference/mongodb-extended-json/).
     #[doc(hidden)]