xmlity/value/
deserialize.rs

1//! This module contains the deserialization implementations for the XML value types including visitors.
2use crate::{
3    de::{self, DeserializeContext, SeqAccess, Visitor},
4    Deserialize, Deserializer, ExpandedName, Prefix, XmlNamespace,
5};
6use core::marker::PhantomData;
7
8use super::*;
9
10impl<'de> Deserialize<'de> for XmlValue {
11    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
12    where
13        D: Deserializer<'de>,
14    {
15        XmlValueWithoutSeq::deserialize(deserializer).map(From::from)
16    }
17
18    fn deserialize_seq<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
19        deserializer
20            .deserialize_seq(IteratorVisitor::<_, XmlSeq<XmlValueWithoutSeq>>::default())
21            .map(|mut a| match a.values.len() {
22                0 => XmlValue::None,
23                1 => a.values.pop_front().expect("Just checked.").into(),
24                _ => XmlValue::Seq(a.values.into_iter().map(From::from).collect()),
25            })
26    }
27}
28
29impl<'de> Deserialize<'de> for XmlValueWithoutSeq {
30    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
31    where
32        D: Deserializer<'de>,
33    {
34        struct __Visitor<'v> {
35            marker: PhantomData<XmlValueWithoutSeq>,
36            lifetime: PhantomData<&'v ()>,
37        }
38
39        impl<'v> crate::de::Visitor<'v> for __Visitor<'v> {
40            type Value = XmlValueWithoutSeq;
41
42            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
43                formatter.write_str("a comment")
44            }
45
46            fn visit_text<E, V>(self, value: V) -> Result<Self::Value, E>
47            where
48                E: de::Error,
49                V: de::XmlText<'v>,
50            {
51                XmlTextVisitor::new()
52                    .visit_text(value)
53                    .map(XmlValueWithoutSeq::Text)
54            }
55
56            fn visit_cdata<E, V>(self, value: V) -> Result<Self::Value, E>
57            where
58                E: de::Error,
59                V: de::XmlCData<'v>,
60            {
61                XmlCDataVisitor::new()
62                    .visit_cdata(value)
63                    .map(XmlValueWithoutSeq::CData)
64            }
65
66            fn visit_element<A>(self, element: A) -> Result<Self::Value, A::Error>
67            where
68                A: de::ElementAccess<'v>,
69            {
70                XmlElementVisitor::new()
71                    .visit_element(element)
72                    .map(XmlValueWithoutSeq::Element)
73            }
74
75            fn visit_pi<E, V>(self, value: V) -> Result<Self::Value, E>
76            where
77                E: de::Error,
78                V: de::XmlProcessingInstruction,
79            {
80                XmlProcessingInstructionVisitor::new()
81                    .visit_pi(value)
82                    .map(XmlValueWithoutSeq::PI)
83            }
84
85            fn visit_decl<E, V>(self, declaration: V) -> Result<Self::Value, E>
86            where
87                E: de::Error,
88                V: de::XmlDeclaration,
89            {
90                XmlDeclVisitor::new()
91                    .visit_decl(declaration)
92                    .map(XmlValueWithoutSeq::Decl)
93            }
94
95            fn visit_comment<E, V>(self, comment: V) -> Result<Self::Value, E>
96            where
97                E: de::Error,
98                V: de::XmlComment<'v>,
99            {
100                XmlCommentVisitor::new()
101                    .visit_comment(comment)
102                    .map(XmlValueWithoutSeq::Comment)
103            }
104
105            fn visit_doctype<E, V>(self, value: V) -> Result<Self::Value, E>
106            where
107                E: de::Error,
108                V: de::XmlDoctype<'v>,
109            {
110                XmlDoctypeVisitor::new()
111                    .visit_doctype(value)
112                    .map(XmlValueWithoutSeq::Doctype)
113            }
114
115            fn visit_none<E>(self) -> Result<Self::Value, E>
116            where
117                E: de::Error,
118            {
119                Ok(XmlValueWithoutSeq::None)
120            }
121        }
122
123        deserializer.deserialize_any(__Visitor {
124            lifetime: PhantomData,
125            marker: PhantomData,
126        })
127    }
128}
129
130// Text
131
132/// A visitor for deserializing to [`XmlText`].
133pub struct XmlTextVisitor<'v> {
134    marker: PhantomData<XmlText>,
135    lifetime: PhantomData<&'v ()>,
136}
137
138impl XmlTextVisitor<'_> {
139    /// Creates a new [`XmlTextVisitor`].
140    pub fn new() -> Self {
141        Self {
142            marker: PhantomData,
143            lifetime: PhantomData,
144        }
145    }
146}
147
148impl Default for XmlTextVisitor<'_> {
149    fn default() -> Self {
150        Self::new()
151    }
152}
153
154impl<'v> crate::de::Visitor<'v> for XmlTextVisitor<'v> {
155    type Value = XmlText;
156
157    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
158        formatter.write_str("a comment")
159    }
160
161    fn visit_text<E, V>(self, value: V) -> Result<Self::Value, E>
162    where
163        E: de::Error,
164        V: de::XmlText<'v>,
165    {
166        Ok(XmlText(value.into_bytes().into()))
167    }
168}
169
170impl DeserializeContext for () {
171    fn default_namespace(&self) -> Option<&XmlNamespace> {
172        None
173    }
174
175    fn resolve_prefix(&self, _prefix: &Prefix) -> Option<&XmlNamespace> {
176        None
177    }
178
179    fn external_data<T>(&self) -> Option<&T>
180    where
181        T: core::any::Any,
182    {
183        None
184    }
185}
186
187impl<'de> Deserialize<'de> for XmlText {
188    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
189    where
190        D: Deserializer<'de>,
191    {
192        deserializer.deserialize_any(XmlTextVisitor::new())
193    }
194}
195
196// CData
197
198/// A visitor for deserializing to [`XmlCData`].
199pub struct XmlCDataVisitor<'v> {
200    marker: PhantomData<XmlCData>,
201    lifetime: PhantomData<&'v ()>,
202}
203impl XmlCDataVisitor<'_> {
204    /// Creates a new [`XmlCDataVisitor`].
205    pub fn new() -> Self {
206        Self {
207            marker: PhantomData,
208            lifetime: PhantomData,
209        }
210    }
211}
212
213impl Default for XmlCDataVisitor<'_> {
214    fn default() -> Self {
215        Self::new()
216    }
217}
218
219impl<'de> Visitor<'de> for XmlCDataVisitor<'de> {
220    type Value = XmlCData;
221    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
222        formatter.write_str("a CDATA section")
223    }
224    fn visit_cdata<E, V>(self, value: V) -> Result<Self::Value, E>
225    where
226        E: de::Error,
227        V: de::XmlCData<'de>,
228    {
229        Ok(XmlCData(value.as_bytes().to_owned()))
230    }
231}
232
233impl<'de> Deserialize<'de> for XmlCData {
234    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
235    where
236        D: Deserializer<'de>,
237    {
238        deserializer.deserialize_any(XmlCDataVisitor::new())
239    }
240}
241
242// Child
243
244/// A visitor for deserializing to [`XmlChild`].
245pub struct XmlChildVisitor<'v> {
246    marker: PhantomData<XmlChild>,
247    lifetime: PhantomData<&'v ()>,
248}
249impl XmlChildVisitor<'_> {
250    /// Creates a new [`XmlChildVisitor`].
251    pub fn new() -> Self {
252        Self {
253            marker: PhantomData,
254            lifetime: PhantomData,
255        }
256    }
257}
258
259impl Default for XmlChildVisitor<'_> {
260    fn default() -> Self {
261        Self::new()
262    }
263}
264
265impl<'v> crate::de::Visitor<'v> for XmlChildVisitor<'v> {
266    type Value = XmlChild;
267    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
268        formatter.write_str("an XML child")
269    }
270
271    fn visit_text<E, V>(self, value: V) -> Result<Self::Value, E>
272    where
273        E: de::Error,
274        V: de::XmlText<'v>,
275    {
276        XmlTextVisitor::new().visit_text(value).map(XmlChild::Text)
277    }
278
279    fn visit_cdata<E, V>(self, value: V) -> Result<Self::Value, E>
280    where
281        E: de::Error,
282        V: de::XmlCData<'v>,
283    {
284        XmlCDataVisitor::new()
285            .visit_cdata(value)
286            .map(XmlChild::CData)
287    }
288
289    fn visit_element<A>(self, element: A) -> Result<Self::Value, A::Error>
290    where
291        A: de::ElementAccess<'v>,
292    {
293        XmlElementVisitor::new()
294            .visit_element(element)
295            .map(XmlChild::Element)
296    }
297
298    fn visit_pi<E, V>(self, value: V) -> Result<Self::Value, E>
299    where
300        E: de::Error,
301        V: de::XmlProcessingInstruction,
302    {
303        XmlProcessingInstructionVisitor::new()
304            .visit_pi(value)
305            .map(XmlChild::PI)
306    }
307
308    fn visit_comment<E, V>(self, value: V) -> Result<Self::Value, E>
309    where
310        E: de::Error,
311        V: de::XmlComment<'v>,
312    {
313        XmlCommentVisitor::new()
314            .visit_comment(value)
315            .map(XmlChild::Comment)
316    }
317}
318
319impl<'de> de::Deserialize<'de> for XmlChild {
320    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
321    where
322        D: de::Deserializer<'de>,
323    {
324        deserializer.deserialize_any(XmlChildVisitor::new())
325    }
326}
327
328// Element
329
330/// A visitor for deserializing to [`XmlElement`].
331pub struct XmlElementVisitor<'v> {
332    marker: PhantomData<XmlElement>,
333    lifetime: PhantomData<&'v ()>,
334}
335
336impl XmlElementVisitor<'_> {
337    /// Creates a new [`XmlElementVisitor`].
338    pub fn new() -> Self {
339        Self {
340            marker: PhantomData,
341            lifetime: PhantomData,
342        }
343    }
344}
345
346impl Default for XmlElementVisitor<'_> {
347    fn default() -> Self {
348        Self::new()
349    }
350}
351
352impl<'v> crate::de::Visitor<'v> for XmlElementVisitor<'v> {
353    type Value = XmlElement;
354    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
355        formatter.write_str("an element")
356    }
357
358    fn visit_element<A>(self, mut element: A) -> Result<Self::Value, A::Error>
359    where
360        A: de::ElementAccess<'v>,
361    {
362        let name = element.name().into_owned();
363        let attributes = iter::from_fn(|| match element.next_attribute::<XmlAttribute>() {
364            Ok(Some(attr)) => Some(Ok(attr)),
365            Ok(None) => None,
366            Err(err) => Some(Err(err)),
367        })
368        .collect::<Result<_, _>>()?;
369        let mut children = element.children()?;
370
371        let children = iter::from_fn(|| match children.next_element::<XmlChild>() {
372            Ok(Some(child)) => Some(Ok(child)),
373            Ok(None) => None,
374            Err(err) => Some(Err(err)),
375        })
376        .collect::<Result<_, _>>()?;
377
378        Ok(XmlElement {
379            name,
380            attributes,
381            children,
382            preferred_prefix: None,
383            enforce_prefix: crate::ser::IncludePrefix::Never,
384        })
385    }
386}
387
388impl<'de> crate::de::Deserialize<'de> for XmlElement {
389    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
390    where
391        D: crate::de::Deserializer<'de>,
392    {
393        deserializer.deserialize_any(XmlElementVisitor::new())
394    }
395}
396
397// Attribute
398
399/// A visitor for deserializing to [`XmlAttribute`].
400pub struct XmlAttributeVisitor<'v> {
401    marker: PhantomData<XmlAttribute>,
402    lifetime: PhantomData<&'v ()>,
403}
404
405impl XmlAttributeVisitor<'_> {
406    /// Creates a new [`XmlAttributeVisitor`].
407    pub fn new() -> Self {
408        Self {
409            marker: PhantomData,
410            lifetime: PhantomData,
411        }
412    }
413}
414
415impl Default for XmlAttributeVisitor<'_> {
416    fn default() -> Self {
417        Self::new()
418    }
419}
420
421impl<'v> crate::de::Visitor<'v> for XmlAttributeVisitor<'v> {
422    type Value = XmlAttribute;
423    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
424        formatter.write_str("an attribute")
425    }
426
427    fn visit_attribute<A>(self, attribute: A) -> Result<Self::Value, A::Error>
428    where
429        A: de::AttributeAccess<'v>,
430    {
431        Ok(XmlAttribute {
432            name: attribute.name().into_owned(),
433            value: attribute.value()?,
434        })
435    }
436}
437
438impl<'a> de::AttributeAccess<'a> for &'a XmlAttribute {
439    type Error = XmlValueDeserializerError;
440
441    fn name(&self) -> ExpandedName<'_> {
442        self.name.as_ref()
443    }
444
445    fn value<T>(self) -> Result<T, Self::Error>
446    where
447        T: Deserialize<'a>,
448    {
449        T::deserialize(&self.value)
450    }
451}
452
453impl<'de> crate::de::Deserialize<'de> for XmlAttribute {
454    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
455    where
456        D: crate::de::Deserializer<'de>,
457    {
458        deserializer.deserialize_any(XmlAttributeVisitor::new())
459    }
460}
461
462// Seq
463
464impl<'de, T: Deserialize<'de>> Deserialize<'de> for XmlSeq<T> {
465    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
466    where
467        D: crate::de::Deserializer<'de>,
468    {
469        deserializer.deserialize_seq(IteratorVisitor::<_, Self>::default())
470    }
471}
472
473// Processing Instruction
474
475/// A visitor for deserializing to [`XmlProcessingInstruction`].
476pub struct XmlProcessingInstructionVisitor<'v> {
477    marker: PhantomData<XmlProcessingInstruction>,
478    lifetime: PhantomData<&'v ()>,
479}
480
481impl XmlProcessingInstructionVisitor<'_> {
482    /// Creates a new [`XmlProcessingInstructionVisitor`].
483    pub fn new() -> Self {
484        Self {
485            marker: PhantomData,
486            lifetime: PhantomData,
487        }
488    }
489}
490
491impl Default for XmlProcessingInstructionVisitor<'_> {
492    fn default() -> Self {
493        Self::new()
494    }
495}
496
497impl<'v> crate::de::Visitor<'v> for XmlProcessingInstructionVisitor<'v> {
498    type Value = XmlProcessingInstruction;
499
500    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
501        formatter.write_str("a comment")
502    }
503
504    fn visit_pi<E, V>(self, value: V) -> Result<Self::Value, E>
505    where
506        E: de::Error,
507        V: de::XmlProcessingInstruction,
508    {
509        Ok(XmlProcessingInstruction {
510            target: value.target().to_vec(),
511            content: value.content().to_vec(),
512        })
513    }
514}
515
516impl<'de> Deserialize<'de> for XmlProcessingInstruction {
517    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
518    where
519        D: Deserializer<'de>,
520    {
521        deserializer.deserialize_any(XmlProcessingInstructionVisitor::new())
522    }
523}
524
525// Xml Decl
526
527/// A visitor for deserializing to [`XmlDeclVisitor`].
528pub struct XmlDeclVisitor<'v> {
529    marker: PhantomData<XmlDecl>,
530    lifetime: PhantomData<&'v ()>,
531}
532
533impl XmlDeclVisitor<'_> {
534    /// Creates a new [`XmlDeclVisitor`].
535    pub fn new() -> Self {
536        Self {
537            marker: PhantomData,
538            lifetime: PhantomData,
539        }
540    }
541}
542
543impl Default for XmlDeclVisitor<'_> {
544    fn default() -> Self {
545        Self::new()
546    }
547}
548
549impl<'v> crate::de::Visitor<'v> for XmlDeclVisitor<'v> {
550    type Value = XmlDecl;
551    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
552        formatter.write_str("a declaration")
553    }
554
555    fn visit_decl<E, V>(self, declaration: V) -> Result<Self::Value, E>
556    where
557        E: de::Error,
558        V: de::XmlDeclaration,
559    {
560        Ok(XmlDecl {
561            version: String::from_utf8_lossy(declaration.version()).to_string(),
562            encoding: declaration
563                .encoding()
564                .map(|e| String::from_utf8_lossy(e).to_string()),
565            standalone: declaration
566                .standalone()
567                .map(|e| String::from_utf8_lossy(e).to_string()),
568        })
569    }
570}
571
572impl<'de> Deserialize<'de> for XmlDecl {
573    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
574    where
575        D: Deserializer<'de>,
576    {
577        deserializer.deserialize_any(XmlDeclVisitor::new())
578    }
579}
580
581// Xml Comment
582
583/// A visitor for deserializing to [`XmlComment`].
584pub struct XmlCommentVisitor<'v> {
585    marker: PhantomData<XmlComment>,
586    lifetime: PhantomData<&'v ()>,
587}
588
589impl XmlCommentVisitor<'_> {
590    /// Creates a new [`XmlCommentVisitor`].
591    pub fn new() -> Self {
592        Self {
593            marker: PhantomData,
594            lifetime: PhantomData,
595        }
596    }
597}
598
599impl Default for XmlCommentVisitor<'_> {
600    fn default() -> Self {
601        Self::new()
602    }
603}
604
605impl<'v> crate::de::Visitor<'v> for XmlCommentVisitor<'v> {
606    type Value = XmlComment;
607
608    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
609        formatter.write_str("a comment")
610    }
611
612    fn visit_comment<E, V>(self, comment: V) -> Result<Self::Value, E>
613    where
614        E: de::Error,
615        V: de::XmlComment<'v>,
616    {
617        Ok(XmlComment(comment.into_bytes().into_owned()))
618    }
619}
620
621impl<'de> Deserialize<'de> for XmlComment {
622    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
623    where
624        D: Deserializer<'de>,
625    {
626        deserializer.deserialize_any(XmlCommentVisitor::new())
627    }
628}
629
630// Xml Doctype
631
632/// A visitor for deserializing to [`XmlDoctype`].
633pub struct XmlDoctypeVisitor<'v> {
634    marker: PhantomData<XmlDoctype>,
635    lifetime: PhantomData<&'v ()>,
636}
637
638impl XmlDoctypeVisitor<'_> {
639    /// Creates a new [`XmlDoctypeVisitor`].
640    pub fn new() -> Self {
641        Self {
642            marker: PhantomData,
643            lifetime: PhantomData,
644        }
645    }
646}
647
648impl Default for XmlDoctypeVisitor<'_> {
649    fn default() -> Self {
650        Self::new()
651    }
652}
653
654impl<'v> crate::de::Visitor<'v> for XmlDoctypeVisitor<'v> {
655    type Value = XmlDoctype;
656
657    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
658        formatter.write_str("a comment")
659    }
660
661    fn visit_doctype<E, V>(self, value: V) -> Result<Self::Value, E>
662    where
663        E: de::Error,
664        V: de::XmlDoctype<'v>,
665    {
666        Ok(XmlDoctype(value.into_bytes().into_owned()))
667    }
668}
669
670impl<'de> Deserialize<'de> for XmlDoctype {
671    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
672    where
673        D: Deserializer<'de>,
674    {
675        deserializer.deserialize_any(XmlDoctypeVisitor::new())
676    }
677}
xmlity/value/deserialize.rs

xmlity/value/
deserialize.rs
