gundb 0.2.1

Distributed graph database that syncs over websockets and multicast
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
110
111
112
113
114
115
116
117
118
119
120

use serde::{Serialize, Deserialize};
use std::collections::BTreeMap;
use serde_json::{json, Value as SerdeJsonValue};
use std::convert::TryFrom;

/// Branch node
pub type Children = BTreeMap<String, NodeData>;

/// Data in a leaf node
#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct NodeData {
    pub value: GunValue,
    pub updated_at: f64
}

impl NodeData {
    pub fn default() -> Self {
        Self {
            value: GunValue::Null,
            updated_at: 0.0
        }
    }
}

/// Value types supported by gun.
#[derive(Clone, Serialize, Deserialize, Debug)]
pub enum GunValue {
    Null,
    Bit(bool),
    Number(f64),
    Text(String),
    Link(String),
}

impl GunValue {
    pub fn size(&self) -> usize {
        match self {
            GunValue::Text(s) => s.len(),
            _ => std::mem::size_of_val(self)
        }
    }

    pub fn to_string(&self) -> String {
        match self {
            GunValue::Null => "null".to_string(),
            GunValue::Bit(bool) => {
                if *bool {
                    "true".to_string()
                } else {
                    "false".to_string()
                }
            }
            GunValue::Number(n) => n.to_string(),
            GunValue::Text(t) => t.clone(),
            GunValue::Link(l) => l.clone(),
        }
    }
}

impl TryFrom<SerdeJsonValue> for GunValue {
    type Error = &'static str;

    fn try_from(v: SerdeJsonValue) -> Result<GunValue, Self::Error> {
        match v {
            SerdeJsonValue::Null => Ok(GunValue::Null),
            SerdeJsonValue::Bool(b) => Ok(GunValue::Bit(b)),
            SerdeJsonValue::String(s) => Ok(GunValue::Text(s)),
            SerdeJsonValue::Number(n) => {
                match n.as_f64() {
                    Some(n) => Ok(GunValue::Number(n)),
                    _ => Err("not convertible to f64")
                }
            },
            SerdeJsonValue::Object(_) => Err("cannot convert json object into GunValue"),
            SerdeJsonValue::Array(_) => Err("cannot convert array into GunValue")
        }
    }
}

impl From<GunValue> for SerdeJsonValue {
    fn from (v: GunValue) -> SerdeJsonValue {
        match v {
            GunValue::Null => SerdeJsonValue::Null,
            GunValue::Text(t) => SerdeJsonValue::String(t),
            GunValue::Bit(b) => SerdeJsonValue::Bool(b),
            GunValue::Number(n) => json!(n),
            GunValue::Link(l) => SerdeJsonValue::String(l) // TODO fix. Object?
        }
    }
}

impl From<usize> for GunValue {
    fn from(n: usize) -> GunValue {
        GunValue::Number(n as f64)
    }
}

impl From<f32> for GunValue {
    fn from(n: f32) -> GunValue {
        GunValue::Number(n as f64)
    }
}

impl From<u64> for GunValue {
    fn from(n: u64) -> GunValue {
        GunValue::Number(n as f64)
    }
}

impl From<&str> for GunValue {
    fn from(s: &str) -> GunValue {
        GunValue::Text(s.to_string())
    }
}

impl From<String> for GunValue {
    fn from(s: String) -> GunValue {
        GunValue::Text(s)
    }
}