xmlity/value/
deserialize.rs

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

xmlity/value/
deserialize.rs
