quick_xml/se/
text.rs

Help
1//! Contains serializer for a special `&text` field
2
3use crate::de::TEXT_KEY;
4use crate::errors::serialize::DeError;
5use crate::se::simple_type::{SimpleSeq, SimpleTypeSerializer};
6use serde::ser::{Impossible, Serialize, Serializer};
7use serde::serde_if_integer128;
8use std::fmt::Write;
9
10macro_rules! write_primitive {
11    ($method:ident ( $ty:ty )) => {
12        #[inline]
13        fn $method(self, value: $ty) -> Result<Self::Ok, Self::Error> {
14            self.0.$method(value)
15        }
16    };
17}
18
19////////////////////////////////////////////////////////////////////////////////////////////////////
20
21/// A serializer used to serialize a `$text` field of a struct or map.
22///
23/// This serializer a very similar to [`SimpleTypeSerializer`], but different
24/// from it in how it processes unit enum variants. Unlike [`SimpleTypeSerializer`]
25/// this serializer does not write anything for the unit variant.
26pub struct TextSerializer<'i, W: Write>(pub SimpleTypeSerializer<'i, W>);
27
28impl<'i, W: Write> Serializer for TextSerializer<'i, W> {
29    type Ok = W;
30    type Error = DeError;
31
32    type SerializeSeq = SimpleSeq<'i, W>;
33    type SerializeTuple = SimpleSeq<'i, W>;
34    type SerializeTupleStruct = SimpleSeq<'i, W>;
35    type SerializeTupleVariant = SimpleSeq<'i, W>;
36    type SerializeMap = Impossible<Self::Ok, Self::Error>;
37    type SerializeStruct = Impossible<Self::Ok, Self::Error>;
38    type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
39
40    write_primitive!(serialize_bool(bool));
41
42    write_primitive!(serialize_i8(i8));
43    write_primitive!(serialize_i16(i16));
44    write_primitive!(serialize_i32(i32));
45    write_primitive!(serialize_i64(i64));
46
47    write_primitive!(serialize_u8(u8));
48    write_primitive!(serialize_u16(u16));
49    write_primitive!(serialize_u32(u32));
50    write_primitive!(serialize_u64(u64));
51
52    serde_if_integer128! {
53        write_primitive!(serialize_i128(i128));
54        write_primitive!(serialize_u128(u128));
55    }
56
57    write_primitive!(serialize_f32(f32));
58    write_primitive!(serialize_f64(f64));
59
60    write_primitive!(serialize_char(char));
61    write_primitive!(serialize_str(&str));
62    write_primitive!(serialize_bytes(&[u8]));
63
64    #[inline]
65    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
66        self.0.serialize_none()
67    }
68
69    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
70        value.serialize(self)
71    }
72
73    #[inline]
74    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
75        self.0.serialize_unit()
76    }
77
78    #[inline]
79    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
80        self.0.serialize_unit_struct(name)
81    }
82
83    #[inline]
84    fn serialize_unit_variant(
85        self,
86        name: &'static str,
87        variant_index: u32,
88        variant: &'static str,
89    ) -> Result<Self::Ok, Self::Error> {
90        if variant == TEXT_KEY {
91            Ok(self.0.writer)
92        } else {
93            self.0.serialize_unit_variant(name, variant_index, variant)
94        }
95    }
96
97    fn serialize_newtype_struct<T: ?Sized + Serialize>(
98        self,
99        _name: &'static str,
100        value: &T,
101    ) -> Result<Self::Ok, Self::Error> {
102        value.serialize(self)
103    }
104
105    #[inline]
106    fn serialize_newtype_variant<T: ?Sized + Serialize>(
107        self,
108        name: &'static str,
109        _variant_index: u32,
110        variant: &'static str,
111        _value: &T,
112    ) -> Result<Self::Ok, Self::Error> {
113        Err(DeError::Unsupported(
114            format!(
115                "cannot serialize enum newtype variant `{}::{}` as text content value",
116                name, variant
117            )
118            .into(),
119        ))
120    }
121
122    #[inline]
123    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
124        self.0.serialize_seq(len)
125    }
126
127    #[inline]
128    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
129        self.0.serialize_tuple(len)
130    }
131
132    #[inline]
133    fn serialize_tuple_struct(
134        self,
135        name: &'static str,
136        len: usize,
137    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
138        self.0.serialize_tuple_struct(name, len)
139    }
140
141    #[inline]
142    fn serialize_tuple_variant(
143        self,
144        name: &'static str,
145        _variant_index: u32,
146        variant: &'static str,
147        _len: usize,
148    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
149        Err(DeError::Unsupported(
150            format!(
151                "cannot serialize enum tuple variant `{}::{}` as text content value",
152                name, variant
153            )
154            .into(),
155        ))
156    }
157
158    #[inline]
159    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
160        Err(DeError::Unsupported(
161            "cannot serialize map as text content value".into(),
162        ))
163    }
164
165    #[inline]
166    fn serialize_struct(
167        self,
168        name: &'static str,
169        _len: usize,
170    ) -> Result<Self::SerializeStruct, Self::Error> {
171        Err(DeError::Unsupported(
172            format!("cannot serialize struct `{}` as text content value", name).into(),
173        ))
174    }
175
176    #[inline]
177    fn serialize_struct_variant(
178        self,
179        name: &'static str,
180        _variant_index: u32,
181        variant: &'static str,
182        _len: usize,
183    ) -> Result<Self::SerializeStructVariant, Self::Error> {
184        Err(DeError::Unsupported(
185            format!(
186                "cannot serialize enum struct variant `{}::{}` as text content value",
187                name, variant
188            )
189            .into(),
190        ))
191    }
192}
quick_xml/se/text.rs

quick_xml/se/
text.rs
