rtdlib/types/
call_server_type.rs

1
2use crate::types::*;
3use crate::errors::*;
4use uuid::Uuid;
5
6
7
8
9use std::fmt::Debug;
10use serde::de::{Deserialize, Deserializer};
11
12
13
14/// TRAIT | Describes the type of a call server
15pub trait TDCallServerType: Debug + RObject {}
16
17/// Describes the type of a call server
18#[derive(Debug, Clone, Serialize)]
19#[serde(untagged)]
20pub enum CallServerType {
21  #[doc(hidden)] _Default(()),
22  /// A Telegram call reflector
23  TelegramReflector(CallServerTypeTelegramReflector),
24  /// A WebRTC server
25  Webrtc(CallServerTypeWebrtc),
26
27}
28
29impl Default for CallServerType {
30  fn default() -> Self { CallServerType::_Default(()) }
31}
32
33impl<'de> Deserialize<'de> for CallServerType {
34  fn deserialize<D>(deserializer: D) -> Result<CallServerType, D::Error> where D: Deserializer<'de> {
35    use serde::de::Error;
36    rtd_enum_deserialize!(
37      CallServerType,
38      (callServerTypeTelegramReflector, TelegramReflector);
39      (callServerTypeWebrtc, Webrtc);
40
41    )(deserializer)
42  }
43}
44
45impl RObject for CallServerType {
46  #[doc(hidden)] fn td_name(&self) -> &'static str {
47    match self {
48      CallServerType::TelegramReflector(t) => t.td_name(),
49      CallServerType::Webrtc(t) => t.td_name(),
50
51      _ => "-1",
52    }
53  }
54  #[doc(hidden)] fn extra(&self) -> Option<String> {
55    match self {
56      CallServerType::TelegramReflector(t) => t.extra(),
57      CallServerType::Webrtc(t) => t.extra(),
58
59      _ => None,
60    }
61  }
62  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
63}
64
65impl CallServerType {
66  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
67  #[doc(hidden)] pub fn _is_default(&self) -> bool { if let CallServerType::_Default(_) = self { true } else { false } }
68
69  pub fn is_telegram_reflector(&self) -> bool { if let CallServerType::TelegramReflector(_) = self { true } else { false } }
70  pub fn is_webrtc(&self) -> bool { if let CallServerType::Webrtc(_) = self { true } else { false } }
71
72  pub fn on_telegram_reflector<F: FnOnce(&CallServerTypeTelegramReflector)>(&self, fnc: F) -> &Self { if let CallServerType::TelegramReflector(t) = self { fnc(t) }; self }
73  pub fn on_webrtc<F: FnOnce(&CallServerTypeWebrtc)>(&self, fnc: F) -> &Self { if let CallServerType::Webrtc(t) = self { fnc(t) }; self }
74
75  pub fn as_telegram_reflector(&self) -> Option<&CallServerTypeTelegramReflector> { if let CallServerType::TelegramReflector(t) = self { return Some(t) } None }
76  pub fn as_webrtc(&self) -> Option<&CallServerTypeWebrtc> { if let CallServerType::Webrtc(t) = self { return Some(t) } None }
77
78
79
80  pub fn telegram_reflector<T: AsRef<CallServerTypeTelegramReflector>>(t: T) -> Self { CallServerType::TelegramReflector(t.as_ref().clone()) }
81
82  pub fn webrtc<T: AsRef<CallServerTypeWebrtc>>(t: T) -> Self { CallServerType::Webrtc(t.as_ref().clone()) }
83
84}
85
86impl AsRef<CallServerType> for CallServerType {
87  fn as_ref(&self) -> &CallServerType { self }
88}
89
90
91
92
93
94
95
96/// A Telegram call reflector
97#[derive(Debug, Clone, Default, Serialize, Deserialize)]
98pub struct CallServerTypeTelegramReflector {
99  #[doc(hidden)]
100  #[serde(rename(serialize = "@type", deserialize = "@type"))]
101  td_name: String,
102  #[doc(hidden)]
103  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
104  extra: Option<String>,
105  /// A peer tag to be used with the reflector
106  peer_tag: String,
107  
108}
109
110impl RObject for CallServerTypeTelegramReflector {
111  #[doc(hidden)] fn td_name(&self) -> &'static str { "callServerTypeTelegramReflector" }
112  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
113  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
114}
115
116
117impl TDCallServerType for CallServerTypeTelegramReflector {}
118
119
120
121impl CallServerTypeTelegramReflector {
122  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
123  pub fn builder() -> RTDCallServerTypeTelegramReflectorBuilder {
124    let mut inner = CallServerTypeTelegramReflector::default();
125    inner.td_name = "callServerTypeTelegramReflector".to_string();
126    inner.extra = Some(Uuid::new_v4().to_string());
127    RTDCallServerTypeTelegramReflectorBuilder { inner }
128  }
129
130  pub fn peer_tag(&self) -> &String { &self.peer_tag }
131
132}
133
134#[doc(hidden)]
135pub struct RTDCallServerTypeTelegramReflectorBuilder {
136  inner: CallServerTypeTelegramReflector
137}
138
139impl RTDCallServerTypeTelegramReflectorBuilder {
140  pub fn build(&self) -> CallServerTypeTelegramReflector { self.inner.clone() }
141
142   
143  pub fn peer_tag<T: AsRef<str>>(&mut self, peer_tag: T) -> &mut Self {
144    self.inner.peer_tag = peer_tag.as_ref().to_string();
145    self
146  }
147
148}
149
150impl AsRef<CallServerTypeTelegramReflector> for CallServerTypeTelegramReflector {
151  fn as_ref(&self) -> &CallServerTypeTelegramReflector { self }
152}
153
154impl AsRef<CallServerTypeTelegramReflector> for RTDCallServerTypeTelegramReflectorBuilder {
155  fn as_ref(&self) -> &CallServerTypeTelegramReflector { &self.inner }
156}
157
158
159
160
161
162
163
164/// A WebRTC server
165#[derive(Debug, Clone, Default, Serialize, Deserialize)]
166pub struct CallServerTypeWebrtc {
167  #[doc(hidden)]
168  #[serde(rename(serialize = "@type", deserialize = "@type"))]
169  td_name: String,
170  #[doc(hidden)]
171  #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
172  extra: Option<String>,
173  /// Username to be used for authentication
174  username: String,
175  /// Authentication password
176  password: String,
177  /// True, if the server supports TURN
178  supports_turn: bool,
179  /// True, if the server supports STUN
180  supports_stun: bool,
181  
182}
183
184impl RObject for CallServerTypeWebrtc {
185  #[doc(hidden)] fn td_name(&self) -> &'static str { "callServerTypeWebrtc" }
186  #[doc(hidden)] fn extra(&self) -> Option<String> { self.extra.clone() }
187  fn to_json(&self) -> RTDResult<String> { Ok(serde_json::to_string(self)?) }
188}
189
190
191impl TDCallServerType for CallServerTypeWebrtc {}
192
193
194
195impl CallServerTypeWebrtc {
196  pub fn from_json<S: AsRef<str>>(json: S) -> RTDResult<Self> { Ok(serde_json::from_str(json.as_ref())?) }
197  pub fn builder() -> RTDCallServerTypeWebrtcBuilder {
198    let mut inner = CallServerTypeWebrtc::default();
199    inner.td_name = "callServerTypeWebrtc".to_string();
200    inner.extra = Some(Uuid::new_v4().to_string());
201    RTDCallServerTypeWebrtcBuilder { inner }
202  }
203
204  pub fn username(&self) -> &String { &self.username }
205
206  pub fn password(&self) -> &String { &self.password }
207
208  pub fn supports_turn(&self) -> bool { self.supports_turn }
209
210  pub fn supports_stun(&self) -> bool { self.supports_stun }
211
212}
213
214#[doc(hidden)]
215pub struct RTDCallServerTypeWebrtcBuilder {
216  inner: CallServerTypeWebrtc
217}
218
219impl RTDCallServerTypeWebrtcBuilder {
220  pub fn build(&self) -> CallServerTypeWebrtc { self.inner.clone() }
221
222   
223  pub fn username<T: AsRef<str>>(&mut self, username: T) -> &mut Self {
224    self.inner.username = username.as_ref().to_string();
225    self
226  }
227
228   
229  pub fn password<T: AsRef<str>>(&mut self, password: T) -> &mut Self {
230    self.inner.password = password.as_ref().to_string();
231    self
232  }
233
234   
235  pub fn supports_turn(&mut self, supports_turn: bool) -> &mut Self {
236    self.inner.supports_turn = supports_turn;
237    self
238  }
239
240   
241  pub fn supports_stun(&mut self, supports_stun: bool) -> &mut Self {
242    self.inner.supports_stun = supports_stun;
243    self
244  }
245
246}
247
248impl AsRef<CallServerTypeWebrtc> for CallServerTypeWebrtc {
249  fn as_ref(&self) -> &CallServerTypeWebrtc { self }
250}
251
252impl AsRef<CallServerTypeWebrtc> for RTDCallServerTypeWebrtcBuilder {
253  fn as_ref(&self) -> &CallServerTypeWebrtc { &self.inner }
254}
255
256
257
rtdlib/types/call_server_type.rs

rtdlib/types/
call_server_type.rs
