ggapi 0.2.5

A library for communicating with start.gg's API.
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212


use serde::{
    Deserialize,
    Serialize,
};

/// Equivalent for start.gg Streams.
///
/// Each element in the structure is optional, allowing a user to only query values they want.
/// Given each is an option and not a requirement, a method is included for each element with the same name.
/// These methods will unwrap and return the proper value without any unwrapping or references needed.
#[derive(Clone, Default, Serialize, Deserialize)]
pub struct GGStreams {

    pub enabled:            Option<bool>,

    #[serde(rename(serialize = "followerCount",     deserialize = "followerCount"))]
    pub follower_count:     Option<i64>,
    pub id:                 Option<i64>,

    #[serde(rename(serialize = "isOnline",          deserialize = "isOnline"))]
    pub is_online:          Option<bool>,

    #[serde(rename(serialize = "numSetups",         deserialize = "numSetups"))]
    pub num_setups:         Option<i64>,

    #[serde(rename(serialize = "parentStreamId",    deserialize = "parentStreamId"))]
    pub parent_stream_id:   Option<i64>,

    #[serde(rename(serialize = "streamGame",        deserialize = "streamGame"))]
    pub stream_game:        Option<String>,

    #[serde(rename(serialize = "streamId",          deserialize = "streamId"))]
    pub stream_id:          Option<String>,

    #[serde(rename(serialize = "streamLogo",        deserialize = "streamLogo"))]
    pub stream_logo:        Option<String>,

    #[serde(rename(serialize = "streamName",        deserialize = "streamName"))]
    pub stream_name:        Option<String>,

    #[serde(rename(serialize = "streamSource",      deserialize = "streamSource"))]
    pub stream_source:      Option<i64>,

    #[serde(rename(serialize = "streamStatus",      deserialize = "streamStatus"))]
    pub stream_status:      Option<String>,

    #[serde(rename(serialize = "streamType",        deserialize = "streamType"))]
    pub stream_type:        Option<i64>,

    #[serde(rename(serialize = "streamTypeId",      deserialize = "streamTypeId"))]
    pub stream_type_id:     Option<i64>,

}

impl GGStreams {

    /// Returns if the streams are enabled.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn enabled(&self) -> bool {
        let mut result: bool = false;
        if self.enabled.is_some() {
            result = self.enabled.unwrap().clone();
        }
        return result;
    }

    /// Returns the follower count of the streams.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn follower_count(&self) -> i64 {
        let mut result: i64 = 0;
        if self.follower_count.is_some() {
            result = self.follower_count.unwrap().clone();
        }
        return result;
    }

    /// Returns the id of the streams.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn id(&self) -> i64 {
        let mut result: i64 = 0;
        if self.id.is_some() {
            result = self.id.unwrap().clone();
        }
        return result;
    }

    /// Returns if the streams is online.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn is_online(&self) -> bool {
        let mut result: bool = false;
        if self.is_online.is_some() {
            result = self.is_online.unwrap().clone();
        }
        return result;
    }

    /// Returns the number of setups on the streams.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn num_setups(&self) -> i64 {
        let mut result: i64 = 0;
        if self.num_setups.is_some() {
            result = self.num_setups.unwrap().clone();
        }
        return result;
    }

    /// Returns the parent stream id of the streams.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn parent_stream_id(&self) -> i64 {
        let mut result: i64 = 0;
        if self.parent_stream_id.is_some() {
            result = self.parent_stream_id.unwrap().clone();
        }
        return result;
    }

    /// Returns the stream game of the streams.
    ///
    /// Returns an empty string if not set or wasn't queried.
    pub fn stream_game(&self) -> String {
        let mut result: String = "".to_string();
        if self.stream_game.is_some() {
            result = self.stream_game.clone().unwrap().clone();
        }
        return result;
    }

    /// Returns the stream id of the streams.
    ///
    /// Returns an empty string if not set or wasn't queried.
    pub fn stream_id(&self) -> String {
        let mut result: String = "".to_string();
        if self.stream_id.is_some() {
            result = self.stream_id.clone().unwrap().clone();
        }
        return result;
    }

    /// Returns the stream logo of the streams.
    ///
    /// Returns an empty string if not set or wasn't queried.
    pub fn stream_logo(&self) -> String {
        let mut result: String = "".to_string();
        if self.stream_logo.is_some() {
            result = self.stream_logo.clone().unwrap().clone();
        }
        return result;
    }

    /// Returns the stream name of the streams.
    ///
    /// Returns an empty string if not set or wasn't queried.
    pub fn stream_name(&self) -> String {
        let mut result: String = "".to_string();
        if self.stream_name.is_some() {
            result = self.stream_name.clone().unwrap().clone();
        }
        return result;
    }

    /// Returns the stream source of the streams.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn stream_source(&self) -> i64 {
        let mut result: i64 = 0;
        if self.stream_source.is_some() {
            result = self.stream_source.unwrap().clone();
        }
        return result;
    }

    /// Returns the stream status of the streams.
    ///
    /// Returns an empty string if not set or wasn't queried.
    pub fn stream_status(&self) -> String {
        let mut result: String = "".to_string();
        if self.stream_status.is_some() {
            result = self.stream_status.clone().unwrap().clone();
        }
        return result;
    }

    /// Returns the stream type of the streams.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn stream_type(&self) -> i64 {
        let mut result: i64 = 0;
        if self.stream_type.is_some() {
            result = self.stream_type.unwrap().clone();
        }
        return result;
    }

    /// Returns the stream type id of the streams.
    ///
    /// Returns zero if not set or wasn't queried.
    pub fn stream_type_id(&self) -> i64 {
        let mut result: i64 = 0;
        if self.stream_type_id.is_some() {
            result = self.stream_type_id.unwrap().clone();
        }
        return result;
    }

}