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

xmlity/value/
serializer.rs
