socketboard 0.1.0

The official Rust SDK for Socketboard, a lightweight websocket variable table.
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 std::collections::HashMap;
use std::fmt::Display;
use serde_json::Value;

#[derive(Clone)]
pub enum Data {
    String(String),
    Number(f64),
    Boolean(bool),
    Array(Vec<Data>),
    Object(HashMap<String, Data>),
    None,
}

impl Display for Data {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Data::String(s) => write!(f, "{}", s),
            Data::Number(n) => write!(f, "{}", n),
            Data::Boolean(b) => write!(f, "{}", b),
            Data::Array(a) => {
                write!(f, "[")?;
                for (i, data) in a.iter().enumerate() {
                    write!(f, "{}", data)?;
                    if i < a.len() - 1 {
                        write!(f, ", ")?;
                    }
                }
                write!(f, "]")
            }
            Data::Object(o) => {
                write!(f, "{{")?;
                for (i, (key, value)) in o.iter().enumerate() {
                    write!(f, "\"{}\": {}", key, value)?;
                    if i < o.len() - 1 {
                        write!(f, ", ")?;
                    }
                }
                write!(f, "}}")
            }
            Data::None => write!(f, "None"),
        }
    }
}

pub trait JSON {
    fn to_json(&self) -> serde_json::Value;
    fn from_json(value: &serde_json::Value) -> Self;
}

impl JSON for Data {
    fn to_json(&self) -> Value {
        match self {
            Data::String(s) => Value::String(s.clone()),
            Data::Number(n) => Value::Number(serde_json::Number::from_f64(*n).unwrap()),
            Data::Boolean(b) => Value::Bool(*b),
            Data::Array(a) => {
                let mut json_array = Vec::new();
                for data in a {
                    json_array.push(data.to_json());
                }
                Value::Array(json_array)
            }
            Data::Object(o) => {
                let mut json_object = serde_json::Map::new();
                for (key, value) in o {
                    json_object.insert(key.clone(), value.to_json());
                }
                Value::Object(json_object)
            }
            Data::None => Value::Null,
        }
    }
    
    fn from_json(value: &Value) -> Self {
        match value {
            Value::String(s) => Data::String(s.clone()),
            Value::Number(n) => Data::Number(n.as_f64().unwrap()),
            Value::Bool(b) => Data::Boolean(*b),
            Value::Array(a) => {
                let mut data_array = Vec::new();
                for json_value in a {
                    data_array.push(Data::from_json(json_value));
                }
                Data::Array(data_array)
            }
            Value::Object(o) => {
                let mut data_object = HashMap::new();
                for (key, json_value) in o {
                    data_object.insert(key.clone(), Data::from_json(json_value));
                }
                Data::Object(data_object)
            }
            Value::Null => Data::None,
        }
    }
}

#[derive(Clone)]
pub enum ConnectionStatus {
    Connected(String),
    Failed(String),
    Disconnected(String),
    Connecting,
    Stopped,
    None
}

impl Display for ConnectionStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            ConnectionStatus::Connected(address) => write!(f, "Connected to {}", address),
            ConnectionStatus::Failed(address) => write!(f, "Failed to connect to {}", address),
            ConnectionStatus::Disconnected(address) => write!(f, "Disconnected from {}", address),
            ConnectionStatus::Connecting => write!(f, "Connecting..."),
            ConnectionStatus::Stopped => write!(f, "Stopped"),
            ConnectionStatus::None => write!(f, "None"),
        }
    }
}