rust_tdlib/types/
connection_state.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Describes the current state of the connection to Telegram servers
8pub trait TDConnectionState: Debug + RObject {}
9
10/// Describes the current state of the connection to Telegram servers
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum ConnectionState {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// Currently establishing a connection to the Telegram servers
18    #[serde(rename = "connectionStateConnecting")]
19    Connecting(ConnectionStateConnecting),
20    /// Currently establishing a connection with a proxy server
21    #[serde(rename = "connectionStateConnectingToProxy")]
22    ConnectingToProxy(ConnectionStateConnectingToProxy),
23    /// There is a working connection to the Telegram servers
24    #[serde(rename = "connectionStateReady")]
25    Ready(ConnectionStateReady),
26    /// Downloading data received while the application was offline
27    #[serde(rename = "connectionStateUpdating")]
28    Updating(ConnectionStateUpdating),
29    /// Currently waiting for the network to become available. Use setNetworkType to change the available network type
30    #[serde(rename = "connectionStateWaitingForNetwork")]
31    WaitingForNetwork(ConnectionStateWaitingForNetwork),
32}
33
34impl RObject for ConnectionState {
35    #[doc(hidden)]
36    fn extra(&self) -> Option<&str> {
37        match self {
38            ConnectionState::Connecting(t) => t.extra(),
39            ConnectionState::ConnectingToProxy(t) => t.extra(),
40            ConnectionState::Ready(t) => t.extra(),
41            ConnectionState::Updating(t) => t.extra(),
42            ConnectionState::WaitingForNetwork(t) => t.extra(),
43
44            _ => None,
45        }
46    }
47    #[doc(hidden)]
48    fn client_id(&self) -> Option<i32> {
49        match self {
50            ConnectionState::Connecting(t) => t.client_id(),
51            ConnectionState::ConnectingToProxy(t) => t.client_id(),
52            ConnectionState::Ready(t) => t.client_id(),
53            ConnectionState::Updating(t) => t.client_id(),
54            ConnectionState::WaitingForNetwork(t) => t.client_id(),
55
56            _ => None,
57        }
58    }
59}
60
61impl ConnectionState {
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, ConnectionState::_Default)
68    }
69}
70
71impl AsRef<ConnectionState> for ConnectionState {
72    fn as_ref(&self) -> &ConnectionState {
73        self
74    }
75}
76
77/// Currently establishing a connection to the Telegram servers
78#[derive(Debug, Clone, Default, Serialize, Deserialize)]
79pub struct ConnectionStateConnecting {
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 ConnectionStateConnecting {
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 TDConnectionState for ConnectionStateConnecting {}
99
100impl ConnectionStateConnecting {
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() -> ConnectionStateConnectingBuilder {
105        let mut inner = ConnectionStateConnecting::default();
106        inner.extra = Some(Uuid::new_v4().to_string());
107
108        ConnectionStateConnectingBuilder { inner }
109    }
110}
111
112#[doc(hidden)]
113pub struct ConnectionStateConnectingBuilder {
114    inner: ConnectionStateConnecting,
115}
116
117#[deprecated]
118pub type RTDConnectionStateConnectingBuilder = ConnectionStateConnectingBuilder;
119
120impl ConnectionStateConnectingBuilder {
121    pub fn build(&self) -> ConnectionStateConnecting {
122        self.inner.clone()
123    }
124}
125
126impl AsRef<ConnectionStateConnecting> for ConnectionStateConnecting {
127    fn as_ref(&self) -> &ConnectionStateConnecting {
128        self
129    }
130}
131
132impl AsRef<ConnectionStateConnecting> for ConnectionStateConnectingBuilder {
133    fn as_ref(&self) -> &ConnectionStateConnecting {
134        &self.inner
135    }
136}
137
138/// Currently establishing a connection with a proxy server
139#[derive(Debug, Clone, Default, Serialize, Deserialize)]
140pub struct ConnectionStateConnectingToProxy {
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 ConnectionStateConnectingToProxy {
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 TDConnectionState for ConnectionStateConnectingToProxy {}
160
161impl ConnectionStateConnectingToProxy {
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() -> ConnectionStateConnectingToProxyBuilder {
166        let mut inner = ConnectionStateConnectingToProxy::default();
167        inner.extra = Some(Uuid::new_v4().to_string());
168
169        ConnectionStateConnectingToProxyBuilder { inner }
170    }
171}
172
173#[doc(hidden)]
174pub struct ConnectionStateConnectingToProxyBuilder {
175    inner: ConnectionStateConnectingToProxy,
176}
177
178#[deprecated]
179pub type RTDConnectionStateConnectingToProxyBuilder = ConnectionStateConnectingToProxyBuilder;
180
181impl ConnectionStateConnectingToProxyBuilder {
182    pub fn build(&self) -> ConnectionStateConnectingToProxy {
183        self.inner.clone()
184    }
185}
186
187impl AsRef<ConnectionStateConnectingToProxy> for ConnectionStateConnectingToProxy {
188    fn as_ref(&self) -> &ConnectionStateConnectingToProxy {
189        self
190    }
191}
192
193impl AsRef<ConnectionStateConnectingToProxy> for ConnectionStateConnectingToProxyBuilder {
194    fn as_ref(&self) -> &ConnectionStateConnectingToProxy {
195        &self.inner
196    }
197}
198
199/// There is a working connection to the Telegram servers
200#[derive(Debug, Clone, Default, Serialize, Deserialize)]
201pub struct ConnectionStateReady {
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 ConnectionStateReady {
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 TDConnectionState for ConnectionStateReady {}
221
222impl ConnectionStateReady {
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() -> ConnectionStateReadyBuilder {
227        let mut inner = ConnectionStateReady::default();
228        inner.extra = Some(Uuid::new_v4().to_string());
229
230        ConnectionStateReadyBuilder { inner }
231    }
232}
233
234#[doc(hidden)]
235pub struct ConnectionStateReadyBuilder {
236    inner: ConnectionStateReady,
237}
238
239#[deprecated]
240pub type RTDConnectionStateReadyBuilder = ConnectionStateReadyBuilder;
241
242impl ConnectionStateReadyBuilder {
243    pub fn build(&self) -> ConnectionStateReady {
244        self.inner.clone()
245    }
246}
247
248impl AsRef<ConnectionStateReady> for ConnectionStateReady {
249    fn as_ref(&self) -> &ConnectionStateReady {
250        self
251    }
252}
253
254impl AsRef<ConnectionStateReady> for ConnectionStateReadyBuilder {
255    fn as_ref(&self) -> &ConnectionStateReady {
256        &self.inner
257    }
258}
259
260/// Downloading data received while the application was offline
261#[derive(Debug, Clone, Default, Serialize, Deserialize)]
262pub struct ConnectionStateUpdating {
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 ConnectionStateUpdating {
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 TDConnectionState for ConnectionStateUpdating {}
282
283impl ConnectionStateUpdating {
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() -> ConnectionStateUpdatingBuilder {
288        let mut inner = ConnectionStateUpdating::default();
289        inner.extra = Some(Uuid::new_v4().to_string());
290
291        ConnectionStateUpdatingBuilder { inner }
292    }
293}
294
295#[doc(hidden)]
296pub struct ConnectionStateUpdatingBuilder {
297    inner: ConnectionStateUpdating,
298}
299
300#[deprecated]
301pub type RTDConnectionStateUpdatingBuilder = ConnectionStateUpdatingBuilder;
302
303impl ConnectionStateUpdatingBuilder {
304    pub fn build(&self) -> ConnectionStateUpdating {
305        self.inner.clone()
306    }
307}
308
309impl AsRef<ConnectionStateUpdating> for ConnectionStateUpdating {
310    fn as_ref(&self) -> &ConnectionStateUpdating {
311        self
312    }
313}
314
315impl AsRef<ConnectionStateUpdating> for ConnectionStateUpdatingBuilder {
316    fn as_ref(&self) -> &ConnectionStateUpdating {
317        &self.inner
318    }
319}
320
321/// Currently waiting for the network to become available. Use setNetworkType to change the available network type
322#[derive(Debug, Clone, Default, Serialize, Deserialize)]
323pub struct ConnectionStateWaitingForNetwork {
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 ConnectionStateWaitingForNetwork {
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 TDConnectionState for ConnectionStateWaitingForNetwork {}
343
344impl ConnectionStateWaitingForNetwork {
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() -> ConnectionStateWaitingForNetworkBuilder {
349        let mut inner = ConnectionStateWaitingForNetwork::default();
350        inner.extra = Some(Uuid::new_v4().to_string());
351
352        ConnectionStateWaitingForNetworkBuilder { inner }
353    }
354}
355
356#[doc(hidden)]
357pub struct ConnectionStateWaitingForNetworkBuilder {
358    inner: ConnectionStateWaitingForNetwork,
359}
360
361#[deprecated]
362pub type RTDConnectionStateWaitingForNetworkBuilder = ConnectionStateWaitingForNetworkBuilder;
363
364impl ConnectionStateWaitingForNetworkBuilder {
365    pub fn build(&self) -> ConnectionStateWaitingForNetwork {
366        self.inner.clone()
367    }
368}
369
370impl AsRef<ConnectionStateWaitingForNetwork> for ConnectionStateWaitingForNetwork {
371    fn as_ref(&self) -> &ConnectionStateWaitingForNetwork {
372        self
373    }
374}
375
376impl AsRef<ConnectionStateWaitingForNetwork> for ConnectionStateWaitingForNetworkBuilder {
377    fn as_ref(&self) -> &ConnectionStateWaitingForNetwork {
378        &self.inner
379    }
380}
rust_tdlib/types/connection_state.rs

rust_tdlib/types/
connection_state.rs
