xmlity/types/
value.rs

1//! This module contains the [`XmlValue`] type, which is a type which can be serialized or deserialized as XML, and a type which other types can deserialize from/serialize into.
2//!
3//! It also contains subtypes to [`XmlValue`] including [`XmlText`], [`XmlElement`], and [`XmlAttribute`], which can be used to deserialize from/serialize into specific types of XML data.
4//!
5//! This is very useful in cases where you have arbitrary XML data, and you want to deserialize it into a type which can be used in your application, but you don't know what the type is ahead of time and want to be able to handle it generically.
6//!
7//! The types in this module can be constructed using the [`crate::xml!`] macro.
8use core::{
9    fmt::{self, Debug},
10    str,
11};
12use std::{fmt::Formatter, iter, ops::Deref};
13
14use crate::{
15    de::{self, AttributesAccess, ElementAccess, SeqAccess, Visitor},
16    ser::{
17        self, IncludePrefix, SerializeAttributeAccess, SerializeAttributes, SerializeChildren,
18        SerializeElement, SerializeElementChildren, SerializeSeq,
19    },
20    AttributeSerializer, Deserialize, Deserializer, ExpandedName, Prefix, Serialize,
21    SerializeAttribute, Serializer,
22};
23
24/// A value that can be serialized or deserialized as XML, and a type which other types can deserialize from/serialize into.
25#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
26pub enum XmlValue {
27    /// A text node.
28    Text(XmlText),
29    /// A CDATA section.
30    CData(XmlCData),
31    /// An element.
32    Element(XmlElement),
33    /// A sequence of XML values.
34    Seq(XmlSeq<XmlValue>),
35    /// A processing instruction.
36    PI(XmlPI),
37    /// A declaration.
38    Decl(XmlDecl),
39    /// A comment.
40    Comment(XmlComment),
41    /// A doctype.
42    Doctype(XmlDoctype),
43    /// Nothing.
44    #[default]
45    None,
46}
47
48impl From<XmlText> for XmlValue {
49    fn from(value: XmlText) -> Self {
50        XmlValue::Text(value)
51    }
52}
53
54impl From<XmlCData> for XmlValue {
55    fn from(value: XmlCData) -> Self {
56        XmlValue::CData(value)
57    }
58}
59
60impl From<XmlElement> for XmlValue {
61    fn from(value: XmlElement) -> Self {
62        XmlValue::Element(value)
63    }
64}
65
66impl From<XmlSeq<XmlValue>> for XmlValue {
67    fn from(value: XmlSeq<XmlValue>) -> Self {
68        XmlValue::Seq(value)
69    }
70}
71
72impl From<XmlPI> for XmlValue {
73    fn from(value: XmlPI) -> Self {
74        XmlValue::PI(value)
75    }
76}
77impl From<XmlDecl> for XmlValue {
78    fn from(value: XmlDecl) -> Self {
79        XmlValue::Decl(value)
80    }
81}
82impl From<XmlComment> for XmlValue {
83    fn from(value: XmlComment) -> Self {
84        XmlValue::Comment(value)
85    }
86}
87impl From<XmlDoctype> for XmlValue {
88    fn from(value: XmlDoctype) -> Self {
89        XmlValue::Doctype(value)
90    }
91}
92
93impl Serialize for XmlValue {
94    fn serialize<S: crate::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
95        match self {
96            XmlValue::Text(xml_text) => xml_text.serialize(serializer),
97            XmlValue::CData(xml_cdata) => xml_cdata.serialize(serializer),
98            XmlValue::Element(xml_element) => xml_element.serialize(serializer),
99            XmlValue::Seq(xml_seq) => xml_seq.serialize(serializer),
100            XmlValue::PI(xml_pi) => xml_pi.serialize(serializer),
101            XmlValue::Decl(xml_decl) => xml_decl.serialize(serializer),
102            XmlValue::Comment(xml_comment) => xml_comment.serialize(serializer),
103            XmlValue::Doctype(xml_doctype) => xml_doctype.serialize(serializer),
104            XmlValue::None => serializer.serialize_none(),
105        }
106    }
107}
108
109impl<'de> Deserialize<'de> for XmlValue {
110    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
111    where
112        D: Deserializer<'de>,
113    {
114        struct __Visitor<'v> {
115            marker: ::core::marker::PhantomData<XmlValue>,
116            lifetime: ::core::marker::PhantomData<&'v ()>,
117        }
118
119        impl<'v> crate::de::Visitor<'v> for __Visitor<'v> {
120            type Value = XmlValue;
121
122            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
123                formatter.write_str("a comment")
124            }
125
126            fn visit_text<E, V>(self, value: V) -> Result<Self::Value, E>
127            where
128                E: de::Error,
129                V: de::XmlText,
130            {
131                XmlTextVisitor::new().visit_text(value).map(XmlValue::Text)
132            }
133
134            fn visit_cdata<E, V>(self, value: V) -> Result<Self::Value, E>
135            where
136                E: de::Error,
137                V: de::XmlCData,
138            {
139                XmlCDataVisitor::new()
140                    .visit_cdata(value)
141                    .map(XmlValue::CData)
142            }
143
144            fn visit_element<A>(self, element: A) -> Result<Self::Value, A::Error>
145            where
146                A: de::ElementAccess<'v>,
147            {
148                XmlElementVisitor::new()
149                    .visit_element(element)
150                    .map(XmlValue::Element)
151            }
152
153            fn visit_seq<S>(self, sequence: S) -> Result<Self::Value, S::Error>
154            where
155                S: de::SeqAccess<'v>,
156            {
157                XmlSeqVisitor::new().visit_seq(sequence).map(XmlValue::Seq)
158            }
159
160            fn visit_pi<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
161            where
162                E: de::Error,
163            {
164                XmlPIVisitor::new().visit_pi(value).map(XmlValue::PI)
165            }
166
167            fn visit_decl<E, V: AsRef<[u8]>>(
168                self,
169                version: V,
170                encoding: Option<V>,
171                standalone: Option<V>,
172            ) -> Result<Self::Value, E>
173            where
174                E: de::Error,
175            {
176                XmlDeclVisitor::new()
177                    .visit_decl(version, encoding, standalone)
178                    .map(XmlValue::Decl)
179            }
180
181            fn visit_comment<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
182            where
183                E: de::Error,
184            {
185                XmlCommentVisitor::new()
186                    .visit_comment(value)
187                    .map(XmlValue::Comment)
188            }
189
190            fn visit_doctype<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
191            where
192                E: de::Error,
193            {
194                XmlDoctypeVisitor::new()
195                    .visit_doctype(value)
196                    .map(XmlValue::Doctype)
197            }
198
199            fn visit_none<E>(self) -> Result<Self::Value, E>
200            where
201                E: de::Error,
202            {
203                Ok(XmlValue::None)
204            }
205        }
206
207        deserializer.deserialize_any(__Visitor {
208            lifetime: ::core::marker::PhantomData,
209            marker: ::core::marker::PhantomData,
210        })
211    }
212}
213
214impl<'s> Serializer for &'s mut &mut XmlSeq<XmlValue> {
215    type Ok = ();
216    type Error = XmlValueSerializerError;
217
218    type SerializeSeq = &'s mut XmlSeq<XmlValue>;
219    type SerializeElement = &'s mut XmlElement;
220
221    fn serialize_cdata<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
222        self.values
223            .push(XmlValue::CData(XmlCData::new(text.as_ref().as_bytes())));
224        Ok(())
225    }
226
227    fn serialize_text<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
228        self.values.push(XmlValue::Text(XmlText::new(text)));
229        Ok(())
230    }
231
232    fn serialize_element(
233        self,
234        name: &'_ ExpandedName<'_>,
235    ) -> Result<Self::SerializeElement, Self::Error> {
236        self.values.push(XmlValue::Element(XmlElement::new(
237            name.clone().into_owned(),
238        )));
239
240        let XmlValue::Element(element) = self.values.last_mut().expect("just pushed") else {
241            unreachable!()
242        };
243
244        Ok(element)
245    }
246
247    fn serialize_seq(self) -> Result<Self::SerializeSeq, Self::Error> {
248        Ok(self)
249    }
250
251    fn serialize_pi<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
252        self.values
253            .push(XmlValue::PI(XmlPI(text.as_ref().to_vec())));
254        Ok(())
255    }
256
257    fn serialize_comment<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
258        self.values
259            .push(XmlValue::Comment(XmlComment(text.as_ref().to_vec())));
260        Ok(())
261    }
262
263    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
264        self.values.push(XmlValue::None);
265        Ok(())
266    }
267
268    fn serialize_decl<S: AsRef<str>>(
269        self,
270        version: S,
271        encoding: Option<S>,
272        standalone: Option<S>,
273    ) -> Result<Self::Ok, Self::Error> {
274        self.values
275            .push(XmlValue::Decl(XmlDecl::new(version, encoding, standalone)));
276        Ok(())
277    }
278
279    fn serialize_doctype<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
280        self.values
281            .push(XmlValue::Doctype(XmlDoctype(text.as_ref().to_vec())));
282        Ok(())
283    }
284}
285
286impl<'s> Serializer for &'s mut XmlValue {
287    type Ok = ();
288    type Error = XmlValueSerializerError;
289
290    type SerializeSeq = &'s mut XmlSeq<XmlValue>;
291    type SerializeElement = &'s mut XmlElement;
292
293    fn serialize_cdata<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
294        *self = XmlValue::CData(XmlCData::new(text.as_ref().as_bytes()));
295        Ok(())
296    }
297
298    fn serialize_text<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
299        *self = XmlValue::Text(XmlText::new(text));
300        Ok(())
301    }
302
303    fn serialize_element(
304        self,
305        name: &'_ ExpandedName<'_>,
306    ) -> Result<Self::SerializeElement, Self::Error> {
307        *self = XmlValue::Element(XmlElement::new(name.clone().into_owned()));
308
309        let XmlValue::Element(element) = self else {
310            unreachable!()
311        };
312
313        Ok(element)
314    }
315
316    fn serialize_seq(self) -> Result<Self::SerializeSeq, Self::Error> {
317        *self = XmlValue::Seq(XmlSeq::new());
318        let XmlValue::Seq(seq) = self else {
319            unreachable!()
320        };
321        Ok(seq)
322    }
323
324    fn serialize_decl<S: AsRef<str>>(
325        self,
326        version: S,
327        encoding: Option<S>,
328        standalone: Option<S>,
329    ) -> Result<Self::Ok, Self::Error> {
330        *self = XmlValue::Decl(XmlDecl::new(version, encoding, standalone));
331        Ok(())
332    }
333
334    fn serialize_pi<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
335        *self = XmlValue::PI(XmlPI(text.as_ref().to_vec()));
336        Ok(())
337    }
338
339    fn serialize_comment<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
340        *self = XmlValue::Comment(XmlComment(text.as_ref().to_vec()));
341        Ok(())
342    }
343
344    fn serialize_doctype<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
345        *self = XmlValue::Doctype(XmlDoctype(text.as_ref().to_vec()));
346        Ok(())
347    }
348
349    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
350        *self = XmlValue::None;
351        Ok(())
352    }
353}
354
355impl<'de> Deserializer<'de> for &'de XmlValue {
356    type Error = XmlValueDeserializerError;
357
358    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
359    where
360        V: Visitor<'de>,
361    {
362        match self {
363            XmlValue::Text(xml_text) => xml_text.deserialize_any(visitor),
364            XmlValue::CData(xml_cdata) => xml_cdata.deserialize_any(visitor),
365            XmlValue::Element(xml_element) => xml_element.deserialize_any(visitor),
366            XmlValue::Seq(xml_seq) => XmlSeqAccess::new(xml_seq).deserialize_any(visitor),
367            XmlValue::PI(xml_pi) => xml_pi.deserialize_any(visitor),
368            XmlValue::Decl(xml_decl) => xml_decl.deserialize_any(visitor),
369            XmlValue::Comment(xml_comment) => xml_comment.deserialize_any(visitor),
370            XmlValue::Doctype(xml_doctype) => xml_doctype.deserialize_any(visitor),
371            XmlValue::None => visitor.visit_none(),
372        }
373    }
374
375    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
376    where
377        V: Visitor<'de>,
378    {
379        match self {
380            XmlValue::Text(xml_text) => xml_text.deserialize_seq(visitor),
381            XmlValue::CData(xml_cdata) => xml_cdata.deserialize_seq(visitor),
382            XmlValue::Element(xml_element) => xml_element.deserialize_seq(visitor),
383            XmlValue::Seq(xml_seq) => XmlSeqAccess::new(xml_seq).deserialize_seq(visitor),
384            XmlValue::PI(xml_pi) => xml_pi.deserialize_seq(visitor),
385            XmlValue::Decl(xml_decl) => xml_decl.deserialize_seq(visitor),
386            XmlValue::Comment(xml_comment) => xml_comment.deserialize_seq(visitor),
387            XmlValue::Doctype(xml_doctype) => xml_doctype.deserialize_seq(visitor),
388            XmlValue::None => visitor.visit_none(),
389        }
390    }
391}
392
393/// A text node in an XML document.
394#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
395#[non_exhaustive]
396pub struct XmlText(pub Vec<u8>);
397
398impl XmlText {
399    /// Creates a new [`XmlText`] from a string.
400    pub fn new<T: AsRef<str>>(text: T) -> Self {
401        Self(text.as_ref().as_bytes().to_vec())
402    }
403}
404
405impl Debug for XmlText {
406    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
407        f.debug_tuple("XmlText")
408            .field(&String::from_utf8_lossy(&self.0))
409            .finish()
410    }
411}
412
413impl Serialize for XmlText {
414    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
415    where
416        S: Serializer,
417    {
418        serializer.serialize_text(String::from_utf8_lossy(&self.0))
419    }
420}
421
422struct XmlTextVisitor<'v> {
423    marker: ::core::marker::PhantomData<XmlText>,
424    lifetime: ::core::marker::PhantomData<&'v ()>,
425}
426
427impl XmlTextVisitor<'_> {
428    fn new() -> Self {
429        Self {
430            marker: ::core::marker::PhantomData,
431            lifetime: ::core::marker::PhantomData,
432        }
433    }
434}
435
436impl<'v> crate::de::Visitor<'v> for XmlTextVisitor<'v> {
437    type Value = XmlText;
438
439    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
440        formatter.write_str("a comment")
441    }
442
443    fn visit_text<E, V>(self, value: V) -> Result<Self::Value, E>
444    where
445        E: de::Error,
446        V: de::XmlText,
447    {
448        Ok(XmlText(value.as_bytes().to_owned()))
449    }
450}
451
452impl<'de> Deserialize<'de> for XmlText {
453    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
454    where
455        D: Deserializer<'de>,
456    {
457        deserializer.deserialize_any(XmlTextVisitor::new())
458    }
459}
460
461impl de::XmlText for &XmlText {
462    fn as_bytes(&self) -> &[u8] {
463        &self.0
464    }
465
466    fn as_str(&self) -> std::borrow::Cow<'_, str> {
467        std::borrow::Cow::Borrowed(std::str::from_utf8(&self.0).unwrap())
468    }
469}
470
471impl<'de> Deserializer<'de> for &'de XmlText {
472    type Error = XmlValueDeserializerError;
473    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
474    where
475        V: Visitor<'de>,
476    {
477        visitor.visit_text(self)
478    }
479
480    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
481    where
482        V: Visitor<'de>,
483    {
484        self.deserialize_any(visitor)
485    }
486}
487
488/// CDATA section.
489#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
490pub struct XmlCData(pub Vec<u8>);
491
492impl XmlCData {
493    /// Creates a new [CDATA section](`XmlCData`).
494    pub fn new<T: Into<Vec<u8>>>(text: T) -> Self {
495        Self(text.into())
496    }
497}
498
499impl Serialize for XmlCData {
500    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
501    where
502        S: Serializer,
503    {
504        serializer.serialize_cdata(str::from_utf8(&self.0).unwrap())
505    }
506}
507
508struct XmlCDataVisitor<'v> {
509    marker: ::core::marker::PhantomData<XmlCData>,
510    lifetime: ::core::marker::PhantomData<&'v ()>,
511}
512impl XmlCDataVisitor<'_> {
513    fn new() -> Self {
514        Self {
515            marker: ::core::marker::PhantomData,
516            lifetime: ::core::marker::PhantomData,
517        }
518    }
519}
520
521impl<'de> Visitor<'de> for XmlCDataVisitor<'de> {
522    type Value = XmlCData;
523    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
524        formatter.write_str("a CDATA section")
525    }
526    fn visit_cdata<E, V>(self, value: V) -> Result<Self::Value, E>
527    where
528        E: de::Error,
529        V: de::XmlCData,
530    {
531        Ok(XmlCData(value.as_bytes().to_owned()))
532    }
533}
534
535impl<'de> Deserialize<'de> for XmlCData {
536    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
537    where
538        D: Deserializer<'de>,
539    {
540        deserializer.deserialize_any(XmlCDataVisitor::new())
541    }
542}
543
544impl de::XmlCData for &XmlCData {
545    fn as_bytes(&self) -> &[u8] {
546        &self.0
547    }
548
549    fn as_str(&self) -> std::borrow::Cow<'_, str> {
550        std::borrow::Cow::Borrowed(std::str::from_utf8(&self.0).unwrap())
551    }
552}
553
554impl<'de> Deserializer<'de> for &'de XmlCData {
555    type Error = XmlValueDeserializerError;
556    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
557    where
558        V: Visitor<'de>,
559    {
560        visitor.visit_cdata(self)
561    }
562
563    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
564    where
565        V: Visitor<'de>,
566    {
567        self.deserialize_any(visitor)
568    }
569}
570
571/// An XML child node.
572#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
573pub enum XmlChild {
574    /// A text node.
575    Text(XmlText),
576    /// A CDATA node.
577    CData(XmlCData),
578    /// An element node.
579    Element(XmlElement),
580    /// A processing instruction node.
581    PI(XmlPI),
582    /// A comment node.
583    Comment(XmlComment),
584    /// Nothing.
585    #[default]
586    None,
587}
588
589impl From<XmlText> for XmlChild {
590    fn from(value: XmlText) -> Self {
591        XmlChild::Text(value)
592    }
593}
594
595impl From<XmlCData> for XmlChild {
596    fn from(value: XmlCData) -> Self {
597        XmlChild::CData(value)
598    }
599}
600
601impl From<XmlElement> for XmlChild {
602    fn from(value: XmlElement) -> Self {
603        XmlChild::Element(value)
604    }
605}
606
607impl From<XmlPI> for XmlChild {
608    fn from(value: XmlPI) -> Self {
609        XmlChild::PI(value)
610    }
611}
612
613impl From<XmlComment> for XmlChild {
614    fn from(value: XmlComment) -> Self {
615        XmlChild::Comment(value)
616    }
617}
618
619impl Serialize for XmlChild {
620    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
621    where
622        S: Serializer,
623    {
624        match self {
625            XmlChild::Text(v) => v.serialize(serializer),
626            XmlChild::CData(v) => v.serialize(serializer),
627            XmlChild::Element(v) => v.serialize(serializer),
628            XmlChild::PI(v) => v.serialize(serializer),
629            XmlChild::Comment(v) => v.serialize(serializer),
630            XmlChild::None => serializer.serialize_none(),
631        }
632    }
633}
634
635struct XmlChildVisitor<'v> {
636    marker: ::core::marker::PhantomData<XmlChild>,
637    lifetime: ::core::marker::PhantomData<&'v ()>,
638}
639impl XmlChildVisitor<'_> {
640    fn new() -> Self {
641        Self {
642            marker: ::core::marker::PhantomData,
643            lifetime: ::core::marker::PhantomData,
644        }
645    }
646}
647
648impl<'v> crate::de::Visitor<'v> for XmlChildVisitor<'v> {
649    type Value = XmlChild;
650    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
651        formatter.write_str("an XML child")
652    }
653
654    fn visit_text<E, V>(self, value: V) -> Result<Self::Value, E>
655    where
656        E: de::Error,
657        V: de::XmlText,
658    {
659        XmlTextVisitor::new().visit_text(value).map(XmlChild::Text)
660    }
661
662    fn visit_cdata<E, V>(self, value: V) -> Result<Self::Value, E>
663    where
664        E: de::Error,
665        V: de::XmlCData,
666    {
667        XmlCDataVisitor::new()
668            .visit_cdata(value)
669            .map(XmlChild::CData)
670    }
671
672    fn visit_element<A>(self, element: A) -> Result<Self::Value, A::Error>
673    where
674        A: de::ElementAccess<'v>,
675    {
676        XmlElementVisitor::new()
677            .visit_element(element)
678            .map(XmlChild::Element)
679    }
680
681    fn visit_pi<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
682    where
683        E: de::Error,
684    {
685        XmlPIVisitor::new().visit_pi(value).map(XmlChild::PI)
686    }
687
688    fn visit_comment<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
689    where
690        E: de::Error,
691    {
692        XmlCommentVisitor::new()
693            .visit_comment(value)
694            .map(XmlChild::Comment)
695    }
696}
697
698impl<'de> de::Deserialize<'de> for XmlChild {
699    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
700    where
701        D: de::Deserializer<'de>,
702    {
703        deserializer.deserialize_any(XmlChildVisitor::new())
704    }
705}
706
707impl<'s> Serializer for &'s mut &mut XmlSeq<XmlChild> {
708    type Ok = ();
709    type Error = XmlValueSerializerError;
710
711    type SerializeSeq = &'s mut XmlSeq<XmlChild>;
712    type SerializeElement = &'s mut XmlElement;
713
714    fn serialize_cdata<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
715        self.values
716            .push(XmlChild::CData(XmlCData::new(text.as_ref().as_bytes())));
717        Ok(())
718    }
719
720    fn serialize_text<S: AsRef<str>>(self, text: S) -> Result<Self::Ok, Self::Error> {
721        self.values.push(XmlChild::Text(XmlText::new(text)));
722        Ok(())
723    }
724
725    fn serialize_element(
726        self,
727        name: &'_ ExpandedName<'_>,
728    ) -> Result<Self::SerializeElement, Self::Error> {
729        self.values.push(XmlChild::Element(XmlElement::new(
730            name.clone().into_owned(),
731        )));
732
733        let XmlChild::Element(element) = self.values.last_mut().expect("just pushed") else {
734            unreachable!()
735        };
736
737        Ok(element)
738    }
739
740    fn serialize_seq(self) -> Result<Self::SerializeSeq, Self::Error> {
741        Ok(self)
742    }
743
744    fn serialize_pi<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
745        self.values
746            .push(XmlChild::PI(XmlPI(text.as_ref().to_vec())));
747        Ok(())
748    }
749
750    fn serialize_comment<S: AsRef<[u8]>>(self, text: S) -> Result<Self::Ok, Self::Error> {
751        self.values
752            .push(XmlChild::Comment(XmlComment(text.as_ref().to_vec())));
753        Ok(())
754    }
755
756    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
757        self.values.push(XmlChild::None);
758        Ok(())
759    }
760
761    fn serialize_decl<S: AsRef<str>>(
762        self,
763        _version: S,
764        _encoding: Option<S>,
765        _standalone: Option<S>,
766    ) -> Result<Self::Ok, Self::Error> {
767        Err(XmlValueSerializerError::InvalidChildDeserialization)
768    }
769
770    fn serialize_doctype<S: AsRef<[u8]>>(self, _text: S) -> Result<Self::Ok, Self::Error> {
771        Err(XmlValueSerializerError::InvalidChildDeserialization)
772    }
773}
774
775impl<'de> Deserializer<'de> for &'de XmlChild {
776    type Error = XmlValueDeserializerError;
777
778    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
779    where
780        V: Visitor<'de>,
781    {
782        match self {
783            XmlChild::Text(xml_text) => xml_text.deserialize_any(visitor),
784            XmlChild::CData(xml_cdata) => xml_cdata.deserialize_any(visitor),
785            XmlChild::Element(xml_element) => xml_element.deserialize_any(visitor),
786            XmlChild::PI(xml_pi) => xml_pi.deserialize_any(visitor),
787            XmlChild::Comment(xml_comment) => xml_comment.deserialize_any(visitor),
788            XmlChild::None => visitor.visit_none(),
789        }
790    }
791
792    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
793    where
794        V: Visitor<'de>,
795    {
796        match self {
797            XmlChild::Text(xml_text) => xml_text.deserialize_seq(visitor),
798            XmlChild::CData(xml_cdata) => xml_cdata.deserialize_seq(visitor),
799            XmlChild::Element(xml_element) => xml_element.deserialize_seq(visitor),
800            XmlChild::PI(xml_pi) => xml_pi.deserialize_seq(visitor),
801            XmlChild::Comment(xml_comment) => xml_comment.deserialize_seq(visitor),
802            XmlChild::None => visitor.visit_none(),
803        }
804    }
805}
806
807/// An XML element.
808#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
809#[non_exhaustive]
810pub struct XmlElement {
811    /// The name of the element.
812    pub name: ExpandedName<'static>,
813    /// The attributes of the element.
814    pub attributes: Vec<XmlAttribute>,
815    /// The children of the element.
816    pub children: XmlSeq<XmlChild>,
817    /// Whether to enforce the prefix of the element.
818    pub enforce_prefix: IncludePrefix,
819    /// The preferred prefix of the element.
820    pub preferred_prefix: Option<Prefix<'static>>,
821}
822
823impl XmlElement {
824    /// Creates a new XML element.
825    pub fn new<T: Into<ExpandedName<'static>>>(name: T) -> Self {
826        Self {
827            name: name.into(),
828            attributes: Vec::new(),
829            children: XmlSeq::new(),
830            enforce_prefix: IncludePrefix::default(),
831            preferred_prefix: None,
832        }
833    }
834
835    /// Adds an attribute to the element.
836    pub fn with_attribute<T: Into<XmlAttribute>>(mut self, attribute: T) -> Self {
837        self.attributes.push(attribute.into());
838        self
839    }
840
841    /// Adds multiple attributes to the element.
842    pub fn with_attributes<U: Into<XmlAttribute>, T: IntoIterator<Item = U>>(
843        mut self,
844        attributes: T,
845    ) -> Self {
846        self.attributes
847            .extend(attributes.into_iter().map(Into::into));
848        self
849    }
850
851    /// Adds a child to the element.
852    pub fn with_child<T: Into<XmlChild>>(mut self, child: T) -> Self {
853        self.children.values.push(child.into());
854        self
855    }
856
857    /// Adds multiple children to the element.
858    pub fn with_children<U: Into<XmlChild>, T: IntoIterator<Item = U>>(
859        mut self,
860        children: T,
861    ) -> Self {
862        self.children
863            .values
864            .extend(children.into_iter().map(Into::into));
865        self
866    }
867}
868
869impl Serialize for XmlElement {
870    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
871    where
872        S: Serializer,
873    {
874        let mut element = serializer.serialize_element(&self.name)?;
875        for attr in &self.attributes {
876            element.serialize_attribute(attr)?;
877        }
878
879        if self.children.values.is_empty() {
880            return element.end();
881        }
882
883        let mut children = element.serialize_children()?;
884        for child in &self.children.values {
885            children.serialize_child(child)?;
886        }
887        children.end()
888    }
889}
890
891struct XmlElementVisitor<'v> {
892    marker: ::core::marker::PhantomData<XmlElement>,
893    lifetime: ::core::marker::PhantomData<&'v ()>,
894}
895impl XmlElementVisitor<'_> {
896    fn new() -> Self {
897        Self {
898            marker: ::core::marker::PhantomData,
899            lifetime: ::core::marker::PhantomData,
900        }
901    }
902}
903
904impl<'v> crate::de::Visitor<'v> for XmlElementVisitor<'v> {
905    type Value = XmlElement;
906    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
907        formatter.write_str("an element")
908    }
909
910    fn visit_element<A>(self, mut element: A) -> Result<Self::Value, A::Error>
911    where
912        A: de::ElementAccess<'v>,
913    {
914        let name = element.name().clone().into_owned();
915        let attributes = iter::from_fn(|| match element.next_attribute::<XmlAttribute>() {
916            Ok(Some(attr)) => Some(Ok(attr)),
917            Ok(None) => None,
918            Err(err) => Some(Err(err)),
919        })
920        .collect::<Result<_, _>>()?;
921        let mut children = element.children()?;
922
923        let children = iter::from_fn(|| match children.next_element::<XmlChild>() {
924            Ok(Some(child)) => Some(Ok(child)),
925            Ok(None) => None,
926            Err(err) => Some(Err(err)),
927        })
928        .collect::<Result<_, _>>()?;
929
930        Ok(XmlElement {
931            name,
932            attributes,
933            children,
934            preferred_prefix: None,
935            enforce_prefix: crate::ser::IncludePrefix::Never,
936        })
937    }
938}
939
940impl<'de> crate::de::Deserialize<'de> for XmlElement {
941    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
942    where
943        D: crate::de::Deserializer<'de>,
944    {
945        deserializer.deserialize_any(XmlElementVisitor::new())
946    }
947}
948
949impl ser::SerializeAttributes for &mut XmlElement {
950    type Ok = ();
951
952    type Error = XmlValueSerializerError;
953
954    fn serialize_attribute<A: SerializeAttribute>(
955        &mut self,
956        a: &A,
957    ) -> Result<Self::Ok, Self::Error> {
958        a.serialize_attribute(self)?;
959
960        Ok(())
961    }
962}
963
964impl ser::AttributeSerializer for &mut &mut XmlElement {
965    type Ok = ();
966    type Error = XmlValueSerializerError;
967
968    type SerializeAttribute<'a>
969        = XmlAttributeBuilder<'a>
970    where
971        Self: 'a;
972
973    fn serialize_attribute(
974        &mut self,
975        name: &'_ ExpandedName<'_>,
976    ) -> Result<Self::SerializeAttribute<'_>, Self::Error> {
977        Ok(XmlAttributeBuilder {
978            name: name.clone().into_owned(),
979            write_to: &mut self.attributes,
980            should_enforce: IncludePrefix::default(),
981            preferred_prefix: None,
982        })
983    }
984
985    fn serialize_none(&mut self) -> Result<Self::Ok, Self::Error> {
986        Ok(())
987    }
988}
989
990impl<'s> ser::SerializeElement for &'s mut XmlElement {
991    type SerializeElementChildren = &'s mut XmlSeq<XmlChild>;
992
993    fn include_prefix(&mut self, should_enforce: IncludePrefix) -> Result<Self::Ok, Self::Error> {
994        self.enforce_prefix = should_enforce;
995        Ok(())
996    }
997
998    fn preferred_prefix(
999        &mut self,
1000        preferred_prefix: Option<crate::Prefix<'_>>,
1001    ) -> Result<Self::Ok, Self::Error> {
1002        self.preferred_prefix = preferred_prefix.map(Prefix::into_owned);
1003        Ok(())
1004    }
1005
1006    fn serialize_children(self) -> Result<Self::SerializeElementChildren, Self::Error> {
1007        Ok(&mut self.children)
1008    }
1009
1010    fn end(self) -> Result<Self::Ok, Self::Error> {
1011        Ok(())
1012    }
1013}
1014
1015struct XmlElementAccess<'de, 'i> {
1016    element: &'de XmlElement,
1017    attribute_index: usize,
1018    write_attribute_index_to: Option<&'i mut usize>,
1019}
1020
1021impl Drop for XmlElementAccess<'_, '_> {
1022    fn drop(&mut self) {
1023        if let Some(write_to) = self.write_attribute_index_to.as_mut() {
1024            **write_to = self.attribute_index;
1025        }
1026    }
1027}
1028
1029impl<'de> AttributesAccess<'de> for XmlElementAccess<'de, '_> {
1030    type Error = XmlValueDeserializerError;
1031
1032    type SubAccess<'a>
1033        = XmlElementAccess<'de, 'a>
1034    where
1035        Self: 'a;
1036
1037    fn next_attribute<T>(&mut self) -> Result<Option<T>, Self::Error>
1038    where
1039        T: Deserialize<'de>,
1040    {
1041        let Some(attribute) = self.element.attributes.get(self.attribute_index) else {
1042            return Ok(None);
1043        };
1044        let attribute = T::deserialize(attribute)?;
1045        self.attribute_index += 1;
1046        Ok(Some(attribute))
1047    }
1048
1049    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
1050        Ok(XmlElementAccess {
1051            attribute_index: self.attribute_index,
1052            element: self.element,
1053            write_attribute_index_to: Some(&mut self.attribute_index),
1054        })
1055    }
1056}
1057
1058impl<'de> ElementAccess<'de> for XmlElementAccess<'de, '_> {
1059    type ChildrenAccess = XmlSeqAccess<'de, 'static, XmlChild>;
1060
1061    fn name(&self) -> ExpandedName<'_> {
1062        self.element.name.clone()
1063    }
1064
1065    fn children(self) -> Result<Self::ChildrenAccess, Self::Error> {
1066        Ok(XmlSeqAccess {
1067            seq: &self.element.children,
1068            index: 0,
1069            write_index_to: None,
1070        })
1071    }
1072}
1073
1074impl<'de> Deserializer<'de> for &'de XmlElement {
1075    type Error = XmlValueDeserializerError;
1076    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1077    where
1078        V: Visitor<'de>,
1079    {
1080        visitor.visit_element(XmlElementAccess {
1081            element: self,
1082            attribute_index: 0,
1083            write_attribute_index_to: None,
1084        })
1085    }
1086
1087    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1088    where
1089        V: Visitor<'de>,
1090    {
1091        self.deserialize_any(visitor)
1092    }
1093}
1094
1095/// An XML attribute.
1096#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1097#[non_exhaustive]
1098pub struct XmlAttribute {
1099    /// The name of the attribute.
1100    pub name: ExpandedName<'static>,
1101    /// The value of the attribute.
1102    pub value: String,
1103}
1104
1105impl XmlAttribute {
1106    /// Creates a new XML attribute.
1107    pub fn new<T: Into<ExpandedName<'static>>, U: Into<String>>(name: T, value: U) -> Self {
1108        Self {
1109            name: name.into(),
1110            value: value.into(),
1111        }
1112    }
1113}
1114
1115impl SerializeAttribute for XmlAttribute {
1116    fn serialize_attribute<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
1117    where
1118        S: AttributeSerializer,
1119    {
1120        let attr = serializer.serialize_attribute(&self.name)?;
1121
1122        attr.end(self.value.as_str())
1123    }
1124}
1125
1126struct XmlAttributeVisitor<'v> {
1127    marker: ::core::marker::PhantomData<XmlAttribute>,
1128    lifetime: ::core::marker::PhantomData<&'v ()>,
1129}
1130
1131impl XmlAttributeVisitor<'_> {
1132    fn new() -> Self {
1133        Self {
1134            marker: ::core::marker::PhantomData,
1135            lifetime: ::core::marker::PhantomData,
1136        }
1137    }
1138}
1139
1140impl<'v> crate::de::Visitor<'v> for XmlAttributeVisitor<'v> {
1141    type Value = XmlAttribute;
1142    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1143        formatter.write_str("an attribute")
1144    }
1145
1146    fn visit_attribute<A>(self, attribute: A) -> Result<Self::Value, A::Error>
1147    where
1148        A: de::AttributeAccess<'v>,
1149    {
1150        Ok(XmlAttribute {
1151            name: attribute.name().clone().into_owned(),
1152            value: attribute.value().to_owned(),
1153        })
1154    }
1155}
1156
1157impl<'a> de::AttributeAccess<'a> for &'a XmlAttribute {
1158    type Error = XmlValueDeserializerError;
1159
1160    fn name(&self) -> ExpandedName<'_> {
1161        self.name.clone()
1162    }
1163
1164    fn value(&self) -> &str {
1165        &self.value
1166    }
1167}
1168
1169impl<'de> crate::de::Deserialize<'de> for XmlAttribute {
1170    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1171    where
1172        D: crate::de::Deserializer<'de>,
1173    {
1174        deserializer.deserialize_any(XmlAttributeVisitor::new())
1175    }
1176}
1177
1178/// Builder used when serializing to an [`XmlAttribute``].
1179pub struct XmlAttributeBuilder<'a> {
1180    name: ExpandedName<'static>,
1181    write_to: &'a mut Vec<XmlAttribute>,
1182    should_enforce: IncludePrefix,
1183    preferred_prefix: Option<Prefix<'static>>,
1184}
1185
1186impl<'a> XmlAttributeBuilder<'a> {
1187    /// Creates a new [`XmlAttributeBuilder`].
1188    pub fn new(name: ExpandedName<'static>, write_to: &'a mut Vec<XmlAttribute>) -> Self {
1189        Self {
1190            name,
1191            write_to,
1192            should_enforce: IncludePrefix::default(),
1193            preferred_prefix: None,
1194        }
1195    }
1196}
1197
1198impl SerializeAttributeAccess for XmlAttributeBuilder<'_> {
1199    type Ok = ();
1200
1201    type Error = XmlValueSerializerError;
1202
1203    fn include_prefix(&mut self, should_enforce: IncludePrefix) -> Result<Self::Ok, Self::Error> {
1204        self.should_enforce = should_enforce;
1205        Ok(())
1206    }
1207
1208    fn preferred_prefix(
1209        &mut self,
1210        preferred_prefix: Option<crate::Prefix<'_>>,
1211    ) -> Result<Self::Ok, Self::Error> {
1212        self.preferred_prefix = preferred_prefix.map(|p| p.into_owned());
1213        Ok(())
1214    }
1215
1216    fn end<S: AsRef<str>>(self, value: S) -> Result<Self::Ok, Self::Error> {
1217        self.write_to.push(XmlAttribute {
1218            name: self.name,
1219            value: value.as_ref().to_string(),
1220        });
1221        Ok(())
1222    }
1223}
1224
1225impl<'de> crate::de::Deserializer<'de> for &'de XmlAttribute {
1226    type Error = XmlValueDeserializerError;
1227
1228    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1229    where
1230        V: Visitor<'de>,
1231    {
1232        visitor.visit_attribute(self)
1233    }
1234
1235    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1236    where
1237        V: Visitor<'de>,
1238    {
1239        visitor.visit_attribute(self)
1240    }
1241}
1242
1243/// A sequence of XML elements.
1244#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1245#[non_exhaustive]
1246pub struct XmlSeq<T> {
1247    values: Vec<T>,
1248}
1249
1250impl<T> IntoIterator for XmlSeq<T> {
1251    type Item = T;
1252    type IntoIter = std::vec::IntoIter<T>;
1253    fn into_iter(self) -> Self::IntoIter {
1254        self.values.into_iter()
1255    }
1256}
1257
1258impl<T> FromIterator<T> for XmlSeq<T> {
1259    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
1260        Self {
1261            values: iter.into_iter().collect(),
1262        }
1263    }
1264}
1265
1266impl<T> From<Vec<T>> for XmlSeq<T> {
1267    fn from(value: Vec<T>) -> Self {
1268        Self::from_vec(value)
1269    }
1270}
1271
1272impl<T> XmlSeq<T> {
1273    /// Creates a new empty sequence.
1274    pub fn new() -> Self {
1275        Self::from_vec(Vec::new())
1276    }
1277
1278    fn from_vec(values: Vec<T>) -> Self {
1279        Self { values }
1280    }
1281
1282    /// Pushes a value onto the sequence.
1283    pub fn push(&mut self, value: T) {
1284        self.values.push(value);
1285    }
1286}
1287
1288impl<T> Default for XmlSeq<T> {
1289    fn default() -> Self {
1290        Self::new()
1291    }
1292}
1293
1294impl<T: Serialize> Serialize for XmlSeq<T> {
1295    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1296    where
1297        S: crate::ser::Serializer,
1298    {
1299        let mut seq = serializer.serialize_seq()?;
1300        for item in self.values.iter() {
1301            seq.serialize_element(item)?;
1302        }
1303
1304        seq.end()
1305    }
1306}
1307
1308struct XmlSeqVisitor<'v, T> {
1309    marker: ::core::marker::PhantomData<XmlSeq<T>>,
1310    lifetime: ::core::marker::PhantomData<&'v ()>,
1311}
1312
1313impl<T> XmlSeqVisitor<'_, T> {
1314    fn new() -> Self {
1315        Self {
1316            marker: ::core::marker::PhantomData,
1317            lifetime: ::core::marker::PhantomData,
1318        }
1319    }
1320}
1321
1322impl<'v, T: Deserialize<'v>> crate::de::Visitor<'v> for XmlSeqVisitor<'v, T> {
1323    type Value = XmlSeq<T>;
1324    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1325        formatter.write_str("a sequence of values")
1326    }
1327    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1328    where
1329        A: crate::de::SeqAccess<'v>,
1330    {
1331        let mut values = Vec::new();
1332        while let Some(value) = seq.next_element()? {
1333            values.push(value);
1334        }
1335        Ok(XmlSeq { values })
1336    }
1337}
1338
1339impl crate::ser::SerializeSeq for &mut XmlSeq<XmlValue> {
1340    type Ok = ();
1341
1342    type Error = XmlValueSerializerError;
1343
1344    fn serialize_element<V: Serialize>(&mut self, v: &V) -> Result<Self::Ok, Self::Error> {
1345        v.serialize(self)
1346    }
1347
1348    fn end(self) -> Result<Self::Ok, Self::Error> {
1349        Ok(())
1350    }
1351}
1352
1353impl crate::ser::SerializeSeq for &mut XmlSeq<XmlChild> {
1354    type Ok = ();
1355
1356    type Error = XmlValueSerializerError;
1357
1358    fn serialize_element<V: Serialize>(&mut self, v: &V) -> Result<Self::Ok, Self::Error> {
1359        v.serialize(self)?;
1360        Ok(())
1361    }
1362
1363    fn end(self) -> Result<Self::Ok, Self::Error> {
1364        Ok(())
1365    }
1366}
1367
1368impl crate::ser::SerializeChildren for &mut XmlSeq<XmlChild> {
1369    type Ok = ();
1370
1371    type Error = XmlValueSerializerError;
1372
1373    fn serialize_child<V: Serialize>(&mut self, v: &V) -> Result<Self::Ok, Self::Error> {
1374        v.serialize(self)?;
1375        Ok(())
1376    }
1377}
1378
1379impl crate::ser::SerializeElementChildren for &mut XmlSeq<XmlChild> {
1380    fn end(self) -> Result<Self::Ok, Self::Error> {
1381        Ok(())
1382    }
1383}
1384
1385struct XmlSeqAccess<'de, 'i, T> {
1386    seq: &'de XmlSeq<T>,
1387    index: usize,
1388    write_index_to: Option<&'i mut usize>,
1389}
1390
1391impl<'de, T> XmlSeqAccess<'de, '_, T> {
1392    pub fn new(seq: &'de XmlSeq<T>) -> Self {
1393        Self {
1394            seq,
1395            index: 0,
1396            write_index_to: None,
1397        }
1398    }
1399}
1400
1401impl<T> Drop for XmlSeqAccess<'_, '_, T> {
1402    fn drop(&mut self) {
1403        if let Some(write_index_to) = self.write_index_to.as_mut() {
1404            **write_index_to = self.index;
1405        }
1406    }
1407}
1408
1409// One would think that these impls for XmlSeqAccess that take XmlValue and XmlChild should be unified using a generic impl, but this does not appear to be possible due to an error mentioning limits in the borrow checker.
1410// I've fought the borrow checker for a long time and lost, so for now, these are separate impls.
1411// If you want to take a stab at unifying these, be my guest.
1412impl<'de> de::SeqAccess<'de> for XmlSeqAccess<'de, '_, XmlChild> {
1413    type Error = XmlValueDeserializerError;
1414    type SubAccess<'g>
1415        = XmlSeqAccess<'de, 'g, XmlChild>
1416    where
1417        Self: 'g;
1418    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
1419    where
1420        T: Deserialize<'de>,
1421    {
1422        let Some(value) = self.seq.values.get(self.index) else {
1423            return Ok(None);
1424        };
1425        let value = T::deserialize(value)?;
1426        self.index += 1;
1427        Ok(Some(value))
1428    }
1429
1430    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
1431    where
1432        T: Deserialize<'de>,
1433    {
1434        T::deserialize_seq(self).map(Some)
1435    }
1436
1437    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
1438        Ok(XmlSeqAccess {
1439            seq: self.seq,
1440            index: self.index,
1441            write_index_to: Some(&mut self.index),
1442        })
1443    }
1444}
1445
1446impl<'de> de::SeqAccess<'de> for XmlSeqAccess<'de, '_, XmlValue> {
1447    type Error = XmlValueDeserializerError;
1448    type SubAccess<'g>
1449        = XmlSeqAccess<'de, 'g, XmlValue>
1450    where
1451        Self: 'g;
1452    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
1453    where
1454        T: Deserialize<'de>,
1455    {
1456        let Some(value) = self.seq.values.get(self.index) else {
1457            return Ok(None);
1458        };
1459        let value = T::deserialize(value)?;
1460        self.index += 1;
1461        Ok(Some(value))
1462    }
1463
1464    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
1465    where
1466        T: Deserialize<'de>,
1467    {
1468        T::deserialize_seq(self).map(Some)
1469    }
1470
1471    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
1472        Ok(XmlSeqAccess {
1473            seq: self.seq,
1474            index: self.index,
1475            write_index_to: Some(&mut self.index),
1476        })
1477    }
1478}
1479
1480impl<'de, T: Deserialize<'de>> Deserialize<'de> for XmlSeq<T> {
1481    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1482    where
1483        D: crate::de::Deserializer<'de>,
1484    {
1485        deserializer.deserialize_seq(XmlSeqVisitor::new())
1486    }
1487}
1488
1489impl<'de> Deserializer<'de> for &mut XmlSeqAccess<'de, '_, XmlValue> {
1490    type Error = XmlValueDeserializerError;
1491    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1492    where
1493        V: Visitor<'de>,
1494    {
1495        visitor.visit_seq(self)
1496    }
1497
1498    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1499    where
1500        V: Visitor<'de>,
1501    {
1502        self.deserialize_any(visitor)
1503    }
1504}
1505
1506impl<'de> Deserializer<'de> for &mut XmlSeqAccess<'de, '_, XmlChild> {
1507    type Error = XmlValueDeserializerError;
1508    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1509    where
1510        V: Visitor<'de>,
1511    {
1512        visitor.visit_seq(self)
1513    }
1514
1515    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1516    where
1517        V: Visitor<'de>,
1518    {
1519        self.deserialize_any(visitor)
1520    }
1521}
1522
1523/// A processing instruction.
1524#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1525#[non_exhaustive]
1526pub struct XmlPI(pub Vec<u8>);
1527
1528impl XmlPI {
1529    /// Creates a new processing instruction.
1530    pub fn new<T: Into<Vec<u8>>>(data: T) -> Self {
1531        Self(data.into())
1532    }
1533}
1534
1535impl Serialize for XmlPI {
1536    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1537    where
1538        S: crate::ser::Serializer,
1539    {
1540        serializer.serialize_pi(&self.0)
1541    }
1542}
1543
1544struct XmlPIVisitor<'v> {
1545    marker: ::core::marker::PhantomData<XmlPI>,
1546    lifetime: ::core::marker::PhantomData<&'v ()>,
1547}
1548
1549impl XmlPIVisitor<'_> {
1550    fn new() -> Self {
1551        Self {
1552            marker: ::core::marker::PhantomData,
1553            lifetime: ::core::marker::PhantomData,
1554        }
1555    }
1556}
1557
1558impl<'v> crate::de::Visitor<'v> for XmlPIVisitor<'v> {
1559    type Value = XmlPI;
1560
1561    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1562        formatter.write_str("a comment")
1563    }
1564
1565    fn visit_pi<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
1566    where
1567        E: de::Error,
1568    {
1569        Ok(XmlPI(value.as_ref().to_vec()))
1570    }
1571}
1572
1573impl<'de> Deserialize<'de> for XmlPI {
1574    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1575    where
1576        D: Deserializer<'de>,
1577    {
1578        deserializer.deserialize_any(XmlPIVisitor::new())
1579    }
1580}
1581
1582impl<'de> Deserializer<'de> for &'de XmlPI {
1583    type Error = XmlValueDeserializerError;
1584    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1585    where
1586        V: Visitor<'de>,
1587    {
1588        visitor.visit_pi(&self.0)
1589    }
1590
1591    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1592    where
1593        V: Visitor<'de>,
1594    {
1595        self.deserialize_any(visitor)
1596    }
1597}
1598
1599/// Represents an XML declaration.
1600#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1601#[non_exhaustive]
1602pub struct XmlDecl {
1603    /// The version of the XML document.
1604    pub version: String,
1605    /// The encoding of the XML document.
1606    pub encoding: Option<String>,
1607    /// The standalone status of the XML document.
1608    pub standalone: Option<String>,
1609}
1610
1611impl XmlDecl {
1612    /// Creates a new XML declaration.
1613    pub fn new<T: AsRef<str>>(version: T, encoding: Option<T>, standalone: Option<T>) -> Self {
1614        Self {
1615            version: version.as_ref().to_string(),
1616            encoding: encoding.map(|e| e.as_ref().to_string()),
1617            standalone: standalone.map(|s| s.as_ref().to_string()),
1618        }
1619    }
1620}
1621
1622impl Serialize for XmlDecl {
1623    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1624        serializer.serialize_decl(
1625            self.version.deref(),
1626            self.encoding.as_deref(),
1627            self.standalone.as_deref(),
1628        )
1629    }
1630}
1631
1632struct XmlDeclVisitor<'v> {
1633    marker: ::core::marker::PhantomData<XmlDecl>,
1634    lifetime: ::core::marker::PhantomData<&'v ()>,
1635}
1636
1637impl XmlDeclVisitor<'_> {
1638    fn new() -> Self {
1639        Self {
1640            marker: ::core::marker::PhantomData,
1641            lifetime: ::core::marker::PhantomData,
1642        }
1643    }
1644}
1645
1646impl<'v> crate::de::Visitor<'v> for XmlDeclVisitor<'v> {
1647    type Value = XmlDecl;
1648    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1649        formatter.write_str("a declaration")
1650    }
1651
1652    fn visit_decl<E, V: AsRef<[u8]>>(
1653        self,
1654        version: V,
1655        encoding: Option<V>,
1656        standalone: Option<V>,
1657    ) -> Result<Self::Value, E>
1658    where
1659        E: de::Error,
1660    {
1661        Ok(XmlDecl {
1662            version: String::from_utf8_lossy(version.as_ref()).to_string(),
1663            encoding: encoding.map(|e| String::from_utf8_lossy(e.as_ref()).to_string()),
1664            standalone: standalone.map(|e| String::from_utf8_lossy(e.as_ref()).to_string()),
1665        })
1666    }
1667}
1668
1669impl<'de> Deserialize<'de> for XmlDecl {
1670    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1671    where
1672        D: Deserializer<'de>,
1673    {
1674        deserializer.deserialize_any(XmlDeclVisitor::new())
1675    }
1676}
1677
1678impl<'de> Deserializer<'de> for &'de XmlDecl {
1679    type Error = XmlValueDeserializerError;
1680    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1681    where
1682        V: Visitor<'de>,
1683    {
1684        visitor.visit_decl(
1685            &self.version,
1686            self.encoding.as_ref(),
1687            self.standalone.as_ref(),
1688        )
1689    }
1690
1691    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1692    where
1693        V: Visitor<'de>,
1694    {
1695        self.deserialize_any(visitor)
1696    }
1697}
1698
1699/// XML Comment
1700#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1701#[non_exhaustive]
1702pub struct XmlComment(pub Vec<u8>);
1703
1704impl XmlComment {
1705    /// Creates a new XML comment.
1706    pub fn new<T: Into<Vec<u8>>>(comment: T) -> Self {
1707        Self(comment.into())
1708    }
1709}
1710
1711impl Serialize for XmlComment {
1712    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1713    where
1714        S: Serializer,
1715    {
1716        serializer.serialize_comment(&self.0)
1717    }
1718}
1719
1720struct XmlCommentVisitor<'v> {
1721    marker: ::core::marker::PhantomData<XmlComment>,
1722    lifetime: ::core::marker::PhantomData<&'v ()>,
1723}
1724
1725impl XmlCommentVisitor<'_> {
1726    pub fn new() -> Self {
1727        Self {
1728            marker: ::core::marker::PhantomData,
1729            lifetime: ::core::marker::PhantomData,
1730        }
1731    }
1732}
1733
1734impl<'v> crate::de::Visitor<'v> for XmlCommentVisitor<'v> {
1735    type Value = XmlComment;
1736
1737    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1738        formatter.write_str("a comment")
1739    }
1740
1741    fn visit_comment<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
1742    where
1743        E: de::Error,
1744    {
1745        Ok(XmlComment(value.as_ref().to_vec()))
1746    }
1747}
1748
1749impl<'de> Deserialize<'de> for XmlComment {
1750    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1751    where
1752        D: Deserializer<'de>,
1753    {
1754        deserializer.deserialize_any(XmlCommentVisitor::new())
1755    }
1756}
1757
1758impl<'de> Deserializer<'de> for &'de XmlComment {
1759    type Error = XmlValueDeserializerError;
1760    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1761    where
1762        V: Visitor<'de>,
1763    {
1764        visitor.visit_comment(&self.0)
1765    }
1766    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1767    where
1768        V: Visitor<'de>,
1769    {
1770        self.deserialize_any(visitor)
1771    }
1772}
1773
1774/// A doctype declaration.
1775#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1776#[non_exhaustive]
1777pub struct XmlDoctype(pub Vec<u8>);
1778
1779impl XmlDoctype {
1780    /// Creates a new doctype declaration.
1781    pub fn new<T: Into<Vec<u8>>>(value: T) -> Self {
1782        Self(value.into())
1783    }
1784}
1785
1786impl Serialize for XmlDoctype {
1787    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1788    where
1789        S: Serializer,
1790    {
1791        serializer.serialize_doctype(&self.0)
1792    }
1793}
1794
1795struct XmlDoctypeVisitor<'v> {
1796    marker: ::core::marker::PhantomData<XmlDoctype>,
1797    lifetime: ::core::marker::PhantomData<&'v ()>,
1798}
1799
1800impl XmlDoctypeVisitor<'_> {
1801    pub fn new() -> Self {
1802        Self {
1803            marker: ::core::marker::PhantomData,
1804            lifetime: ::core::marker::PhantomData,
1805        }
1806    }
1807}
1808
1809impl<'v> crate::de::Visitor<'v> for XmlDoctypeVisitor<'v> {
1810    type Value = XmlDoctype;
1811
1812    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1813        formatter.write_str("a comment")
1814    }
1815
1816    fn visit_doctype<E, V: AsRef<[u8]>>(self, value: V) -> Result<Self::Value, E>
1817    where
1818        E: de::Error,
1819    {
1820        Ok(XmlDoctype(value.as_ref().to_vec()))
1821    }
1822}
1823
1824impl<'de> Deserialize<'de> for XmlDoctype {
1825    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1826    where
1827        D: Deserializer<'de>,
1828    {
1829        deserializer.deserialize_any(XmlDoctypeVisitor::new())
1830    }
1831}
1832
1833impl<'de> Deserializer<'de> for &'de XmlDoctype {
1834    type Error = XmlValueDeserializerError;
1835
1836    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1837    where
1838        V: Visitor<'de>,
1839    {
1840        visitor.visit_doctype(&self.0)
1841    }
1842
1843    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1844    where
1845        V: Visitor<'de>,
1846    {
1847        self.deserialize_any(visitor)
1848    }
1849}
1850
1851/// Error type for serializing XML values.
1852#[derive(Debug, thiserror::Error)]
1853pub enum XmlValueSerializerError {
1854    /// Error for when a custom error occurs during serialization.
1855    #[error("Custom error: {0}")]
1856    Custom(String),
1857    /// Error for when an invalid child deserialization occurs.
1858    #[error("Invalid child deserialization")]
1859    InvalidChildDeserialization,
1860}
1861
1862impl ser::Error for XmlValueSerializerError {
1863    fn custom<T>(msg: T) -> Self
1864    where
1865        T: std::fmt::Display,
1866    {
1867        Self::Custom(msg.to_string())
1868    }
1869}
1870
1871/// Error type for deserializing XML values.
1872#[derive(Debug, thiserror::Error)]
1873pub enum XmlValueDeserializerError {
1874    /// Error for when an unexpected visit occurs during deserialization.
1875    #[error("Unexpected visit: {0}")]
1876    UnexpectedVisit(crate::de::Unexpected),
1877    /// Error for when a custom error occurs during deserialization.
1878    #[error("Custom error: {0}")]
1879    Custom(String),
1880    /// Error for when a name is expected to be a certain value, but it is not.
1881    #[error("Wrong name: {actual:?}, expected: {expected:?}")]
1882    WrongName {
1883        /// The actual name that was encountered.
1884        actual: Box<ExpandedName<'static>>,
1885        /// The expected name.
1886        expected: Box<ExpandedName<'static>>,
1887    },
1888    /// Error for when a field is missing.
1889    #[error("Missing field: {0}")]
1890    MissingField(String),
1891    /// Error for when a child cannot be identified, and ignoring it is not allowed.
1892    #[error("Unknown child")]
1893    UnknownChild,
1894    /// Error for when a string is invalid for the type.
1895    #[error("Invalid string")]
1896    InvalidString,
1897    /// Error for when a type has no possible variants to deserialize into.
1898    #[error("No possible variant")]
1899    NoPossibleVariant {
1900        /// The name of the type that has no possible variants.
1901        ident: String,
1902    },
1903    /// Error for when a type is missing data that is required to deserialize it.
1904    #[error("Missing data")]
1905    MissingData,
1906}
1907
1908impl de::Error for XmlValueDeserializerError {
1909    fn custom<T>(msg: T) -> Self
1910    where
1911        T: std::fmt::Display,
1912    {
1913        Self::Custom(msg.to_string())
1914    }
1915
1916    fn wrong_name(name: &ExpandedName<'_>, expected: &ExpandedName<'_>) -> Self {
1917        Self::WrongName {
1918            actual: Box::new(name.clone().into_owned()),
1919            expected: Box::new(expected.clone().into_owned()),
1920        }
1921    }
1922
1923    fn unexpected_visit<T>(unexpected: de::Unexpected, _expected: &T) -> Self {
1924        Self::UnexpectedVisit(unexpected)
1925    }
1926
1927    fn missing_field(field: &str) -> Self {
1928        Self::MissingField(field.to_string())
1929    }
1930
1931    fn no_possible_variant(ident: &str) -> Self {
1932        Self::NoPossibleVariant {
1933            ident: ident.to_string(),
1934        }
1935    }
1936
1937    fn missing_data() -> Self {
1938        Self::MissingData
1939    }
1940
1941    fn unknown_child() -> Self {
1942        Self::UnknownChild
1943    }
1944
1945    fn invalid_string() -> Self {
1946        Self::InvalidString
1947    }
1948}
xmlity/types/value.rs

xmlity/types/
value.rs
