rust_tdlib/types/
rich_text.rs

1use crate::errors::Result;
2use crate::types::*;
3use uuid::Uuid;
4
5use std::fmt::Debug;
6
7/// Describes a text object inside an instant-view web page
8pub trait TDRichText: Debug + RObject {}
9
10/// Describes a text object inside an instant-view web page
11#[derive(Debug, Clone, Deserialize, Serialize, Default)]
12#[serde(tag = "@type")]
13pub enum RichText {
14    #[doc(hidden)]
15    #[default]
16    _Default,
17    /// An anchor
18    #[serde(rename = "richTextAnchor")]
19    Anchor(RichTextAnchor),
20    /// A link to an anchor on the same web page
21    #[serde(rename = "richTextAnchorLink")]
22    AnchorLink(RichTextAnchorLink),
23    /// A bold rich text
24    #[serde(rename = "richTextBold")]
25    Bold(RichTextBold),
26    /// A rich text email link
27    #[serde(rename = "richTextEmailAddress")]
28    EmailAddress(RichTextEmailAddress),
29    /// A fixed-width rich text
30    #[serde(rename = "richTextFixed")]
31    Fixed(RichTextFixed),
32    /// A small image inside the text
33    #[serde(rename = "richTextIcon")]
34    Icon(Box<RichTextIcon>),
35    /// An italicized rich text
36    #[serde(rename = "richTextItalic")]
37    Italic(RichTextItalic),
38    /// A marked rich text
39    #[serde(rename = "richTextMarked")]
40    Marked(RichTextMarked),
41    /// A rich text phone number
42    #[serde(rename = "richTextPhoneNumber")]
43    PhoneNumber(RichTextPhoneNumber),
44    /// A plain text
45    #[serde(rename = "richTextPlain")]
46    Plain(RichTextPlain),
47    /// A reference to a richTexts object on the same web page
48    #[serde(rename = "richTextReference")]
49    Reference(RichTextReference),
50    /// A strikethrough rich text
51    #[serde(rename = "richTextStrikethrough")]
52    Strikethrough(RichTextStrikethrough),
53    /// A subscript rich text
54    #[serde(rename = "richTextSubscript")]
55    Subscript(RichTextSubscript),
56    /// A superscript rich text
57    #[serde(rename = "richTextSuperscript")]
58    Superscript(RichTextSuperscript),
59    /// An underlined rich text
60    #[serde(rename = "richTextUnderline")]
61    Underline(RichTextUnderline),
62    /// A rich text URL link
63    #[serde(rename = "richTextUrl")]
64    Url(RichTextUrl),
65    /// A concatenation of rich texts
66    #[serde(rename = "richTexts")]
67    RichTexts(RichTexts),
68}
69
70impl RObject for RichText {
71    #[doc(hidden)]
72    fn extra(&self) -> Option<&str> {
73        match self {
74            RichText::Anchor(t) => t.extra(),
75            RichText::AnchorLink(t) => t.extra(),
76            RichText::Bold(t) => t.extra(),
77            RichText::EmailAddress(t) => t.extra(),
78            RichText::Fixed(t) => t.extra(),
79            RichText::Icon(t) => t.extra(),
80            RichText::Italic(t) => t.extra(),
81            RichText::Marked(t) => t.extra(),
82            RichText::PhoneNumber(t) => t.extra(),
83            RichText::Plain(t) => t.extra(),
84            RichText::Reference(t) => t.extra(),
85            RichText::Strikethrough(t) => t.extra(),
86            RichText::Subscript(t) => t.extra(),
87            RichText::Superscript(t) => t.extra(),
88            RichText::Underline(t) => t.extra(),
89            RichText::Url(t) => t.extra(),
90            RichText::RichTexts(t) => t.extra(),
91
92            _ => None,
93        }
94    }
95    #[doc(hidden)]
96    fn client_id(&self) -> Option<i32> {
97        match self {
98            RichText::Anchor(t) => t.client_id(),
99            RichText::AnchorLink(t) => t.client_id(),
100            RichText::Bold(t) => t.client_id(),
101            RichText::EmailAddress(t) => t.client_id(),
102            RichText::Fixed(t) => t.client_id(),
103            RichText::Icon(t) => t.client_id(),
104            RichText::Italic(t) => t.client_id(),
105            RichText::Marked(t) => t.client_id(),
106            RichText::PhoneNumber(t) => t.client_id(),
107            RichText::Plain(t) => t.client_id(),
108            RichText::Reference(t) => t.client_id(),
109            RichText::Strikethrough(t) => t.client_id(),
110            RichText::Subscript(t) => t.client_id(),
111            RichText::Superscript(t) => t.client_id(),
112            RichText::Underline(t) => t.client_id(),
113            RichText::Url(t) => t.client_id(),
114            RichText::RichTexts(t) => t.client_id(),
115
116            _ => None,
117        }
118    }
119}
120
121impl RichText {
122    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
123        Ok(serde_json::from_str(json.as_ref())?)
124    }
125    #[doc(hidden)]
126    pub fn _is_default(&self) -> bool {
127        matches!(self, RichText::_Default)
128    }
129}
130
131impl AsRef<RichText> for RichText {
132    fn as_ref(&self) -> &RichText {
133        self
134    }
135}
136
137/// An anchor
138#[derive(Debug, Clone, Default, Serialize, Deserialize)]
139pub struct RichTextAnchor {
140    #[doc(hidden)]
141    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
142    extra: Option<String>,
143    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
144    client_id: Option<i32>,
145    /// Anchor name
146
147    #[serde(default)]
148    name: String,
149}
150
151impl RObject for RichTextAnchor {
152    #[doc(hidden)]
153    fn extra(&self) -> Option<&str> {
154        self.extra.as_deref()
155    }
156    #[doc(hidden)]
157    fn client_id(&self) -> Option<i32> {
158        self.client_id
159    }
160}
161
162impl TDRichText for RichTextAnchor {}
163
164impl RichTextAnchor {
165    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
166        Ok(serde_json::from_str(json.as_ref())?)
167    }
168    pub fn builder() -> RichTextAnchorBuilder {
169        let mut inner = RichTextAnchor::default();
170        inner.extra = Some(Uuid::new_v4().to_string());
171
172        RichTextAnchorBuilder { inner }
173    }
174
175    pub fn name(&self) -> &String {
176        &self.name
177    }
178}
179
180#[doc(hidden)]
181pub struct RichTextAnchorBuilder {
182    inner: RichTextAnchor,
183}
184
185#[deprecated]
186pub type RTDRichTextAnchorBuilder = RichTextAnchorBuilder;
187
188impl RichTextAnchorBuilder {
189    pub fn build(&self) -> RichTextAnchor {
190        self.inner.clone()
191    }
192
193    pub fn name<T: AsRef<str>>(&mut self, name: T) -> &mut Self {
194        self.inner.name = name.as_ref().to_string();
195        self
196    }
197}
198
199impl AsRef<RichTextAnchor> for RichTextAnchor {
200    fn as_ref(&self) -> &RichTextAnchor {
201        self
202    }
203}
204
205impl AsRef<RichTextAnchor> for RichTextAnchorBuilder {
206    fn as_ref(&self) -> &RichTextAnchor {
207        &self.inner
208    }
209}
210
211/// A link to an anchor on the same web page
212#[derive(Debug, Clone, Default, Serialize, Deserialize)]
213pub struct RichTextAnchorLink {
214    #[doc(hidden)]
215    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
216    extra: Option<String>,
217    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
218    client_id: Option<i32>,
219    /// The link text
220
221    #[serde(skip_serializing_if = "RichText::_is_default")]
222    text: Box<RichText>,
223    /// The anchor name. If the name is empty, the link must bring back to top
224
225    #[serde(default)]
226    anchor_name: String,
227    /// An HTTP URL, opening the anchor
228
229    #[serde(default)]
230    url: String,
231}
232
233impl RObject for RichTextAnchorLink {
234    #[doc(hidden)]
235    fn extra(&self) -> Option<&str> {
236        self.extra.as_deref()
237    }
238    #[doc(hidden)]
239    fn client_id(&self) -> Option<i32> {
240        self.client_id
241    }
242}
243
244impl TDRichText for RichTextAnchorLink {}
245
246impl RichTextAnchorLink {
247    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
248        Ok(serde_json::from_str(json.as_ref())?)
249    }
250    pub fn builder() -> RichTextAnchorLinkBuilder {
251        let mut inner = RichTextAnchorLink::default();
252        inner.extra = Some(Uuid::new_v4().to_string());
253
254        RichTextAnchorLinkBuilder { inner }
255    }
256
257    pub fn text(&self) -> &Box<RichText> {
258        &self.text
259    }
260
261    pub fn anchor_name(&self) -> &String {
262        &self.anchor_name
263    }
264
265    pub fn url(&self) -> &String {
266        &self.url
267    }
268}
269
270#[doc(hidden)]
271pub struct RichTextAnchorLinkBuilder {
272    inner: RichTextAnchorLink,
273}
274
275#[deprecated]
276pub type RTDRichTextAnchorLinkBuilder = RichTextAnchorLinkBuilder;
277
278impl RichTextAnchorLinkBuilder {
279    pub fn build(&self) -> RichTextAnchorLink {
280        self.inner.clone()
281    }
282
283    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
284        self.inner.text = text.as_ref().clone();
285        self
286    }
287
288    pub fn anchor_name<T: AsRef<str>>(&mut self, anchor_name: T) -> &mut Self {
289        self.inner.anchor_name = anchor_name.as_ref().to_string();
290        self
291    }
292
293    pub fn url<T: AsRef<str>>(&mut self, url: T) -> &mut Self {
294        self.inner.url = url.as_ref().to_string();
295        self
296    }
297}
298
299impl AsRef<RichTextAnchorLink> for RichTextAnchorLink {
300    fn as_ref(&self) -> &RichTextAnchorLink {
301        self
302    }
303}
304
305impl AsRef<RichTextAnchorLink> for RichTextAnchorLinkBuilder {
306    fn as_ref(&self) -> &RichTextAnchorLink {
307        &self.inner
308    }
309}
310
311/// A bold rich text
312#[derive(Debug, Clone, Default, Serialize, Deserialize)]
313pub struct RichTextBold {
314    #[doc(hidden)]
315    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
316    extra: Option<String>,
317    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
318    client_id: Option<i32>,
319    /// Text
320
321    #[serde(skip_serializing_if = "RichText::_is_default")]
322    text: Box<RichText>,
323}
324
325impl RObject for RichTextBold {
326    #[doc(hidden)]
327    fn extra(&self) -> Option<&str> {
328        self.extra.as_deref()
329    }
330    #[doc(hidden)]
331    fn client_id(&self) -> Option<i32> {
332        self.client_id
333    }
334}
335
336impl TDRichText for RichTextBold {}
337
338impl RichTextBold {
339    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
340        Ok(serde_json::from_str(json.as_ref())?)
341    }
342    pub fn builder() -> RichTextBoldBuilder {
343        let mut inner = RichTextBold::default();
344        inner.extra = Some(Uuid::new_v4().to_string());
345
346        RichTextBoldBuilder { inner }
347    }
348
349    pub fn text(&self) -> &Box<RichText> {
350        &self.text
351    }
352}
353
354#[doc(hidden)]
355pub struct RichTextBoldBuilder {
356    inner: RichTextBold,
357}
358
359#[deprecated]
360pub type RTDRichTextBoldBuilder = RichTextBoldBuilder;
361
362impl RichTextBoldBuilder {
363    pub fn build(&self) -> RichTextBold {
364        self.inner.clone()
365    }
366
367    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
368        self.inner.text = text.as_ref().clone();
369        self
370    }
371}
372
373impl AsRef<RichTextBold> for RichTextBold {
374    fn as_ref(&self) -> &RichTextBold {
375        self
376    }
377}
378
379impl AsRef<RichTextBold> for RichTextBoldBuilder {
380    fn as_ref(&self) -> &RichTextBold {
381        &self.inner
382    }
383}
384
385/// A rich text email link
386#[derive(Debug, Clone, Default, Serialize, Deserialize)]
387pub struct RichTextEmailAddress {
388    #[doc(hidden)]
389    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
390    extra: Option<String>,
391    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
392    client_id: Option<i32>,
393    /// Text
394
395    #[serde(skip_serializing_if = "RichText::_is_default")]
396    text: Box<RichText>,
397    /// Email address
398
399    #[serde(default)]
400    email_address: String,
401}
402
403impl RObject for RichTextEmailAddress {
404    #[doc(hidden)]
405    fn extra(&self) -> Option<&str> {
406        self.extra.as_deref()
407    }
408    #[doc(hidden)]
409    fn client_id(&self) -> Option<i32> {
410        self.client_id
411    }
412}
413
414impl TDRichText for RichTextEmailAddress {}
415
416impl RichTextEmailAddress {
417    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
418        Ok(serde_json::from_str(json.as_ref())?)
419    }
420    pub fn builder() -> RichTextEmailAddressBuilder {
421        let mut inner = RichTextEmailAddress::default();
422        inner.extra = Some(Uuid::new_v4().to_string());
423
424        RichTextEmailAddressBuilder { inner }
425    }
426
427    pub fn text(&self) -> &Box<RichText> {
428        &self.text
429    }
430
431    pub fn email_address(&self) -> &String {
432        &self.email_address
433    }
434}
435
436#[doc(hidden)]
437pub struct RichTextEmailAddressBuilder {
438    inner: RichTextEmailAddress,
439}
440
441#[deprecated]
442pub type RTDRichTextEmailAddressBuilder = RichTextEmailAddressBuilder;
443
444impl RichTextEmailAddressBuilder {
445    pub fn build(&self) -> RichTextEmailAddress {
446        self.inner.clone()
447    }
448
449    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
450        self.inner.text = text.as_ref().clone();
451        self
452    }
453
454    pub fn email_address<T: AsRef<str>>(&mut self, email_address: T) -> &mut Self {
455        self.inner.email_address = email_address.as_ref().to_string();
456        self
457    }
458}
459
460impl AsRef<RichTextEmailAddress> for RichTextEmailAddress {
461    fn as_ref(&self) -> &RichTextEmailAddress {
462        self
463    }
464}
465
466impl AsRef<RichTextEmailAddress> for RichTextEmailAddressBuilder {
467    fn as_ref(&self) -> &RichTextEmailAddress {
468        &self.inner
469    }
470}
471
472/// A fixed-width rich text
473#[derive(Debug, Clone, Default, Serialize, Deserialize)]
474pub struct RichTextFixed {
475    #[doc(hidden)]
476    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
477    extra: Option<String>,
478    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
479    client_id: Option<i32>,
480    /// Text
481
482    #[serde(skip_serializing_if = "RichText::_is_default")]
483    text: Box<RichText>,
484}
485
486impl RObject for RichTextFixed {
487    #[doc(hidden)]
488    fn extra(&self) -> Option<&str> {
489        self.extra.as_deref()
490    }
491    #[doc(hidden)]
492    fn client_id(&self) -> Option<i32> {
493        self.client_id
494    }
495}
496
497impl TDRichText for RichTextFixed {}
498
499impl RichTextFixed {
500    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
501        Ok(serde_json::from_str(json.as_ref())?)
502    }
503    pub fn builder() -> RichTextFixedBuilder {
504        let mut inner = RichTextFixed::default();
505        inner.extra = Some(Uuid::new_v4().to_string());
506
507        RichTextFixedBuilder { inner }
508    }
509
510    pub fn text(&self) -> &Box<RichText> {
511        &self.text
512    }
513}
514
515#[doc(hidden)]
516pub struct RichTextFixedBuilder {
517    inner: RichTextFixed,
518}
519
520#[deprecated]
521pub type RTDRichTextFixedBuilder = RichTextFixedBuilder;
522
523impl RichTextFixedBuilder {
524    pub fn build(&self) -> RichTextFixed {
525        self.inner.clone()
526    }
527
528    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
529        self.inner.text = text.as_ref().clone();
530        self
531    }
532}
533
534impl AsRef<RichTextFixed> for RichTextFixed {
535    fn as_ref(&self) -> &RichTextFixed {
536        self
537    }
538}
539
540impl AsRef<RichTextFixed> for RichTextFixedBuilder {
541    fn as_ref(&self) -> &RichTextFixed {
542        &self.inner
543    }
544}
545
546/// A small image inside the text
547#[derive(Debug, Clone, Default, Serialize, Deserialize)]
548pub struct RichTextIcon {
549    #[doc(hidden)]
550    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
551    extra: Option<String>,
552    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
553    client_id: Option<i32>,
554    /// The image represented as a document. The image can be in GIF, JPEG or PNG format
555    document: Document,
556    /// Width of a bounding box in which the image must be shown; 0 if unknown
557
558    #[serde(default)]
559    width: i32,
560    /// Height of a bounding box in which the image must be shown; 0 if unknown
561
562    #[serde(default)]
563    height: i32,
564}
565
566impl RObject for RichTextIcon {
567    #[doc(hidden)]
568    fn extra(&self) -> Option<&str> {
569        self.extra.as_deref()
570    }
571    #[doc(hidden)]
572    fn client_id(&self) -> Option<i32> {
573        self.client_id
574    }
575}
576
577impl TDRichText for RichTextIcon {}
578
579impl RichTextIcon {
580    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
581        Ok(serde_json::from_str(json.as_ref())?)
582    }
583    pub fn builder() -> RichTextIconBuilder {
584        let mut inner = RichTextIcon::default();
585        inner.extra = Some(Uuid::new_v4().to_string());
586
587        RichTextIconBuilder { inner }
588    }
589
590    pub fn document(&self) -> &Document {
591        &self.document
592    }
593
594    pub fn width(&self) -> i32 {
595        self.width
596    }
597
598    pub fn height(&self) -> i32 {
599        self.height
600    }
601}
602
603#[doc(hidden)]
604pub struct RichTextIconBuilder {
605    inner: RichTextIcon,
606}
607
608#[deprecated]
609pub type RTDRichTextIconBuilder = RichTextIconBuilder;
610
611impl RichTextIconBuilder {
612    pub fn build(&self) -> RichTextIcon {
613        self.inner.clone()
614    }
615
616    pub fn document<T: AsRef<Document>>(&mut self, document: T) -> &mut Self {
617        self.inner.document = document.as_ref().clone();
618        self
619    }
620
621    pub fn width(&mut self, width: i32) -> &mut Self {
622        self.inner.width = width;
623        self
624    }
625
626    pub fn height(&mut self, height: i32) -> &mut Self {
627        self.inner.height = height;
628        self
629    }
630}
631
632impl AsRef<RichTextIcon> for RichTextIcon {
633    fn as_ref(&self) -> &RichTextIcon {
634        self
635    }
636}
637
638impl AsRef<RichTextIcon> for RichTextIconBuilder {
639    fn as_ref(&self) -> &RichTextIcon {
640        &self.inner
641    }
642}
643
644/// An italicized rich text
645#[derive(Debug, Clone, Default, Serialize, Deserialize)]
646pub struct RichTextItalic {
647    #[doc(hidden)]
648    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
649    extra: Option<String>,
650    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
651    client_id: Option<i32>,
652    /// Text
653
654    #[serde(skip_serializing_if = "RichText::_is_default")]
655    text: Box<RichText>,
656}
657
658impl RObject for RichTextItalic {
659    #[doc(hidden)]
660    fn extra(&self) -> Option<&str> {
661        self.extra.as_deref()
662    }
663    #[doc(hidden)]
664    fn client_id(&self) -> Option<i32> {
665        self.client_id
666    }
667}
668
669impl TDRichText for RichTextItalic {}
670
671impl RichTextItalic {
672    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
673        Ok(serde_json::from_str(json.as_ref())?)
674    }
675    pub fn builder() -> RichTextItalicBuilder {
676        let mut inner = RichTextItalic::default();
677        inner.extra = Some(Uuid::new_v4().to_string());
678
679        RichTextItalicBuilder { inner }
680    }
681
682    pub fn text(&self) -> &Box<RichText> {
683        &self.text
684    }
685}
686
687#[doc(hidden)]
688pub struct RichTextItalicBuilder {
689    inner: RichTextItalic,
690}
691
692#[deprecated]
693pub type RTDRichTextItalicBuilder = RichTextItalicBuilder;
694
695impl RichTextItalicBuilder {
696    pub fn build(&self) -> RichTextItalic {
697        self.inner.clone()
698    }
699
700    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
701        self.inner.text = text.as_ref().clone();
702        self
703    }
704}
705
706impl AsRef<RichTextItalic> for RichTextItalic {
707    fn as_ref(&self) -> &RichTextItalic {
708        self
709    }
710}
711
712impl AsRef<RichTextItalic> for RichTextItalicBuilder {
713    fn as_ref(&self) -> &RichTextItalic {
714        &self.inner
715    }
716}
717
718/// A marked rich text
719#[derive(Debug, Clone, Default, Serialize, Deserialize)]
720pub struct RichTextMarked {
721    #[doc(hidden)]
722    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
723    extra: Option<String>,
724    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
725    client_id: Option<i32>,
726    /// Text
727
728    #[serde(skip_serializing_if = "RichText::_is_default")]
729    text: Box<RichText>,
730}
731
732impl RObject for RichTextMarked {
733    #[doc(hidden)]
734    fn extra(&self) -> Option<&str> {
735        self.extra.as_deref()
736    }
737    #[doc(hidden)]
738    fn client_id(&self) -> Option<i32> {
739        self.client_id
740    }
741}
742
743impl TDRichText for RichTextMarked {}
744
745impl RichTextMarked {
746    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
747        Ok(serde_json::from_str(json.as_ref())?)
748    }
749    pub fn builder() -> RichTextMarkedBuilder {
750        let mut inner = RichTextMarked::default();
751        inner.extra = Some(Uuid::new_v4().to_string());
752
753        RichTextMarkedBuilder { inner }
754    }
755
756    pub fn text(&self) -> &Box<RichText> {
757        &self.text
758    }
759}
760
761#[doc(hidden)]
762pub struct RichTextMarkedBuilder {
763    inner: RichTextMarked,
764}
765
766#[deprecated]
767pub type RTDRichTextMarkedBuilder = RichTextMarkedBuilder;
768
769impl RichTextMarkedBuilder {
770    pub fn build(&self) -> RichTextMarked {
771        self.inner.clone()
772    }
773
774    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
775        self.inner.text = text.as_ref().clone();
776        self
777    }
778}
779
780impl AsRef<RichTextMarked> for RichTextMarked {
781    fn as_ref(&self) -> &RichTextMarked {
782        self
783    }
784}
785
786impl AsRef<RichTextMarked> for RichTextMarkedBuilder {
787    fn as_ref(&self) -> &RichTextMarked {
788        &self.inner
789    }
790}
791
792/// A rich text phone number
793#[derive(Debug, Clone, Default, Serialize, Deserialize)]
794pub struct RichTextPhoneNumber {
795    #[doc(hidden)]
796    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
797    extra: Option<String>,
798    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
799    client_id: Option<i32>,
800    /// Text
801
802    #[serde(skip_serializing_if = "RichText::_is_default")]
803    text: Box<RichText>,
804    /// Phone number
805
806    #[serde(default)]
807    phone_number: String,
808}
809
810impl RObject for RichTextPhoneNumber {
811    #[doc(hidden)]
812    fn extra(&self) -> Option<&str> {
813        self.extra.as_deref()
814    }
815    #[doc(hidden)]
816    fn client_id(&self) -> Option<i32> {
817        self.client_id
818    }
819}
820
821impl TDRichText for RichTextPhoneNumber {}
822
823impl RichTextPhoneNumber {
824    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
825        Ok(serde_json::from_str(json.as_ref())?)
826    }
827    pub fn builder() -> RichTextPhoneNumberBuilder {
828        let mut inner = RichTextPhoneNumber::default();
829        inner.extra = Some(Uuid::new_v4().to_string());
830
831        RichTextPhoneNumberBuilder { inner }
832    }
833
834    pub fn text(&self) -> &Box<RichText> {
835        &self.text
836    }
837
838    pub fn phone_number(&self) -> &String {
839        &self.phone_number
840    }
841}
842
843#[doc(hidden)]
844pub struct RichTextPhoneNumberBuilder {
845    inner: RichTextPhoneNumber,
846}
847
848#[deprecated]
849pub type RTDRichTextPhoneNumberBuilder = RichTextPhoneNumberBuilder;
850
851impl RichTextPhoneNumberBuilder {
852    pub fn build(&self) -> RichTextPhoneNumber {
853        self.inner.clone()
854    }
855
856    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
857        self.inner.text = text.as_ref().clone();
858        self
859    }
860
861    pub fn phone_number<T: AsRef<str>>(&mut self, phone_number: T) -> &mut Self {
862        self.inner.phone_number = phone_number.as_ref().to_string();
863        self
864    }
865}
866
867impl AsRef<RichTextPhoneNumber> for RichTextPhoneNumber {
868    fn as_ref(&self) -> &RichTextPhoneNumber {
869        self
870    }
871}
872
873impl AsRef<RichTextPhoneNumber> for RichTextPhoneNumberBuilder {
874    fn as_ref(&self) -> &RichTextPhoneNumber {
875        &self.inner
876    }
877}
878
879/// A plain text
880#[derive(Debug, Clone, Default, Serialize, Deserialize)]
881pub struct RichTextPlain {
882    #[doc(hidden)]
883    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
884    extra: Option<String>,
885    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
886    client_id: Option<i32>,
887    /// Text
888
889    #[serde(default)]
890    text: Box<RichText>,
891}
892
893impl RObject for RichTextPlain {
894    #[doc(hidden)]
895    fn extra(&self) -> Option<&str> {
896        self.extra.as_deref()
897    }
898    #[doc(hidden)]
899    fn client_id(&self) -> Option<i32> {
900        self.client_id
901    }
902}
903
904impl TDRichText for RichTextPlain {}
905
906impl RichTextPlain {
907    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
908        Ok(serde_json::from_str(json.as_ref())?)
909    }
910    pub fn builder() -> RichTextPlainBuilder {
911        let mut inner = RichTextPlain::default();
912        inner.extra = Some(Uuid::new_v4().to_string());
913
914        RichTextPlainBuilder { inner }
915    }
916
917    pub fn text(&self) -> &Box<RichText> {
918        &self.text
919    }
920}
921
922#[doc(hidden)]
923pub struct RichTextPlainBuilder {
924    inner: RichTextPlain,
925}
926
927#[deprecated]
928pub type RTDRichTextPlainBuilder = RichTextPlainBuilder;
929
930impl RichTextPlainBuilder {
931    pub fn build(&self) -> RichTextPlain {
932        self.inner.clone()
933    }
934
935    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
936        self.inner.text = text.as_ref().clone();
937        self
938    }
939}
940
941impl AsRef<RichTextPlain> for RichTextPlain {
942    fn as_ref(&self) -> &RichTextPlain {
943        self
944    }
945}
946
947impl AsRef<RichTextPlain> for RichTextPlainBuilder {
948    fn as_ref(&self) -> &RichTextPlain {
949        &self.inner
950    }
951}
952
953/// A reference to a richTexts object on the same web page
954#[derive(Debug, Clone, Default, Serialize, Deserialize)]
955pub struct RichTextReference {
956    #[doc(hidden)]
957    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
958    extra: Option<String>,
959    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
960    client_id: Option<i32>,
961    /// The text
962
963    #[serde(skip_serializing_if = "RichText::_is_default")]
964    text: Box<RichText>,
965    /// The name of a richTextAnchor object, which is the first element of the target richTexts object
966
967    #[serde(default)]
968    anchor_name: String,
969    /// An HTTP URL, opening the reference
970
971    #[serde(default)]
972    url: String,
973}
974
975impl RObject for RichTextReference {
976    #[doc(hidden)]
977    fn extra(&self) -> Option<&str> {
978        self.extra.as_deref()
979    }
980    #[doc(hidden)]
981    fn client_id(&self) -> Option<i32> {
982        self.client_id
983    }
984}
985
986impl TDRichText for RichTextReference {}
987
988impl RichTextReference {
989    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
990        Ok(serde_json::from_str(json.as_ref())?)
991    }
992    pub fn builder() -> RichTextReferenceBuilder {
993        let mut inner = RichTextReference::default();
994        inner.extra = Some(Uuid::new_v4().to_string());
995
996        RichTextReferenceBuilder { inner }
997    }
998
999    pub fn text(&self) -> &Box<RichText> {
1000        &self.text
1001    }
1002
1003    pub fn anchor_name(&self) -> &String {
1004        &self.anchor_name
1005    }
1006
1007    pub fn url(&self) -> &String {
1008        &self.url
1009    }
1010}
1011
1012#[doc(hidden)]
1013pub struct RichTextReferenceBuilder {
1014    inner: RichTextReference,
1015}
1016
1017#[deprecated]
1018pub type RTDRichTextReferenceBuilder = RichTextReferenceBuilder;
1019
1020impl RichTextReferenceBuilder {
1021    pub fn build(&self) -> RichTextReference {
1022        self.inner.clone()
1023    }
1024
1025    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
1026        self.inner.text = text.as_ref().clone();
1027        self
1028    }
1029
1030    pub fn anchor_name<T: AsRef<str>>(&mut self, anchor_name: T) -> &mut Self {
1031        self.inner.anchor_name = anchor_name.as_ref().to_string();
1032        self
1033    }
1034
1035    pub fn url<T: AsRef<str>>(&mut self, url: T) -> &mut Self {
1036        self.inner.url = url.as_ref().to_string();
1037        self
1038    }
1039}
1040
1041impl AsRef<RichTextReference> for RichTextReference {
1042    fn as_ref(&self) -> &RichTextReference {
1043        self
1044    }
1045}
1046
1047impl AsRef<RichTextReference> for RichTextReferenceBuilder {
1048    fn as_ref(&self) -> &RichTextReference {
1049        &self.inner
1050    }
1051}
1052
1053/// A strikethrough rich text
1054#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1055pub struct RichTextStrikethrough {
1056    #[doc(hidden)]
1057    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1058    extra: Option<String>,
1059    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
1060    client_id: Option<i32>,
1061    /// Text
1062
1063    #[serde(skip_serializing_if = "RichText::_is_default")]
1064    text: Box<RichText>,
1065}
1066
1067impl RObject for RichTextStrikethrough {
1068    #[doc(hidden)]
1069    fn extra(&self) -> Option<&str> {
1070        self.extra.as_deref()
1071    }
1072    #[doc(hidden)]
1073    fn client_id(&self) -> Option<i32> {
1074        self.client_id
1075    }
1076}
1077
1078impl TDRichText for RichTextStrikethrough {}
1079
1080impl RichTextStrikethrough {
1081    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1082        Ok(serde_json::from_str(json.as_ref())?)
1083    }
1084    pub fn builder() -> RichTextStrikethroughBuilder {
1085        let mut inner = RichTextStrikethrough::default();
1086        inner.extra = Some(Uuid::new_v4().to_string());
1087
1088        RichTextStrikethroughBuilder { inner }
1089    }
1090
1091    pub fn text(&self) -> &Box<RichText> {
1092        &self.text
1093    }
1094}
1095
1096#[doc(hidden)]
1097pub struct RichTextStrikethroughBuilder {
1098    inner: RichTextStrikethrough,
1099}
1100
1101#[deprecated]
1102pub type RTDRichTextStrikethroughBuilder = RichTextStrikethroughBuilder;
1103
1104impl RichTextStrikethroughBuilder {
1105    pub fn build(&self) -> RichTextStrikethrough {
1106        self.inner.clone()
1107    }
1108
1109    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
1110        self.inner.text = text.as_ref().clone();
1111        self
1112    }
1113}
1114
1115impl AsRef<RichTextStrikethrough> for RichTextStrikethrough {
1116    fn as_ref(&self) -> &RichTextStrikethrough {
1117        self
1118    }
1119}
1120
1121impl AsRef<RichTextStrikethrough> for RichTextStrikethroughBuilder {
1122    fn as_ref(&self) -> &RichTextStrikethrough {
1123        &self.inner
1124    }
1125}
1126
1127/// A subscript rich text
1128#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1129pub struct RichTextSubscript {
1130    #[doc(hidden)]
1131    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1132    extra: Option<String>,
1133    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
1134    client_id: Option<i32>,
1135    /// Text
1136
1137    #[serde(skip_serializing_if = "RichText::_is_default")]
1138    text: Box<RichText>,
1139}
1140
1141impl RObject for RichTextSubscript {
1142    #[doc(hidden)]
1143    fn extra(&self) -> Option<&str> {
1144        self.extra.as_deref()
1145    }
1146    #[doc(hidden)]
1147    fn client_id(&self) -> Option<i32> {
1148        self.client_id
1149    }
1150}
1151
1152impl TDRichText for RichTextSubscript {}
1153
1154impl RichTextSubscript {
1155    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1156        Ok(serde_json::from_str(json.as_ref())?)
1157    }
1158    pub fn builder() -> RichTextSubscriptBuilder {
1159        let mut inner = RichTextSubscript::default();
1160        inner.extra = Some(Uuid::new_v4().to_string());
1161
1162        RichTextSubscriptBuilder { inner }
1163    }
1164
1165    pub fn text(&self) -> &Box<RichText> {
1166        &self.text
1167    }
1168}
1169
1170#[doc(hidden)]
1171pub struct RichTextSubscriptBuilder {
1172    inner: RichTextSubscript,
1173}
1174
1175#[deprecated]
1176pub type RTDRichTextSubscriptBuilder = RichTextSubscriptBuilder;
1177
1178impl RichTextSubscriptBuilder {
1179    pub fn build(&self) -> RichTextSubscript {
1180        self.inner.clone()
1181    }
1182
1183    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
1184        self.inner.text = text.as_ref().clone();
1185        self
1186    }
1187}
1188
1189impl AsRef<RichTextSubscript> for RichTextSubscript {
1190    fn as_ref(&self) -> &RichTextSubscript {
1191        self
1192    }
1193}
1194
1195impl AsRef<RichTextSubscript> for RichTextSubscriptBuilder {
1196    fn as_ref(&self) -> &RichTextSubscript {
1197        &self.inner
1198    }
1199}
1200
1201/// A superscript rich text
1202#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1203pub struct RichTextSuperscript {
1204    #[doc(hidden)]
1205    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1206    extra: Option<String>,
1207    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
1208    client_id: Option<i32>,
1209    /// Text
1210
1211    #[serde(skip_serializing_if = "RichText::_is_default")]
1212    text: Box<RichText>,
1213}
1214
1215impl RObject for RichTextSuperscript {
1216    #[doc(hidden)]
1217    fn extra(&self) -> Option<&str> {
1218        self.extra.as_deref()
1219    }
1220    #[doc(hidden)]
1221    fn client_id(&self) -> Option<i32> {
1222        self.client_id
1223    }
1224}
1225
1226impl TDRichText for RichTextSuperscript {}
1227
1228impl RichTextSuperscript {
1229    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1230        Ok(serde_json::from_str(json.as_ref())?)
1231    }
1232    pub fn builder() -> RichTextSuperscriptBuilder {
1233        let mut inner = RichTextSuperscript::default();
1234        inner.extra = Some(Uuid::new_v4().to_string());
1235
1236        RichTextSuperscriptBuilder { inner }
1237    }
1238
1239    pub fn text(&self) -> &Box<RichText> {
1240        &self.text
1241    }
1242}
1243
1244#[doc(hidden)]
1245pub struct RichTextSuperscriptBuilder {
1246    inner: RichTextSuperscript,
1247}
1248
1249#[deprecated]
1250pub type RTDRichTextSuperscriptBuilder = RichTextSuperscriptBuilder;
1251
1252impl RichTextSuperscriptBuilder {
1253    pub fn build(&self) -> RichTextSuperscript {
1254        self.inner.clone()
1255    }
1256
1257    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
1258        self.inner.text = text.as_ref().clone();
1259        self
1260    }
1261}
1262
1263impl AsRef<RichTextSuperscript> for RichTextSuperscript {
1264    fn as_ref(&self) -> &RichTextSuperscript {
1265        self
1266    }
1267}
1268
1269impl AsRef<RichTextSuperscript> for RichTextSuperscriptBuilder {
1270    fn as_ref(&self) -> &RichTextSuperscript {
1271        &self.inner
1272    }
1273}
1274
1275/// An underlined rich text
1276#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1277pub struct RichTextUnderline {
1278    #[doc(hidden)]
1279    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1280    extra: Option<String>,
1281    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
1282    client_id: Option<i32>,
1283    /// Text
1284
1285    #[serde(skip_serializing_if = "RichText::_is_default")]
1286    text: Box<RichText>,
1287}
1288
1289impl RObject for RichTextUnderline {
1290    #[doc(hidden)]
1291    fn extra(&self) -> Option<&str> {
1292        self.extra.as_deref()
1293    }
1294    #[doc(hidden)]
1295    fn client_id(&self) -> Option<i32> {
1296        self.client_id
1297    }
1298}
1299
1300impl TDRichText for RichTextUnderline {}
1301
1302impl RichTextUnderline {
1303    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1304        Ok(serde_json::from_str(json.as_ref())?)
1305    }
1306    pub fn builder() -> RichTextUnderlineBuilder {
1307        let mut inner = RichTextUnderline::default();
1308        inner.extra = Some(Uuid::new_v4().to_string());
1309
1310        RichTextUnderlineBuilder { inner }
1311    }
1312
1313    pub fn text(&self) -> &Box<RichText> {
1314        &self.text
1315    }
1316}
1317
1318#[doc(hidden)]
1319pub struct RichTextUnderlineBuilder {
1320    inner: RichTextUnderline,
1321}
1322
1323#[deprecated]
1324pub type RTDRichTextUnderlineBuilder = RichTextUnderlineBuilder;
1325
1326impl RichTextUnderlineBuilder {
1327    pub fn build(&self) -> RichTextUnderline {
1328        self.inner.clone()
1329    }
1330
1331    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
1332        self.inner.text = text.as_ref().clone();
1333        self
1334    }
1335}
1336
1337impl AsRef<RichTextUnderline> for RichTextUnderline {
1338    fn as_ref(&self) -> &RichTextUnderline {
1339        self
1340    }
1341}
1342
1343impl AsRef<RichTextUnderline> for RichTextUnderlineBuilder {
1344    fn as_ref(&self) -> &RichTextUnderline {
1345        &self.inner
1346    }
1347}
1348
1349/// A rich text URL link
1350#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1351pub struct RichTextUrl {
1352    #[doc(hidden)]
1353    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1354    extra: Option<String>,
1355    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
1356    client_id: Option<i32>,
1357    /// Text
1358
1359    #[serde(skip_serializing_if = "RichText::_is_default")]
1360    text: Box<RichText>,
1361    /// URL
1362
1363    #[serde(default)]
1364    url: String,
1365    /// True, if the URL has cached instant view server-side
1366
1367    #[serde(default)]
1368    is_cached: bool,
1369}
1370
1371impl RObject for RichTextUrl {
1372    #[doc(hidden)]
1373    fn extra(&self) -> Option<&str> {
1374        self.extra.as_deref()
1375    }
1376    #[doc(hidden)]
1377    fn client_id(&self) -> Option<i32> {
1378        self.client_id
1379    }
1380}
1381
1382impl TDRichText for RichTextUrl {}
1383
1384impl RichTextUrl {
1385    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1386        Ok(serde_json::from_str(json.as_ref())?)
1387    }
1388    pub fn builder() -> RichTextUrlBuilder {
1389        let mut inner = RichTextUrl::default();
1390        inner.extra = Some(Uuid::new_v4().to_string());
1391
1392        RichTextUrlBuilder { inner }
1393    }
1394
1395    pub fn text(&self) -> &Box<RichText> {
1396        &self.text
1397    }
1398
1399    pub fn url(&self) -> &String {
1400        &self.url
1401    }
1402
1403    pub fn is_cached(&self) -> bool {
1404        self.is_cached
1405    }
1406}
1407
1408#[doc(hidden)]
1409pub struct RichTextUrlBuilder {
1410    inner: RichTextUrl,
1411}
1412
1413#[deprecated]
1414pub type RTDRichTextUrlBuilder = RichTextUrlBuilder;
1415
1416impl RichTextUrlBuilder {
1417    pub fn build(&self) -> RichTextUrl {
1418        self.inner.clone()
1419    }
1420
1421    pub fn text<T: AsRef<Box<RichText>>>(&mut self, text: T) -> &mut Self {
1422        self.inner.text = text.as_ref().clone();
1423        self
1424    }
1425
1426    pub fn url<T: AsRef<str>>(&mut self, url: T) -> &mut Self {
1427        self.inner.url = url.as_ref().to_string();
1428        self
1429    }
1430
1431    pub fn is_cached(&mut self, is_cached: bool) -> &mut Self {
1432        self.inner.is_cached = is_cached;
1433        self
1434    }
1435}
1436
1437impl AsRef<RichTextUrl> for RichTextUrl {
1438    fn as_ref(&self) -> &RichTextUrl {
1439        self
1440    }
1441}
1442
1443impl AsRef<RichTextUrl> for RichTextUrlBuilder {
1444    fn as_ref(&self) -> &RichTextUrl {
1445        &self.inner
1446    }
1447}
1448
1449/// A concatenation of rich texts
1450#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1451pub struct RichTexts {
1452    #[doc(hidden)]
1453    #[serde(rename(serialize = "@extra", deserialize = "@extra"))]
1454    extra: Option<String>,
1455    #[serde(rename(serialize = "@client_id", deserialize = "@client_id"))]
1456    client_id: Option<i32>,
1457    /// Texts
1458
1459    #[serde(default)]
1460    texts: Vec<RichText>,
1461}
1462
1463impl RObject for RichTexts {
1464    #[doc(hidden)]
1465    fn extra(&self) -> Option<&str> {
1466        self.extra.as_deref()
1467    }
1468    #[doc(hidden)]
1469    fn client_id(&self) -> Option<i32> {
1470        self.client_id
1471    }
1472}
1473
1474impl TDRichText for RichTexts {}
1475
1476impl RichTexts {
1477    pub fn from_json<S: AsRef<str>>(json: S) -> Result<Self> {
1478        Ok(serde_json::from_str(json.as_ref())?)
1479    }
1480    pub fn builder() -> RichTextsBuilder {
1481        let mut inner = RichTexts::default();
1482        inner.extra = Some(Uuid::new_v4().to_string());
1483
1484        RichTextsBuilder { inner }
1485    }
1486
1487    pub fn texts(&self) -> &Vec<RichText> {
1488        &self.texts
1489    }
1490}
1491
1492#[doc(hidden)]
1493pub struct RichTextsBuilder {
1494    inner: RichTexts,
1495}
1496
1497#[deprecated]
1498pub type RTDRichTextsBuilder = RichTextsBuilder;
1499
1500impl RichTextsBuilder {
1501    pub fn build(&self) -> RichTexts {
1502        self.inner.clone()
1503    }
1504
1505    pub fn texts(&mut self, texts: Vec<RichText>) -> &mut Self {
1506        self.inner.texts = texts;
1507        self
1508    }
1509}
1510
1511impl AsRef<RichTexts> for RichTexts {
1512    fn as_ref(&self) -> &RichTexts {
1513        self
1514    }
1515}
1516
1517impl AsRef<RichTexts> for RichTextsBuilder {
1518    fn as_ref(&self) -> &RichTexts {
1519        &self.inner
1520    }
1521}
rust_tdlib/types/rich_text.rs

rust_tdlib/types/
rich_text.rs
