rust_tdlib/types/
dice_stickers.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Contains animated stickers which must be used for dice animation rendering
8pub trait TDDiceStickers: Debug + RObject {}
9
10/// Contains animated stickers which must be used for dice animation rendering
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum DiceStickers {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// A regular animated sticker
18    #[serde(rename = "diceStickersRegular")]
19    Regular(Box<DiceStickersRegular>),
20    /// Animated stickers to be combined into a slot machine
21    #[serde(rename = "diceStickersSlotMachine")]
22    SlotMachine(Box<DiceStickersSlotMachine>),
23}
24
25impl RObject for DiceStickers {
26    #[doc(hidden)]
27    fn extra(&self) -> Option<&str> {
28        match self {
29            DiceStickers::Regular(t) => t.extra(),
30            DiceStickers::SlotMachine(t) => t.extra(),
31
32            _ => None,
33        }
34    }
35    #[doc(hidden)]
36    fn client_id(&self) -> Option<i32> {
37        match self {
38            DiceStickers::Regular(t) => t.client_id(),
39            DiceStickers::SlotMachine(t) => t.client_id(),
40
41            _ => None,
42        }
43    }
44}
45
46impl DiceStickers {
47    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
48        Ok(serde_json::from_str(json.as_ref())?)
49    }
50    #[doc(hidden)]
51    pub fn _is_default(&self) -> bool {
52        matches!(self, DiceStickers::_Default)
53    }
54}
55
56impl AsRef<DiceStickers> for DiceStickers {
57    fn as_ref(&self) -> &DiceStickers {
58        self
59    }
60}
61
62/// A regular animated sticker
63#[derive(Debug, Clone, Default, Serialize, Deserialize)]
64pub struct DiceStickersRegular {
65    #[doc(hidden)]
66    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
67    extra: Option<String>,
68    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
69    client_id: Option<i32>,
70    /// The animated sticker with the dice animation
71    sticker: Sticker,
72}
73
74impl RObject for DiceStickersRegular {
75    #[doc(hidden)]
76    fn extra(&self) -> Option<&str> {
77        self.extra.as_deref()
78    }
79    #[doc(hidden)]
80    fn client_id(&self) -> Option<i32> {
81        self.client_id
82    }
83}
84
85impl TDDiceStickers for DiceStickersRegular {}
86
87impl DiceStickersRegular {
88    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
89        Ok(serde_json::from_str(json.as_ref())?)
90    }
91    pub fn builder() -> DiceStickersRegularBuilder {
92        let mut inner = DiceStickersRegular::default();
93        inner.extra = Some(Uuid::new_v4().to_string());
94
95        DiceStickersRegularBuilder { inner }
96    }
97
98    pub fn sticker(&self) -> &Sticker {
99        &self.sticker
100    }
101}
102
103#[doc(hidden)]
104pub struct DiceStickersRegularBuilder {
105    inner: DiceStickersRegular,
106}
107
108#[deprecated]
109pub type RTDDiceStickersRegularBuilder = DiceStickersRegularBuilder;
110
111impl DiceStickersRegularBuilder {
112    pub fn build(&self) -> DiceStickersRegular {
113        self.inner.clone()
114    }
115
116    pub fn sticker<T: AsRef<Sticker>>(&mut self, sticker: T) -> &mut Self {
117        self.inner.sticker = sticker.as_ref().clone();
118        self
119    }
120}
121
122impl AsRef<DiceStickersRegular> for DiceStickersRegular {
123    fn as_ref(&self) -> &DiceStickersRegular {
124        self
125    }
126}
127
128impl AsRef<DiceStickersRegular> for DiceStickersRegularBuilder {
129    fn as_ref(&self) -> &DiceStickersRegular {
130        &self.inner
131    }
132}
133
134/// Animated stickers to be combined into a slot machine
135#[derive(Debug, Clone, Default, Serialize, Deserialize)]
136pub struct DiceStickersSlotMachine {
137    #[doc(hidden)]
138    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
139    extra: Option<String>,
140    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
141    client_id: Option<i32>,
142    /// The animated sticker with the slot machine background. The background animation must start playing after all reel animations finish
143    background: Sticker,
144    /// The animated sticker with the lever animation. The lever animation must play once in the initial dice state
145    lever: Sticker,
146    /// The animated sticker with the left reel
147    left_reel: Sticker,
148    /// The animated sticker with the center reel
149    center_reel: Sticker,
150    /// The animated sticker with the right reel
151    right_reel: Sticker,
152}
153
154impl RObject for DiceStickersSlotMachine {
155    #[doc(hidden)]
156    fn extra(&self) -> Option<&str> {
157        self.extra.as_deref()
158    }
159    #[doc(hidden)]
160    fn client_id(&self) -> Option<i32> {
161        self.client_id
162    }
163}
164
165impl TDDiceStickers for DiceStickersSlotMachine {}
166
167impl DiceStickersSlotMachine {
168    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
169        Ok(serde_json::from_str(json.as_ref())?)
170    }
171    pub fn builder() -> DiceStickersSlotMachineBuilder {
172        let mut inner = DiceStickersSlotMachine::default();
173        inner.extra = Some(Uuid::new_v4().to_string());
174
175        DiceStickersSlotMachineBuilder { inner }
176    }
177
178    pub fn background(&self) -> &Sticker {
179        &self.background
180    }
181
182    pub fn lever(&self) -> &Sticker {
183        &self.lever
184    }
185
186    pub fn left_reel(&self) -> &Sticker {
187        &self.left_reel
188    }
189
190    pub fn center_reel(&self) -> &Sticker {
191        &self.center_reel
192    }
193
194    pub fn right_reel(&self) -> &Sticker {
195        &self.right_reel
196    }
197}
198
199#[doc(hidden)]
200pub struct DiceStickersSlotMachineBuilder {
201    inner: DiceStickersSlotMachine,
202}
203
204#[deprecated]
205pub type RTDDiceStickersSlotMachineBuilder = DiceStickersSlotMachineBuilder;
206
207impl DiceStickersSlotMachineBuilder {
208    pub fn build(&self) -> DiceStickersSlotMachine {
209        self.inner.clone()
210    }
211
212    pub fn background<T: AsRef<Sticker>>(&mut self, background: T) -> &mut Self {
213        self.inner.background = background.as_ref().clone();
214        self
215    }
216
217    pub fn lever<T: AsRef<Sticker>>(&mut self, lever: T) -> &mut Self {
218        self.inner.lever = lever.as_ref().clone();
219        self
220    }
221
222    pub fn left_reel<T: AsRef<Sticker>>(&mut self, left_reel: T) -> &mut Self {
223        self.inner.left_reel = left_reel.as_ref().clone();
224        self
225    }
226
227    pub fn center_reel<T: AsRef<Sticker>>(&mut self, center_reel: T) -> &mut Self {
228        self.inner.center_reel = center_reel.as_ref().clone();
229        self
230    }
231
232    pub fn right_reel<T: AsRef<Sticker>>(&mut self, right_reel: T) -> &mut Self {
233        self.inner.right_reel = right_reel.as_ref().clone();
234        self
235    }
236}
237
238impl AsRef<DiceStickersSlotMachine> for DiceStickersSlotMachine {
239    fn as_ref(&self) -> &DiceStickersSlotMachine {
240        self
241    }
242}
243
244impl AsRef<DiceStickersSlotMachine> for DiceStickersSlotMachineBuilder {
245    fn as_ref(&self) -> &DiceStickersSlotMachine {
246        &self.inner
247    }
248}
rust_tdlib/types/dice_stickers.rs

rust_tdlib/types/
dice_stickers.rs
