signalk 0.7.0

A library to parse signalk maritime data
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
121
122
123
124
125

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, PartialEq, Debug, Default)]
pub struct V1Discovery {
    pub endpoints: HashMap<String, V1DiscoveryEndpoint>,
    pub server: V1DiscoveryServer,
}

impl V1Discovery {
    pub fn builder() -> V1DiscoveryBuilder {
        V1DiscoveryBuilder::default()
    }

    pub fn get_v1_http_endpoint(&self) -> Option<String> {
        if let Some(end) = self.endpoints.get("v1") {
            end.signalk_http.as_ref().cloned()
        } else {
            None
        }
    }

    pub fn get_v1_ws_endpoint(&self) -> Option<String> {
        if let Some(end) = self.endpoints.get("v1") {
            end.signalk_ws.as_ref().cloned()
        } else {
            None
        }
    }
}

#[derive(Default)]
pub struct V1DiscoveryBuilder {
    endpoints: HashMap<String, V1DiscoveryEndpoint>,
    server: V1DiscoveryServer,
}

impl V1DiscoveryBuilder {
    pub fn server(mut self, value: V1DiscoveryServer) -> V1DiscoveryBuilder {
        self.server = value;
        self
    }
    pub fn endpoint(mut self, key: String, value: V1DiscoveryEndpoint) -> V1DiscoveryBuilder {
        self.endpoints.insert(key, value);
        self
    }
    pub fn build(self) -> V1Discovery {
        V1Discovery {
            endpoints: self.endpoints,
            server: self.server,
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Default)]
pub struct V1DiscoveryEndpoint {
    pub version: String,
    // TODO: Version type?
    #[serde(rename = "signalk-http")]
    pub signalk_http: Option<String>,
    // TODO: URL type
    #[serde(rename = "signalk-ws")]
    pub signalk_ws: Option<String>,
    // TODO: URL type
    #[serde(rename = "signalk-tcp")]
    pub signalk_tcp: Option<String>, // TODO: URL type
}

impl V1DiscoveryEndpoint {
    pub fn builder() -> V1DiscoveryEndpointBuilder {
        V1DiscoveryEndpointBuilder::default()
    }
}

#[derive(Default)]
pub struct V1DiscoveryEndpointBuilder {
    version: String,
    signalk_http: Option<String>,
    signalk_ws: Option<String>,
    signalk_tcp: Option<String>,
}

impl V1DiscoveryEndpointBuilder {
    pub fn version(mut self, value: String) -> V1DiscoveryEndpointBuilder {
        self.version = value;
        self
    }
    pub fn signalk_http(mut self, value: String) -> V1DiscoveryEndpointBuilder {
        self.signalk_http = Some(value);
        self
    }
    pub fn signalk_ws(mut self, value: String) -> V1DiscoveryEndpointBuilder {
        self.signalk_ws = Some(value);
        self
    }
    pub fn signalk_tcp(mut self, value: String) -> V1DiscoveryEndpointBuilder {
        self.signalk_tcp = Some(value);
        self
    }
    pub fn build(self) -> V1DiscoveryEndpoint {
        V1DiscoveryEndpoint {
            version: self.version,
            signalk_http: self.signalk_http,
            signalk_ws: self.signalk_ws,
            signalk_tcp: self.signalk_tcp,
        }
    }
}

/// Information about this server
#[derive(Serialize, Deserialize, PartialEq, Debug, Default)]
pub struct V1DiscoveryServer {
    /// The id of this server (signalk-server-node, iKommunicate, etc.)
    pub id: String,

    /// The version of this server (not limited to signalk versioning rules).
    pub version: String,
}

impl V1DiscoveryServer {
    pub fn new(id: String, version: String) -> Self {
        Self { id, version }
    }
}