Helpers to directly get inner values

Author: thijsc

src/bson.rs

@@ -32,7 +32,7 @@ use spec::{ElementType, BinarySubtype};
 use oid;
 
 /// Possible BSON value types.
-#[derive(Debug, Clone)]
+#[derive(Debug,Clone,PartialEq)]
 pub enum Bson {
     FloatingPoint(f64),
     String(String),

src/lib.rs

@@ -53,6 +53,7 @@ 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 mod macros;
 pub mod oid;

src/oid.rs

@@ -76,7 +76,7 @@ impl error::Error for Error {
     }
 
     fn cause(&self) -> Option<&error::Error> {
-        match self {            
+        match self {
             &Error::ArgumentError(_) => None,
             &Error::FromHexError(ref inner) => Some(inner),
             &Error::IoError(ref inner) => Some(inner),

src/ordered.rs

@@ -1,12 +1,24 @@
-use bson::Bson;
+use chrono::{DateTime, UTC};
+use bson::{Array,Bson,Document};
+use super::oid::ObjectId;
 use std::collections::BTreeMap;
 use std::fmt::{Display, Error, Formatter};
 use std::iter::{FromIterator, Map};
 use std::vec::IntoIter;
 use std::slice;
 
+/// Error to indicate that either a value was empty or it contained an unexpected
+/// type, for use with the direct getters.
+#[derive(Debug,PartialEq)]
+pub enum ValueAccessError {
+    NotPresent,
+    UnexpectedType
+}
+
+pub type ValueAccessResult<T> = Result<T, ValueAccessError>;
+
 /// A BSON document represented as an associative BTree Map with insertion ordering.
-#[derive(Debug, Clone)]
+#[derive(Debug,Clone,PartialEq)]
 pub struct OrderedDocument {
     pub keys: Vec<String>,
     document: BTreeMap<String, Bson>,
@@ -147,11 +159,109 @@ impl OrderedDocument {
         self.document.get(key)
     }
 
-    /// Gets a mutable reference to the value in the entry.
+    /// Gets a mutable reference to the Bson corresponding to the key
     pub fn get_mut(&mut self, key: &str) -> Option<&mut Bson> {
         self.document.get_mut(key)
     }
 
+    /// Get a floating point value for this key if it exists and has
+    /// the correct type.
+    pub fn get_f64(&self, key: &str) -> ValueAccessResult<f64> {
+        match self.get(key) {
+            Some(&Bson::FloatingPoint(v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get a string slice this key if it exists and has the correct type.
+    pub fn get_str(&self, key: &str) -> ValueAccessResult<&str> {
+        match self.get(key) {
+            Some(&Bson::String(ref v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get a reference to an array for this key if it exists and has
+    /// the correct type.
+    pub fn get_array(&self, key: &str) -> ValueAccessResult<&Array> {
+        match self.get(key) {
+            Some(&Bson::Array(ref v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get a reference to a document for this key if it exists and has
+    /// the correct type.
+    pub fn get_document(&self, key: &str) -> ValueAccessResult<&Document> {
+        match self.get(key) {
+            Some(&Bson::Document(ref v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get a bool value for this key if it exists and has the correct type.
+    pub fn get_bool(&self, key: &str) -> ValueAccessResult<bool> {
+        match self.get(key) {
+            Some(&Bson::Boolean(v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Returns wether this key has a null value
+    pub fn is_null(&self, key: &str) -> bool {
+        self.get(key) == Some(&Bson::Null)
+    }
+
+    /// Get an i32 value for this key if it exists and has the correct type.
+    pub fn get_i32(&self, key: &str) -> ValueAccessResult<i32> {
+        match self.get(key) {
+            Some(&Bson::I32(v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get an i64 value for this key if it exists and has the correct type.
+    pub fn get_i64(&self, key: &str) -> ValueAccessResult<i64> {
+        match self.get(key) {
+            Some(&Bson::I64(v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get a time stamp value for this key if it exists and has the correct type.
+    pub fn get_time_stamp(&self, key: &str) -> ValueAccessResult<i64> {
+        match self.get(key) {
+            Some(&Bson::TimeStamp(v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get an object id value for this key if it exists and has the correct type.
+    pub fn get_object_id(&self, key: &str) -> ValueAccessResult<&ObjectId> {
+        match self.get(key) {
+            Some(&Bson::ObjectId(ref v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
+    /// Get a UTC datetime value for this key if it exists and has the correct type.
+    pub fn get_utc_datetime(&self, key: &str) -> ValueAccessResult<&DateTime<UTC>> {
+        match self.get(key) {
+            Some(&Bson::UtcDatetime(ref v)) => Ok(v),
+            Some(_) => Err(ValueAccessError::UnexpectedType),
+            None => Err(ValueAccessError::NotPresent)
+        }
+    }
+
     /// Returns true if the map contains a value for the specified key.
     pub fn contains_key(&self, key: &str) -> bool {
         self.document.contains_key(key)

tests/modules/ordered.rs

@@ -1,4 +1,7 @@
 use bson::{Bson, Document};
+use bson::ValueAccessError;
+use bson::oid::ObjectId;
+use chrono::UTC;
 
 #[test]
 fn ordered_insert() {
@@ -34,6 +37,66 @@ fn ordered_insert_shorthand() {
     assert_eq!(expected_keys, keys);
 }
 
+#[test]
+fn test_getters() {
+    let datetime = UTC::now();
+    let cloned_dt = datetime.clone();
+    let mut doc = doc! {
+        "floating_point" => 10.0,
+        "string" => "a value",
+        "array" => [10, 20, 30],
+        "doc" => { "key" => 1 },
+        "bool" => true,
+        "i32" => 1i32,
+        "i64" => 1i64,
+        "datetime" => cloned_dt
+    };
+
+    assert_eq!(None, doc.get("nonsense"));
+    assert_eq!(Err(ValueAccessError::NotPresent), doc.get_str("nonsense"));
+    assert_eq!(Err(ValueAccessError::UnexpectedType), doc.get_str("floating_point"));
+
+    assert_eq!(Some(&Bson::FloatingPoint(10.0)), doc.get("floating_point"));
+    assert_eq!(Ok(10.0), doc.get_f64("floating_point"));
+
+    assert_eq!(Some(&Bson::String("a value".to_string())), doc.get("string"));
+    assert_eq!(Ok("a value"), doc.get_str("string"));
+
+    let array = vec![Bson::I32(10), Bson::I32(20), Bson::I32(30)];
+    assert_eq!(Some(&Bson::Array(array.clone())), doc.get("array"));
+    assert_eq!(Ok(&array), doc.get_array("array"));
+
+    let embedded = doc! { "key" => 1 };
+    assert_eq!(Some(&Bson::Document(embedded.clone())), doc.get("doc"));
+    assert_eq!(Ok(&embedded), doc.get_document("doc"));
+
+    assert_eq!(Some(&Bson::Boolean(true)), doc.get("bool"));
+    assert_eq!(Ok(true), doc.get_bool("bool"));
+
+    doc.insert("null".to_string(), Bson::Null);
+    assert_eq!(Some(&Bson::Null), doc.get("null"));
+    assert_eq!(true, doc.is_null("null"));
+    assert_eq!(false, doc.is_null("array"));
+
+    assert_eq!(Some(&Bson::I32(1)), doc.get("i32"));
+    assert_eq!(Ok(1i32), doc.get_i32("i32"));
+
+    assert_eq!(Some(&Bson::I64(1)), doc.get("i64"));
+    assert_eq!(Ok(1i64), doc.get_i64("i64"));
+
+    doc.insert("timestamp".to_string(), Bson::TimeStamp(100));
+    assert_eq!(Some(&Bson::TimeStamp(100)), doc.get("timestamp"));
+    assert_eq!(Ok(100i64), doc.get_time_stamp("timestamp"));
+
+    let object_id = ObjectId::new().unwrap();
+    doc.insert("_id".to_string(), Bson::ObjectId(object_id.clone()));
+    assert_eq!(Some(&Bson::ObjectId(object_id.clone())), doc.get("_id"));
+    assert_eq!(Ok(&object_id), doc.get_object_id("_id"));
+
+    assert_eq!(Some(&Bson::UtcDatetime(datetime.clone())), doc.get("datetime"));
+    assert_eq!(Ok(&datetime), doc.get_utc_datetime("datetime"));
+}
+
 #[test]
 fn remove() {
     let mut doc = Document::new();