rust_tdlib/types/
network_type.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Represents the type of a network
8pub trait TDNetworkType: Debug + RObject {}
9
10/// Represents the type of a network
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum NetworkType {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// A mobile network
18    #[serde(rename = "networkTypeMobile")]
19    Mobile(NetworkTypeMobile),
20    /// A mobile roaming network
21    #[serde(rename = "networkTypeMobileRoaming")]
22    MobileRoaming(NetworkTypeMobileRoaming),
23    /// The network is not available
24    #[serde(rename = "networkTypeNone")]
25    None(NetworkTypeNone),
26    /// A different network type (e.g., Ethernet network)
27    #[serde(rename = "networkTypeOther")]
28    Other(NetworkTypeOther),
29    /// A Wi-Fi network
30    #[serde(rename = "networkTypeWiFi")]
31    WiFi(NetworkTypeWiFi),
32}
33
34impl RObject for NetworkType {
35    #[doc(hidden)]
36    fn extra(&self) -> Option<&str> {
37        match self {
38            NetworkType::Mobile(t) => t.extra(),
39            NetworkType::MobileRoaming(t) => t.extra(),
40            NetworkType::None(t) => t.extra(),
41            NetworkType::Other(t) => t.extra(),
42            NetworkType::WiFi(t) => t.extra(),
43
44            _ => None,
45        }
46    }
47    #[doc(hidden)]
48    fn client_id(&self) -> Option<i32> {
49        match self {
50            NetworkType::Mobile(t) => t.client_id(),
51            NetworkType::MobileRoaming(t) => t.client_id(),
52            NetworkType::None(t) => t.client_id(),
53            NetworkType::Other(t) => t.client_id(),
54            NetworkType::WiFi(t) => t.client_id(),
55
56            _ => None,
57        }
58    }
59}
60
61impl NetworkType {
62    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
63        Ok(serde_json::from_str(json.as_ref())?)
64    }
65    #[doc(hidden)]
66    pub fn _is_default(&self) -> bool {
67        matches!(self, NetworkType::_Default)
68    }
69}
70
71impl AsRef<NetworkType> for NetworkType {
72    fn as_ref(&self) -> &NetworkType {
73        self
74    }
75}
76
77/// A mobile network
78#[derive(Debug, Clone, Default, Serialize, Deserialize)]
79pub struct NetworkTypeMobile {
80    #[doc(hidden)]
81    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
82    extra: Option<String>,
83    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
84    client_id: Option<i32>,
85}
86
87impl RObject for NetworkTypeMobile {
88    #[doc(hidden)]
89    fn extra(&self) -> Option<&str> {
90        self.extra.as_deref()
91    }
92    #[doc(hidden)]
93    fn client_id(&self) -> Option<i32> {
94        self.client_id
95    }
96}
97
98impl TDNetworkType for NetworkTypeMobile {}
99
100impl NetworkTypeMobile {
101    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
102        Ok(serde_json::from_str(json.as_ref())?)
103    }
104    pub fn builder() -> NetworkTypeMobileBuilder {
105        let mut inner = NetworkTypeMobile::default();
106        inner.extra = Some(Uuid::new_v4().to_string());
107
108        NetworkTypeMobileBuilder { inner }
109    }
110}
111
112#[doc(hidden)]
113pub struct NetworkTypeMobileBuilder {
114    inner: NetworkTypeMobile,
115}
116
117#[deprecated]
118pub type RTDNetworkTypeMobileBuilder = NetworkTypeMobileBuilder;
119
120impl NetworkTypeMobileBuilder {
121    pub fn build(&self) -> NetworkTypeMobile {
122        self.inner.clone()
123    }
124}
125
126impl AsRef<NetworkTypeMobile> for NetworkTypeMobile {
127    fn as_ref(&self) -> &NetworkTypeMobile {
128        self
129    }
130}
131
132impl AsRef<NetworkTypeMobile> for NetworkTypeMobileBuilder {
133    fn as_ref(&self) -> &NetworkTypeMobile {
134        &self.inner
135    }
136}
137
138/// A mobile roaming network
139#[derive(Debug, Clone, Default, Serialize, Deserialize)]
140pub struct NetworkTypeMobileRoaming {
141    #[doc(hidden)]
142    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
143    extra: Option<String>,
144    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
145    client_id: Option<i32>,
146}
147
148impl RObject for NetworkTypeMobileRoaming {
149    #[doc(hidden)]
150    fn extra(&self) -> Option<&str> {
151        self.extra.as_deref()
152    }
153    #[doc(hidden)]
154    fn client_id(&self) -> Option<i32> {
155        self.client_id
156    }
157}
158
159impl TDNetworkType for NetworkTypeMobileRoaming {}
160
161impl NetworkTypeMobileRoaming {
162    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
163        Ok(serde_json::from_str(json.as_ref())?)
164    }
165    pub fn builder() -> NetworkTypeMobileRoamingBuilder {
166        let mut inner = NetworkTypeMobileRoaming::default();
167        inner.extra = Some(Uuid::new_v4().to_string());
168
169        NetworkTypeMobileRoamingBuilder { inner }
170    }
171}
172
173#[doc(hidden)]
174pub struct NetworkTypeMobileRoamingBuilder {
175    inner: NetworkTypeMobileRoaming,
176}
177
178#[deprecated]
179pub type RTDNetworkTypeMobileRoamingBuilder = NetworkTypeMobileRoamingBuilder;
180
181impl NetworkTypeMobileRoamingBuilder {
182    pub fn build(&self) -> NetworkTypeMobileRoaming {
183        self.inner.clone()
184    }
185}
186
187impl AsRef<NetworkTypeMobileRoaming> for NetworkTypeMobileRoaming {
188    fn as_ref(&self) -> &NetworkTypeMobileRoaming {
189        self
190    }
191}
192
193impl AsRef<NetworkTypeMobileRoaming> for NetworkTypeMobileRoamingBuilder {
194    fn as_ref(&self) -> &NetworkTypeMobileRoaming {
195        &self.inner
196    }
197}
198
199/// The network is not available
200#[derive(Debug, Clone, Default, Serialize, Deserialize)]
201pub struct NetworkTypeNone {
202    #[doc(hidden)]
203    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
204    extra: Option<String>,
205    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
206    client_id: Option<i32>,
207}
208
209impl RObject for NetworkTypeNone {
210    #[doc(hidden)]
211    fn extra(&self) -> Option<&str> {
212        self.extra.as_deref()
213    }
214    #[doc(hidden)]
215    fn client_id(&self) -> Option<i32> {
216        self.client_id
217    }
218}
219
220impl TDNetworkType for NetworkTypeNone {}
221
222impl NetworkTypeNone {
223    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
224        Ok(serde_json::from_str(json.as_ref())?)
225    }
226    pub fn builder() -> NetworkTypeNoneBuilder {
227        let mut inner = NetworkTypeNone::default();
228        inner.extra = Some(Uuid::new_v4().to_string());
229
230        NetworkTypeNoneBuilder { inner }
231    }
232}
233
234#[doc(hidden)]
235pub struct NetworkTypeNoneBuilder {
236    inner: NetworkTypeNone,
237}
238
239#[deprecated]
240pub type RTDNetworkTypeNoneBuilder = NetworkTypeNoneBuilder;
241
242impl NetworkTypeNoneBuilder {
243    pub fn build(&self) -> NetworkTypeNone {
244        self.inner.clone()
245    }
246}
247
248impl AsRef<NetworkTypeNone> for NetworkTypeNone {
249    fn as_ref(&self) -> &NetworkTypeNone {
250        self
251    }
252}
253
254impl AsRef<NetworkTypeNone> for NetworkTypeNoneBuilder {
255    fn as_ref(&self) -> &NetworkTypeNone {
256        &self.inner
257    }
258}
259
260/// A different network type (e.g., Ethernet network)
261#[derive(Debug, Clone, Default, Serialize, Deserialize)]
262pub struct NetworkTypeOther {
263    #[doc(hidden)]
264    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
265    extra: Option<String>,
266    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
267    client_id: Option<i32>,
268}
269
270impl RObject for NetworkTypeOther {
271    #[doc(hidden)]
272    fn extra(&self) -> Option<&str> {
273        self.extra.as_deref()
274    }
275    #[doc(hidden)]
276    fn client_id(&self) -> Option<i32> {
277        self.client_id
278    }
279}
280
281impl TDNetworkType for NetworkTypeOther {}
282
283impl NetworkTypeOther {
284    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
285        Ok(serde_json::from_str(json.as_ref())?)
286    }
287    pub fn builder() -> NetworkTypeOtherBuilder {
288        let mut inner = NetworkTypeOther::default();
289        inner.extra = Some(Uuid::new_v4().to_string());
290
291        NetworkTypeOtherBuilder { inner }
292    }
293}
294
295#[doc(hidden)]
296pub struct NetworkTypeOtherBuilder {
297    inner: NetworkTypeOther,
298}
299
300#[deprecated]
301pub type RTDNetworkTypeOtherBuilder = NetworkTypeOtherBuilder;
302
303impl NetworkTypeOtherBuilder {
304    pub fn build(&self) -> NetworkTypeOther {
305        self.inner.clone()
306    }
307}
308
309impl AsRef<NetworkTypeOther> for NetworkTypeOther {
310    fn as_ref(&self) -> &NetworkTypeOther {
311        self
312    }
313}
314
315impl AsRef<NetworkTypeOther> for NetworkTypeOtherBuilder {
316    fn as_ref(&self) -> &NetworkTypeOther {
317        &self.inner
318    }
319}
320
321/// A Wi-Fi network
322#[derive(Debug, Clone, Default, Serialize, Deserialize)]
323pub struct NetworkTypeWiFi {
324    #[doc(hidden)]
325    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
326    extra: Option<String>,
327    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
328    client_id: Option<i32>,
329}
330
331impl RObject for NetworkTypeWiFi {
332    #[doc(hidden)]
333    fn extra(&self) -> Option<&str> {
334        self.extra.as_deref()
335    }
336    #[doc(hidden)]
337    fn client_id(&self) -> Option<i32> {
338        self.client_id
339    }
340}
341
342impl TDNetworkType for NetworkTypeWiFi {}
343
344impl NetworkTypeWiFi {
345    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
346        Ok(serde_json::from_str(json.as_ref())?)
347    }
348    pub fn builder() -> NetworkTypeWiFiBuilder {
349        let mut inner = NetworkTypeWiFi::default();
350        inner.extra = Some(Uuid::new_v4().to_string());
351
352        NetworkTypeWiFiBuilder { inner }
353    }
354}
355
356#[doc(hidden)]
357pub struct NetworkTypeWiFiBuilder {
358    inner: NetworkTypeWiFi,
359}
360
361#[deprecated]
362pub type RTDNetworkTypeWiFiBuilder = NetworkTypeWiFiBuilder;
363
364impl NetworkTypeWiFiBuilder {
365    pub fn build(&self) -> NetworkTypeWiFi {
366        self.inner.clone()
367    }
368}
369
370impl AsRef<NetworkTypeWiFi> for NetworkTypeWiFi {
371    fn as_ref(&self) -> &NetworkTypeWiFi {
372        self
373    }
374}
375
376impl AsRef<NetworkTypeWiFi> for NetworkTypeWiFiBuilder {
377    fn as_ref(&self) -> &NetworkTypeWiFi {
378        &self.inner
379    }
380}
rust_tdlib/types/network_type.rs

rust_tdlib/types/
network_type.rs
