gremlin-client 0.8.10

A Rust client for Apache TinkerPop™
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

macro_rules! g_serializer {
    ($name:ident, { $($key:expr => $value:ident),*}) => {
        pub fn $name(val: &Value) -> GremlinResult<GValue> {
            if let Value::String(ref s) = val {
                Ok(s.clone().into())
            } else if let Value::Bool(b) = val {
                Ok((*b).into())
            } else {
                let _type = &val["@type"];
                let _type = get_value!(_type,serde_json::Value::String)?.as_str();
                let _value = &val["@value"];

                match _type {
                    $($key => {
                        $value(&$name,_value)
                    })*
                    _ => Err($crate::GremlinError::Json(format!("Type {} not supported",_type)))
                }
            }
        }
    };
}

macro_rules! g_serializer_2 {
    ($name:ident, { $($key:expr => $value:ident),*}) => {
        pub fn $name(val: &Value) -> GremlinResult<GValue> {
            if let Value::String(ref s) = val {
                return Ok(s.clone().into())
            }
            if let Value::Array(_) = val {
                let _type = "g:List";
                let _value = &val;

                return match _type {
                    $($key => {
                        $value(&$name,_value)
                    })*
                    _ => Err($crate::GremlinError::Json(format!("Type {} not supported",_type)))
                }
            }
            if let Value::Object(ref o) = val {
                if o.contains_key("@type") {
                    let _type = o.get("@type").ok_or_else(|| $crate::GremlinError::Generic("Type missing".to_string()))?.as_str().ok_or_else(|| $crate::GremlinError::Generic("Type should be a string".to_string()))?;
                    let _value = &o.get("@value").ok_or_else(|| $crate::GremlinError::Generic("Value missing".to_string()))?;

                    return match _type {
                        $($key => {
                            $value(&$name,_value)
                        })*
                        _ => Err($crate::GremlinError::Json(format!("Type {} not supported",_type)))
                    }
                }
            }

            let _type = "g:Map";
            let _value = &val;

            match _type {
                $($key => {
                    $value(&$name,_value)
                })*
                _ => Err($crate::GremlinError::Json(format!("Type {} not supported",_type)))
            }
        }
    };
}

macro_rules! get_value {
    ($value:expr,$v:path) => {
        match $value {
            $v(e) => Ok(e),
            _ => Err($crate::GremlinError::Json(String::from(stringify!($v)))),
        }
    };
}

macro_rules! expect_i32 {
    ($value:expr) => {
        match $value.as_i64() {
            Some(v) => Ok(v),
            None => Err($crate::GremlinError::Json(String::from("Expected i32"))),
        }? as i32
    };
}

macro_rules! expect_i64 {
    ($value:expr) => {
        match $value.as_i64() {
            Some(v) => Ok(v),
            None => Err($crate::GremlinError::Json(String::from("Expected i64"))),
        }?
    };
}
macro_rules! expect_float {
    ($value:expr) => {
        match $value.as_f64() {
            Some(v) => Ok(v),
            None => Err($crate::GremlinError::Json(String::from("Expected float"))),
        }? as f32
    };
}
macro_rules! expect_double {
    ($value:expr) => {
        match $value.as_f64() {
            Some(v) => Ok(v),
            None => Err($crate::GremlinError::Json(String::from("Expected double"))),
        }?
    };
}