xmlity/value/
serializer.rs

1use crate::{
2    noop::NoopDeSerializer,
3    ser::{self, Error, IncludePrefix, SerializeAttributeAccess, Unexpected},
4    ExpandedName, Prefix, Serialize, SerializeAttribute, Serializer,
5};
6
7use super::*;
8
9impl<'s> Serializer for &'s mut &mut XmlSeq<XmlValue> {
10    type Ok = ();
11    type Error = XmlValueSerializerError;
12
13    type SerializeSeq = &'s mut XmlSeq<XmlValue>;
14    type SerializeElement = &'s mut XmlElement;
15
16    fn serialize_cdata<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
17        self.values
18            .push_back(XmlValue::CData(XmlCData::new(text.as_ref().as_bytes())));
19        Ok(())
20    }
21
22    fn serialize_text<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
23        self.values.push_back(XmlValue::Text(XmlText::new(text)));
24        Ok(())
25    }
26
27    fn serialize_element(
28        self,
29        name: &'_ ExpandedName<'_>,
30    ) -> Result<Self::SerializeElement, Self::Error> {
31        self.values.push_back(XmlValue::Element(XmlElement::new(
32            name.clone().into_owned(),
33        )));
34
35        let XmlValue::Element(element) = self.values.back_mut().expect("just push_backed") else {
36            unreachable!()
37        };
38
39        Ok(element)
40    }
41
42    fn serialize_seq(self) -> Result<Self::SerializeSeq, Self::Error> {
43        Ok(self)
44    }
45
46    fn serialize_pi<S: AsRef<[u8]>>(self, target: S, content: S) -> Result<Self::Ok, Self::Error> {
47        self.values
48            .push_back(XmlValue::PI(XmlProcessingInstruction {
49                target: target.as_ref().to_vec(),
50                content: content.as_ref().to_vec(),
51            }));
52        Ok(())
53    }
54
55    fn serialize_comment<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
56        self.values
57            .push_back(XmlValue::Comment(XmlComment(text.as_ref().to_vec())));
58        Ok(())
59    }
60
61    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
62        self.values.push_back(XmlValue::None);
63        Ok(())
64    }
65
66    fn serialize_decl<S: AsRef<str>>(
67        self,
68        version: S,
69        encoding: Option<S>,
70        standalone: Option<S>,
71    ) -> Result<Self::Ok, Self::Error> {
72        self.values
73            .push_back(XmlValue::Decl(XmlDecl::new(version, encoding, standalone)));
74        Ok(())
75    }
76
77    fn serialize_doctype<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
78        self.values
79            .push_back(XmlValue::Doctype(XmlDoctype(text.as_ref().to_vec())));
80        Ok(())
81    }
82}
83
84impl<'s> Serializer for &'s mut XmlValue {
85    type Ok = ();
86    type Error = XmlValueSerializerError;
87
88    type SerializeSeq = &'s mut XmlSeq<XmlValue>;
89    type SerializeElement = &'s mut XmlElement;
90
91    fn serialize_cdata<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
92        *self = XmlValue::CData(XmlCData::new(text.as_ref().as_bytes()));
93        Ok(())
94    }
95
96    fn serialize_text<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
97        *self = XmlValue::Text(XmlText::new(text));
98        Ok(())
99    }
100
101    fn serialize_element(
102        self,
103        name: &'_ ExpandedName<'_>,
104    ) -> Result<Self::SerializeElement, Self::Error> {
105        *self = XmlValue::Element(XmlElement::new(name.clone().into_owned()));
106
107        let XmlValue::Element(element) = self else {
108            unreachable!()
109        };
110
111        Ok(element)
112    }
113
114    fn serialize_seq(self) -> Result<Self::SerializeSeq, Self::Error> {
115        *self = XmlValue::Seq(XmlSeq::new());
116        let XmlValue::Seq(seq) = self else {
117            unreachable!()
118        };
119        Ok(seq)
120    }
121
122    fn serialize_decl<S: AsRef<str>>(
123        self,
124        version: S,
125        encoding: Option<S>,
126        standalone: Option<S>,
127    ) -> Result<Self::Ok, Self::Error> {
128        *self = XmlValue::Decl(XmlDecl::new(version, encoding, standalone));
129        Ok(())
130    }
131
132    fn serialize_pi<S: AsRef<[u8]>>(self, target: S, content: S) -> Result<Self::Ok, Self::Error> {
133        *self = XmlValue::PI(XmlProcessingInstruction {
134            target: target.as_ref().to_vec(),
135            content: content.as_ref().to_vec(),
136        });
137        Ok(())
138    }
139
140    fn serialize_comment<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
141        *self = XmlValue::Comment(XmlComment(text.as_ref().to_vec()));
142        Ok(())
143    }
144
145    fn serialize_doctype<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
146        *self = XmlValue::Doctype(XmlDoctype(text.as_ref().to_vec()));
147        Ok(())
148    }
149
150    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
151        *self = XmlValue::None;
152        Ok(())
153    }
154}
155
156impl<'s> Serializer for &'s mut &mut XmlSeq<XmlChild> {
157    type Ok = ();
158    type Error = XmlValueSerializerError;
159
160    type SerializeSeq = &'s mut XmlSeq<XmlChild>;
161    type SerializeElement = &'s mut XmlElement;
162
163    fn serialize_cdata<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
164        self.values
165            .push_back(XmlChild::CData(XmlCData::new(text.as_ref().as_bytes())));
166        Ok(())
167    }
168
169    fn serialize_text<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
170        self.values.push_back(XmlChild::Text(XmlText::new(text)));
171        Ok(())
172    }
173
174    fn serialize_element(
175        self,
176        name: &'_ ExpandedName<'_>,
177    ) -> Result<Self::SerializeElement, Self::Error> {
178        self.values.push_back(XmlChild::Element(XmlElement::new(
179            name.clone().into_owned(),
180        )));
181
182        let XmlChild::Element(element) = self.values.back_mut().expect("just push_backed") else {
183            unreachable!()
184        };
185
186        Ok(element)
187    }
188
189    fn serialize_seq(self) -> Result<Self::SerializeSeq, Self::Error> {
190        Ok(self)
191    }
192
193    fn serialize_pi<S: AsRef<[u8]>>(self, target: S, content: S) -> Result<Self::Ok, Self::Error> {
194        self.values
195            .push_back(XmlChild::PI(XmlProcessingInstruction {
196                target: target.as_ref().to_vec(),
197                content: content.as_ref().to_vec(),
198            }));
199        Ok(())
200    }
201
202    fn serialize_comment<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
203        self.values
204            .push_back(XmlChild::Comment(XmlComment(text.as_ref().to_vec())));
205        Ok(())
206    }
207
208    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
209        self.values.push_back(XmlChild::None);
210        Ok(())
211    }
212
213    fn serialize_decl<S: AsRef<str>>(
214        self,
215        _version: S,
216        _encoding: Option<S>,
217        _standalone: Option<S>,
218    ) -> Result<Self::Ok, Self::Error> {
219        Err(Error::unexpected_serialize(Unexpected::Decl))
220    }
221
222    fn serialize_doctype<S: AsRef<[u8]>>(self, _text: S) -> Result<Self::Ok, Self::Error> {
223        Err(Error::unexpected_serialize(Unexpected::DocType))
224    }
225}
226
227impl ser::SerializeAttributes for &mut XmlElement {
228    type Ok = ();
229
230    type Error = XmlValueSerializerError;
231
232    fn serialize_attribute<A: SerializeAttribute>(
233        &mut self,
234        a: &A,
235    ) -> Result<Self::Ok, Self::Error> {
236        a.serialize_attribute(self)?;
237
238        Ok(())
239    }
240}
241
242/// Builder used when serializing to an [`XmlAttribute``].
243pub struct XmlAttributeBuilder<'a> {
244    name: ExpandedName<'static>,
245    write_to: &'a mut VecDeque<XmlAttribute>,
246    should_enforce: IncludePrefix,
247    preferred_prefix: Option<Prefix<'static>>,
248}
249
250impl<'a> XmlAttributeBuilder<'a> {
251    /// Creates a new [`XmlAttributeBuilder`].
252    pub fn new(name: ExpandedName<'static>, write_to: &'a mut VecDeque<XmlAttribute>) -> Self {
253        Self {
254            name,
255            write_to,
256            should_enforce: IncludePrefix::default(),
257            preferred_prefix: None,
258        }
259    }
260}
261
262impl ser::AttributeSerializer for &mut &mut XmlElement {
263    type Ok = ();
264    type Error = XmlValueSerializerError;
265
266    type SerializeAttribute<'a>
267        = XmlAttributeBuilder<'a>
268    where
269        Self: 'a;
270
271    fn serialize_attribute(
272        &mut self,
273        name: &'_ ExpandedName<'_>,
274    ) -> Result<Self::SerializeAttribute<'_>, Self::Error> {
275        Ok(XmlAttributeBuilder {
276            name: name.clone().into_owned(),
277            write_to: &mut self.attributes,
278            should_enforce: IncludePrefix::default(),
279            preferred_prefix: None,
280        })
281    }
282
283    fn serialize_none(&mut self) -> Result<Self::Ok, Self::Error> {
284        Ok(())
285    }
286}
287
288impl<'s> ser::SerializeElementAttributes for &'s mut XmlElement {
289    type ChildrenSerializeSeq = &'s mut XmlSeq<XmlChild>;
290
291    fn serialize_children(self) -> Result<Self::ChildrenSerializeSeq, Self::Error> {
292        Ok(&mut self.children)
293    }
294
295    fn end(self) -> Result<Self::Ok, Self::Error> {
296        Ok(())
297    }
298}
299
300impl<'s> ser::SerializeElement for &'s mut XmlElement {
301    type Ok = ();
302
303    type Error = XmlValueSerializerError;
304
305    type ChildrenSerializeSeq = &'s mut XmlSeq<XmlChild>;
306    type SerializeElementAttributes = &'s mut XmlElement;
307
308    fn include_prefix(&mut self, should_enforce: IncludePrefix) -> Result<Self::Ok, Self::Error> {
309        self.enforce_prefix = should_enforce;
310        Ok(())
311    }
312
313    fn preferred_prefix(
314        &mut self,
315        preferred_prefix: Option<crate::Prefix<'_>>,
316    ) -> Result<Self::Ok, Self::Error> {
317        self.preferred_prefix = preferred_prefix.map(Prefix::into_owned);
318        Ok(())
319    }
320
321    fn serialize_children(self) -> Result<Self::ChildrenSerializeSeq, Self::Error> {
322        Ok(&mut self.children)
323    }
324
325    fn end(self) -> Result<Self::Ok, Self::Error> {
326        Ok(())
327    }
328
329    fn serialize_attributes(self) -> Result<Self::SerializeElementAttributes, Self::Error> {
330        Ok(self)
331    }
332}
333
334// Seq
335
336impl crate::ser::SerializeSeq for &mut XmlSeq<XmlValue> {
337    type Ok = ();
338
339    type Error = XmlValueSerializerError;
340
341    fn serialize_element<V: Serialize>(&mut self, v: &V) -> Result<Self::Ok, Self::Error> {
342        v.serialize(self)
343    }
344
345    fn end(self) -> Result<Self::Ok, Self::Error> {
346        Ok(())
347    }
348}
349
350impl crate::ser::SerializeSeq for &mut XmlSeq<XmlChild> {
351    type Ok = ();
352
353    type Error = XmlValueSerializerError;
354
355    fn serialize_element<V: Serialize>(&mut self, v: &V) -> Result<Self::Ok, Self::Error> {
356        v.serialize(self)?;
357        Ok(())
358    }
359
360    fn end(self) -> Result<Self::Ok, Self::Error> {
361        Ok(())
362    }
363}
364
365impl SerializeAttributeAccess for XmlAttributeBuilder<'_> {
366    type Ok = ();
367
368    type Error = XmlValueSerializerError;
369
370    fn include_prefix(&mut self, should_enforce: IncludePrefix) -> Result<Self::Ok, Self::Error> {
371        self.should_enforce = should_enforce;
372        Ok(())
373    }
374
375    fn preferred_prefix(
376        &mut self,
377        preferred_prefix: Option<crate::Prefix<'_>>,
378    ) -> Result<Self::Ok, Self::Error> {
379        self.preferred_prefix = preferred_prefix.map(|p| p.into_owned());
380        Ok(())
381    }
382
383    /// Serialize the attribute.
384    fn end<S: Serialize>(self, value: &S) -> Result<Self::Ok, Self::Error> {
385        let mut value_container = XmlText::new("");
386        value.serialize(&mut value_container)?;
387        self.write_to.push_back(XmlAttribute {
388            name: self.name,
389            value: value_container,
390        });
391        Ok(())
392    }
393}
394
395impl crate::ser::Serializer for &mut XmlText {
396    type Ok = ();
397
398    type Error = XmlValueSerializerError;
399
400    type SerializeElement = NoopDeSerializer<Self::Ok, XmlValueSerializerError>;
401
402    type SerializeSeq = NoopDeSerializer<Self::Ok, XmlValueSerializerError>;
403
404    fn serialize_text<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
405        self.0 = text.as_ref().as_bytes().to_vec();
406
407        Ok(())
408    }
409
410    fn serialize_cdata<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
411        let _ = text;
412
413        Err(Error::unexpected_serialize(Unexpected::CData))
414    }
415
416    fn serialize_element(
417        self,
418        name: &'_ ExpandedName<'_>,
419    ) -> Result<Self::SerializeElement, Self::Error> {
420        let _ = name;
421
422        Err(Error::unexpected_serialize(Unexpected::Element))
423    }
424
425    fn serialize_seq(self) -> Result<Self::SerializeSeq, Self::Error> {
426        Err(Error::unexpected_serialize(Unexpected::Seq))
427    }
428
429    fn serialize_decl<S: AsRef<str>>(
430        self,
431        version: S,
432        encoding: Option<S>,
433        standalone: Option<S>,
434    ) -> Result<Self::Ok, Self::Error> {
435        let _ = (version, encoding, standalone);
436
437        Err(Error::unexpected_serialize(Unexpected::Decl))
438    }
439
440    fn serialize_pi<S: AsRef<[u8]>>(self, target: S, content: S) -> Result<Self::Ok, Self::Error> {
441        let _ = (target, content);
442
443        Err(Error::unexpected_serialize(Unexpected::PI))
444    }
445
446    fn serialize_comment<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
447        let _ = text;
448
449        Err(Error::unexpected_serialize(Unexpected::Comment))
450    }
451
452    fn serialize_doctype<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
453        let _ = text;
454
455        Err(Error::unexpected_serialize(Unexpected::DocType))
456    }
457
458    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
459        Err(Error::unexpected_serialize(Unexpected::None))
460    }
461}
xmlity/value/serializer.rs

xmlity/value/
serializer.rs
