mongodb 0.1.0

An experimental MongoDB driver written by MongoDB interns.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use bson::Bson;
use nalgebra::ApproxEq;

pub trait NumEq {
    fn float_eq(&self, f: f64) -> bool;
    fn int_eq(&self, i: i64) -> bool;
}

impl NumEq for Bson {
    fn float_eq(&self, f: f64) -> bool {
        match self {
            &Bson::FloatingPoint(ref ff) => f.approx_eq(ff),
            &Bson::I32(i) => f.approx_eq(&(i as f64)),
            &Bson::I64(i) => f.approx_eq(&(i as f64)),
            _ => false
        }
    }

    fn int_eq(&self, i: i64) -> bool {
        match self {
            &Bson::FloatingPoint(ref f) => f.approx_eq(&(i as f64)),
            &Bson::I32(ii) => i == (ii as i64),
            &Bson::I64(ii) => i == ii,
            _ => false
        }
    }
}

pub fn bson_eq(b1: &Bson, b2: &Bson) -> bool {
    macro_rules! doc_eq {
        ( $x:expr, $y:expr ) => {
            {
                if $x.keys != $y.keys {
                    return false;
                }

                for key in $x.keys {
                    match ($x.get(&key), $y.get(&key)) {
                        (Some(v1), Some(v2)) => if !bson_eq(v1, v2) {
                            return false;
                        },
                        (None, None) => (),
                        _ => return false
                    }
                }

                true
            }
        };
    }

    match b1 {
        &Bson::FloatingPoint(f) => b2.float_eq(f),
        &Bson::I32(i) => b2.int_eq(i as i64),
        &Bson::I64(i) => b2.int_eq(i),
        &Bson::String(ref s) =>
            var_match!(b2, &Bson::String(ref ss) => s == ss),
        &Bson::Array(ref arr) => var_match!(b2, &Bson::Array(ref other_arr) => {
            for val1 in arr {
                for val2 in other_arr {
                    if !bson_eq(val1, val2) {
                        return false
                    }
                }
            }
            true
        }),
        &Bson::Document(ref doc) =>
            var_match!(b2, &Bson::Document(ref other_doc) =>
                       doc_eq!(doc.clone(), other_doc.clone())),
        &Bson::Boolean(b) => var_match!(b2, &Bson::Boolean(bb) => b == bb),
        &Bson::Null => var_match!(b2, &Bson::Null => true),
        &Bson::RegExp(ref s1, ref s2) =>
            var_match!(b2, &Bson::RegExp(ref ss1, ref ss2) =>
                       s1 == ss1 && s2 == ss2),
        &Bson::JavaScriptCode(ref s) =>
            var_match!(b2, &Bson::JavaScriptCode(ref ss) => s == ss),
        &Bson::JavaScriptCodeWithScope(ref s, ref doc) =>
            var_match!(b2, &Bson::JavaScriptCodeWithScope(ref ss, ref other_doc) =>
                       s == ss && doc_eq!(doc.clone(), other_doc.clone())),
        &Bson::TimeStamp(i) => var_match!(b2, &Bson::TimeStamp(ii) => i == ii),
        &Bson::Binary(sub_ty, ref bits) =>
            var_match!(b2, &Bson::Binary(other_sub_ty, ref other_bits) =>
                       sub_ty == other_sub_ty && bits == other_bits),
        &Bson::ObjectId(ref bits) => var_match!(b2, &Bson::ObjectId(ref other_bits) =>
                                                bits == other_bits),
        &Bson::UtcDatetime(date_time) =>
            var_match!(b2, &Bson::UtcDatetime(other_date_time) =>
                       date_time == other_date_time)
    }
}