BSON De/serialization

Author: kyeah

Cargo.toml

@@ -17,4 +17,9 @@ libc = "0.1"
 rand = "0.3"
 rust-crypto = "0.2.31"
 rustc-serialize = "0.3"
+serde = "~0.6.1"
 time = "0.1"
+
+[dependencies.num]
+version = "~0.1.27"
+default-features = false

src/bson.rs

@@ -23,9 +23,10 @@
 
 use std::fmt::{Display, Error, Formatter};
 
-use chrono::{DateTime, UTC};
+use chrono::{DateTime, Timelike, UTC};
+use chrono::offset::TimeZone;
 use rustc_serialize::json;
-use rustc_serialize::hex::ToHex;
+use rustc_serialize::hex::{FromHex, ToHex};
 
 use ordered::OrderedDocument;
 use spec::{ElementType, BinarySubtype};
@@ -290,4 +291,85 @@ impl Bson {
             &json::Json::Null => Bson::Null,
         }
     }
+
+    pub fn to_extended_document(&self) -> Document {
+        match *self {
+            Bson::RegExp(ref pat, ref opt) => {
+                doc! {
+                    "$regex" => (pat.clone()),
+                    "$options" => (opt.clone())
+                }
+            }
+            Bson::JavaScriptCode(ref code) => {
+                doc! {
+                    "$code" => (code.clone())
+                }
+            }
+            Bson::JavaScriptCodeWithScope(ref code, ref scope) => {
+                doc! {
+                    "$code" => (code.clone()),
+                    "$scope" => (scope.clone())
+                }
+            }
+            Bson::TimeStamp(v) => {
+                // TODO
+                doc! {
+                    //"$timestamp" => {
+//                        "t" => (v[0..4] as i32),
+                    //"i" => (v[4..8] as i32),
+                    "$timestamp" => v
+                }
+            }
+            Bson::Binary(t, ref v) => {
+                let tval: u8 = From::from(t);
+                doc! {
+                    "$binary" => (v.to_hex()),
+                    "type" => (tval as i64)
+                }
+            }
+            Bson::ObjectId(ref v) => {
+                doc! {
+                    "$oid" => (v.to_string())
+                }
+            }
+            Bson::UtcDatetime(ref v) => {
+                doc! {
+                    "$date" => {
+                        "$numberLong" => ((v.timestamp() * 1000) + (v.nanosecond() / 1000000) as i64)
+                    }
+                }
+            }
+            // TODO: Actual error
+            _ => unreachable!()
+        }
+    }
+
+    pub fn from_extended_document(values: Document) -> Result<Bson, Error> {
+        if let Some(&Bson::String(ref pat)) = values.get("$regex") {
+            if let Some(&Bson::String(ref opt)) = values.get("$options") {
+                return Ok(Bson::RegExp(pat.to_owned(), opt.to_owned()));
+            }
+        } else if let Some(&Bson::String(ref code)) = values.get("$code") {
+            if let Some(&Bson::Document(ref scope)) = values.get("$sscope") {
+                return Ok(Bson::JavaScriptCodeWithScope(code.to_owned(), scope.to_owned()));
+            } else {
+                return Ok(Bson::JavaScriptCode(code.to_owned()));
+            }
+        } else if values.contains_key("$timestamp") {
+            // TODO
+        } else if let Some(&Bson::String(ref hex)) = values.get("$binary") {
+            if let Some(&Bson::I64(t)) = values.get("type") {
+                let ttype = t as u8;
+                return Ok(Bson::Binary(From::from(ttype), hex.from_hex().unwrap()));
+            }
+        } else if let Some(&Bson::String(ref hex)) = values.get("$oid") {
+            return Ok(Bson::ObjectId(oid::ObjectId::with_string(hex).unwrap()));
+        } else if let Some(&Bson::Document(ref doc)) = values.get("$date") {
+            if let Some(&Bson::I64(long)) = doc.get("$numberLong") {
+                return Ok(Bson::UtcDatetime(UTC.timestamp(long / 1000, (long % 1000) as u32 * 1000000)));
+            }
+        }       
+        
+        Ok(Bson::Document(values))
+    }
 }

src/lib.rs

@@ -48,17 +48,21 @@ extern crate crypto;
 extern crate libc;
 extern crate rand;
 extern crate rustc_serialize;
+extern crate serde;
 extern crate time;
 
 pub use self::bson::{Bson, Document, Array};
 pub use self::encoder::{encode_document, EncoderResult, EncoderError};
 pub use self::decoder::{decode_document, DecoderResult, DecoderError};
 pub use self::ordered::{ValueAccessError, ValueAccessResult};
+pub use self::ser::{to_bson, from_bson};
 
+#[macro_use]
 pub mod macros;
 pub mod oid;
 pub mod spec;
 mod bson;
 mod encoder;
 mod decoder;
 mod ordered;
+mod ser;

src/ordered.rs

@@ -9,6 +9,8 @@ use std::fmt::{Debug, Display, Error, Formatter};
 use std::iter::{FromIterator, Map};
 use std::vec::IntoIter;
 use std::slice;
+use serde::ser::{Serialize, Serializer};
+use serde::ser::impls::MapIteratorVisitor;
 
 /// Error to indicate that either a value was empty or it contained an unexpected
 /// type, for use with the direct getters.
@@ -365,3 +367,21 @@ impl OrderedDocument {
         self.document.remove(key)
     }
 }
+
+impl Serialize for OrderedDocument {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+impl From<BTreeMap<String, Bson>> for OrderedDocument {
+    fn from(tree: BTreeMap<String, Bson>) -> OrderedDocument {        
+        OrderedDocument {
+            keys: tree.keys().cloned().collect(),
+            document: tree,
+        }
+    }
+}