xmlity_quick_xml/
de.rs

1use std::{borrow::Cow, ops::Deref};
2
3use quick_xml::{
4    events::{
5        attributes::Attribute, BytesCData, BytesDecl, BytesEnd, BytesPI, BytesStart, BytesText,
6        Event,
7    },
8    name::QName as QuickName,
9    NsReader,
10};
11
12use xmlity::{
13    de::{
14        self, Error as _, NamespaceContext, Unexpected, Visitor, XmlCData, XmlComment,
15        XmlDeclaration, XmlDoctype, XmlProcessingInstruction, XmlText,
16    },
17    Deserialize, ExpandedName, LocalName, QName, XmlNamespace,
18};
19
20use crate::{xml_namespace_from_resolve_result, HasQuickXmlAlternative, OwnedQuickName};
21
22/// Errors that can occur when using this crate.
23#[derive(Debug, thiserror::Error)]
24pub enum Error {
25    /// Error from the `quick-xml` crate.
26    #[error("Quick XML error: {0}")]
27    QuickXml(#[from] quick_xml::Error),
28    /// Error from the `quick-xml` crate when handling attributes.
29    #[error("Attribute error: {0}")]
30    AttrError(#[from] quick_xml::events::attributes::AttrError),
31    /// IO errors.
32    #[error("IO error: {0}")]
33    Io(#[from] std::io::Error),
34    /// Unexpected segments that occurred when deserializing.
35    #[error("Unexpected: {0}")]
36    Unexpected(xmlity::de::Unexpected),
37    /// Wrong name when trying to deserialize an element;
38    #[error("Wrong name: expected {expected:?}, got {actual:?}")]
39    WrongName {
40        /// The actual name.
41        actual: Box<ExpandedName<'static>>,
42        /// The expected name.
43        expected: Box<ExpandedName<'static>>,
44    },
45    /// Unknown child.
46    #[error("Unknown child")]
47    UnknownChild,
48    /// Invalid string.
49    #[error("Invalid string")]
50    InvalidString,
51    /// Missing field.
52    #[error("Missing field: {field}")]
53    MissingField {
54        /// The name of the field.
55        field: String,
56    },
57    /// No possible variant.
58    #[error("No possible variant: {ident}")]
59    NoPossibleVariant {
60        /// The name of the enum.
61        ident: String,
62    },
63    /// Missing data.
64    #[error("Missing data")]
65    MissingData,
66    /// Custom errors occuring in [`Deserialize`] implementations.
67    #[error("Custom: {0}")]
68    Custom(String),
69}
70
71impl xmlity::de::Error for Error {
72    fn custom<T: ToString>(msg: T) -> Self {
73        Error::Custom(msg.to_string())
74    }
75
76    fn wrong_name(actual: &ExpandedName<'_>, expected: &ExpandedName<'_>) -> Self {
77        Error::WrongName {
78            actual: Box::new(actual.as_ref().into_owned()),
79            expected: Box::new(expected.as_ref().into_owned()),
80        }
81    }
82
83    fn unexpected_visit<T>(unexpected: xmlity::de::Unexpected, _expected: &T) -> Self {
84        Error::Unexpected(unexpected)
85    }
86
87    fn missing_field(field: &str) -> Self {
88        Error::MissingField {
89            field: field.to_string(),
90        }
91    }
92
93    fn no_possible_variant(ident: &str) -> Self {
94        Error::NoPossibleVariant {
95            ident: ident.to_string(),
96        }
97    }
98
99    fn missing_data() -> Self {
100        Error::MissingData
101    }
102
103    fn unknown_child() -> Self {
104        Error::UnknownChild
105    }
106
107    fn invalid_string() -> Self {
108        Error::InvalidString
109    }
110}
111
112/// Deserialize from a string.
113pub fn from_str<'a, T>(s: &'a str) -> Result<T, Error>
114where
115    T: Deserialize<'a>,
116{
117    let mut deserializer = Deserializer::from(s.as_bytes());
118    T::deserialize(&mut deserializer)
119}
120
121/// The [`xmlity::Deserializer`] for the `quick-xml` crate.
122///
123/// This currently only supports an underlying reader of type `&[u8]` due to limitations in the `quick-xml` crate.
124#[derive(Debug, Clone)]
125pub struct Deserializer<'i> {
126    reader: NsReader<&'i [u8]>,
127    current_depth: i16,
128    peeked_event: Option<Event<'i>>,
129}
130
131impl<'i> From<NsReader<&'i [u8]>> for Deserializer<'i> {
132    fn from(reader: NsReader<&'i [u8]>) -> Self {
133        Self::new(reader)
134    }
135}
136
137impl<'i> From<&'i [u8]> for Deserializer<'i> {
138    fn from(buffer: &'i [u8]) -> Self {
139        Self::new(NsReader::from_reader(buffer))
140    }
141}
142
143impl<'i> Deserializer<'i> {
144    /// Create a new deserializer from a [`NsReader<&'i [u8]>`].
145    pub fn new(reader: NsReader<&'i [u8]>) -> Self {
146        Self {
147            reader,
148            current_depth: 0,
149            peeked_event: None,
150        }
151    }
152
153    fn read_event(&mut self) -> Result<Option<Event<'i>>, Error> {
154        match self.reader.read_event()? {
155            Event::Eof => Ok(None),
156            event => Ok(Some(event)),
157        }
158    }
159
160    fn read_until_element_end(
161        &mut self,
162        name: quick_xml::name::QName,
163        depth: i16,
164    ) -> Result<(), Error> {
165        while let Some(event) = self.peek_event() {
166            let correct_name = match event {
167                Event::End(ref e) if e.name() == name => true,
168                Event::Eof => return Err(Error::Unexpected(Unexpected::Eof)),
169                _ => false,
170            };
171
172            if correct_name && self.current_depth == depth {
173                return Ok(());
174            }
175
176            self.next_event();
177        }
178
179        Err(Error::Unexpected(de::Unexpected::Eof))
180    }
181
182    fn peek_event(&mut self) -> Option<&Event<'i>> {
183        if self.peeked_event.is_some() {
184            return self.peeked_event.as_ref();
185        }
186
187        self.peeked_event = self.read_event().ok().flatten();
188        self.peeked_event.as_ref()
189    }
190
191    fn next_event(&mut self) -> Option<Event<'i>> {
192        let event = if self.peeked_event.is_some() {
193            self.peeked_event.take()
194        } else {
195            self.read_event().ok().flatten()
196        };
197
198        if matches!(event, Some(Event::End(_))) {
199            self.current_depth -= 1;
200        }
201        if matches!(event, Some(Event::Start(_))) {
202            self.current_depth += 1;
203        }
204
205        event
206    }
207
208    fn create_sub_seq_access<'p>(&'p mut self) -> SubSeqAccess<'p, 'i> {
209        SubSeqAccess::Filled {
210            current: Some(self.clone()),
211            parent: self,
212        }
213    }
214
215    fn try_deserialize<T, E>(
216        &mut self,
217        closure: impl for<'a> FnOnce(&'a mut Deserializer<'i>) -> Result<T, E>,
218    ) -> Result<T, E> {
219        let mut sub_deserializer = self.clone();
220        let res = closure(&mut sub_deserializer);
221
222        if res.is_ok() {
223            *self = sub_deserializer;
224        }
225        res
226    }
227
228    fn resolve_qname<'a>(&'a self, qname: QuickName<'a>) -> ExpandedName<'a> {
229        let (resolve_result, _) = self.reader.resolve(qname, false);
230        let namespace = xml_namespace_from_resolve_result(resolve_result);
231
232        ExpandedName::new(LocalName::from_quick_xml(qname.local_name()), namespace)
233    }
234
235    fn resolve_bytes_start<'a>(&'a self, bytes_start: &'a BytesStart<'a>) -> ExpandedName<'a> {
236        self.resolve_qname(bytes_start.name())
237    }
238
239    fn resolve_attribute<'a>(&'a self, attribute: &'a Attribute<'a>) -> ExpandedName<'a> {
240        self.resolve_qname(attribute.key)
241    }
242}
243
244struct ElementAccess<'a, 'de> {
245    deserializer: Option<&'a mut Deserializer<'de>>,
246    attribute_index: usize,
247    bytes_start: Option<BytesStart<'de>>,
248    start_depth: i16,
249    empty: bool,
250}
251
252impl Drop for ElementAccess<'_, '_> {
253    fn drop(&mut self) {
254        self.try_end().ok();
255    }
256}
257
258impl<'r> ElementAccess<'_, 'r> {
259    fn deserializer(&self) -> &Deserializer<'r> {
260        self.deserializer
261            .as_ref()
262            .expect("Should not be called after ElementAccess has been consumed")
263    }
264
265    fn try_end(&mut self) -> Result<(), Error> {
266        if self.empty {
267            return Ok(());
268        }
269
270        if let Some(deserializer) = self.deserializer.as_mut() {
271            deserializer.read_until_element_end(
272                self.bytes_start
273                    .as_ref()
274                    .expect("Should be some if deserializer is some")
275                    .name(),
276                self.start_depth,
277            )?;
278        }
279        Ok(())
280    }
281}
282
283impl NamespaceContext for &Deserializer<'_> {
284    fn resolve_prefix(&self, prefix: xmlity::Prefix<'_>) -> Option<XmlNamespace<'_>> {
285        let name = format!("{prefix}:a");
286        let (_, namespace) = self.resolve_qname(QuickName(name.as_bytes())).into_parts();
287
288        namespace.map(XmlNamespace::into_owned)
289    }
290}
291
292struct AttributeAccess<'a, 'v> {
293    name: ExpandedName<'v>,
294    value: Cow<'v, [u8]>,
295    deserializer: &'a Deserializer<'a>,
296}
297
298impl<'de> de::AttributeAccess<'de> for AttributeAccess<'_, 'de> {
299    type Error = Error;
300
301    fn name(&self) -> ExpandedName<'de> {
302        self.name.clone()
303    }
304
305    /// Deserializes the value of the attribute.
306    fn value<T>(self) -> Result<T, Self::Error>
307    where
308        T: Deserialize<'de>,
309    {
310        T::deserialize(TextDeserializer {
311            value: self.value,
312            deserializer: self.deserializer,
313        })
314    }
315}
316
317struct TextDeserializer<'a, 'v> {
318    value: Cow<'v, [u8]>,
319    deserializer: &'a Deserializer<'a>,
320}
321
322impl<'de> de::XmlText<'de> for TextDeserializer<'_, 'de> {
323    type NamespaceContext<'a>
324        = &'a Deserializer<'a>
325    where
326        Self: 'a;
327
328    fn into_bytes(self) -> Cow<'de, [u8]> {
329        self.value
330    }
331
332    fn as_bytes(&self) -> &[u8] {
333        self.value.as_ref()
334    }
335
336    fn into_string(self) -> Cow<'de, str> {
337        match self.value {
338            Cow::Borrowed(bytes) => Cow::Borrowed(std::str::from_utf8(bytes).unwrap()),
339            Cow::Owned(_) => Cow::Owned(String::from_utf8(self.value.into_owned()).unwrap()),
340        }
341    }
342
343    fn as_str(&self) -> &str {
344        std::str::from_utf8(self.value.as_ref()).unwrap()
345    }
346
347    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
348        self.deserializer
349    }
350}
351
352impl<'de> de::Deserializer<'de> for TextDeserializer<'_, 'de> {
353    type Error = Error;
354
355    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
356    where
357        V: Visitor<'de>,
358    {
359        visitor.visit_text(self)
360    }
361
362    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
363    where
364        V: Visitor<'de>,
365    {
366        visitor.visit_text(self)
367    }
368}
369
370struct EmptySeqAccess;
371
372impl<'de> de::SeqAccess<'de> for EmptySeqAccess {
373    type Error = Error;
374    type SubAccess<'s>
375        = EmptySeqAccess
376    where
377        Self: 's;
378
379    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
380    where
381        T: Deserialize<'de>,
382    {
383        Ok(None)
384    }
385
386    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
387    where
388        T: Deserialize<'de>,
389    {
390        Ok(None)
391    }
392
393    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
394        Ok(EmptySeqAccess)
395    }
396}
397
398struct AttributeDeserializer<'a, 'v> {
399    name: ExpandedName<'v>,
400    value: Cow<'v, [u8]>,
401    deserializer: &'a Deserializer<'a>,
402}
403
404impl<'de> xmlity::Deserializer<'de> for AttributeDeserializer<'_, 'de> {
405    type Error = Error;
406
407    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
408    where
409        V: Visitor<'de>,
410    {
411        visitor.visit_attribute(AttributeAccess {
412            name: self.name,
413            value: self.value,
414            deserializer: self.deserializer,
415        })
416    }
417
418    fn deserialize_seq<V>(self, _: V) -> Result<V::Value, Self::Error>
419    where
420        V: Visitor<'de>,
421    {
422        Err(Self::Error::Unexpected(de::Unexpected::Seq))
423    }
424}
425
426struct SubAttributesAccess<'a, 'r> {
427    deserializer: &'a Deserializer<'r>,
428    bytes_start: &'a BytesStart<'r>,
429    attribute_index: usize,
430    write_attribute_to: &'a mut usize,
431}
432
433impl Drop for SubAttributesAccess<'_, '_> {
434    fn drop(&mut self) {
435        *self.write_attribute_to = self.attribute_index;
436    }
437}
438
439fn next_attribute<'a, 'de, T: Deserialize<'de>>(
440    deserializer: &'a Deserializer<'_>,
441    bytes_start: &'a BytesStart<'_>,
442    attribute_index: &'a mut usize,
443) -> Result<Option<T>, Error> {
444    while let Some(attribute) = bytes_start.attributes().nth(*attribute_index) {
445        let attribute = attribute?;
446
447        let key = deserializer.resolve_attribute(&attribute).into_owned();
448
449        if key.namespace() == Some(&XmlNamespace::XMLNS) {
450            *attribute_index += 1;
451            continue;
452        }
453
454        let deserializer: AttributeDeserializer<'_, 'static> = AttributeDeserializer {
455            name: key,
456            value: Cow::Owned(attribute.value.into_owned()),
457            deserializer,
458        };
459
460        let res = T::deserialize(deserializer)?;
461
462        // Only increment the index if the deserialization was successful
463        *attribute_index += 1;
464
465        return Ok(Some(res));
466    }
467
468    Ok(None)
469}
470
471impl<'de> de::AttributesAccess<'de> for SubAttributesAccess<'_, 'de> {
472    type Error = Error;
473
474    type SubAccess<'a>
475        = SubAttributesAccess<'a, 'de>
476    where
477        Self: 'a;
478
479    fn next_attribute<T>(&mut self) -> Result<Option<T>, Self::Error>
480    where
481        T: Deserialize<'de>,
482    {
483        next_attribute(
484            self.deserializer,
485            self.bytes_start,
486            &mut self.attribute_index,
487        )
488    }
489
490    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
491        Ok(Self::SubAccess {
492            deserializer: self.deserializer,
493            bytes_start: self.bytes_start,
494            attribute_index: self.attribute_index,
495            write_attribute_to: self.write_attribute_to,
496        })
497    }
498}
499
500impl<'de> de::AttributesAccess<'de> for ElementAccess<'_, 'de> {
501    type Error = Error;
502
503    type SubAccess<'a>
504        = SubAttributesAccess<'a, 'de>
505    where
506        Self: 'a;
507
508    fn next_attribute<T>(&mut self) -> Result<Option<T>, Self::Error>
509    where
510        T: Deserialize<'de>,
511    {
512        next_attribute(
513            self.deserializer
514                .as_ref()
515                .expect("deserializer should be set"),
516            self.bytes_start
517                .as_ref()
518                .expect("bytes_start should be set"),
519            &mut self.attribute_index,
520        )
521    }
522
523    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
524        Ok(Self::SubAccess {
525            bytes_start: self
526                .bytes_start
527                .as_ref()
528                .expect("Should not be called after ElementAccess has been consumed"),
529            attribute_index: self.attribute_index,
530            write_attribute_to: &mut self.attribute_index,
531            deserializer: self
532                .deserializer
533                .as_ref()
534                .expect("Should not be called after ElementAccess has been consumed"),
535        })
536    }
537}
538
539impl<'a, 'de> de::ElementAccess<'de> for ElementAccess<'a, 'de> {
540    type ChildrenAccess = ChildrenAccess<'a, 'de>;
541    type NamespaceContext<'b>
542        = &'b Deserializer<'de>
543    where
544        Self: 'b;
545
546    fn name(&self) -> ExpandedName<'_> {
547        self.deserializer().resolve_bytes_start(
548            self.bytes_start
549                .as_ref()
550                .expect("bytes_start should be set"),
551        )
552    }
553
554    fn children(mut self) -> Result<Self::ChildrenAccess, Self::Error> {
555        Ok(if self.empty {
556            ChildrenAccess::Empty
557        } else {
558            let deserializer = self
559                .deserializer
560                .take()
561                .expect("Should not be called after ElementAccess has been consumed");
562
563            ChildrenAccess::Filled {
564                expected_end: self
565                    .bytes_start
566                    .take()
567                    .expect("Should not be called after ElementAccess has been consumed"),
568                start_depth: self.start_depth,
569                deserializer,
570            }
571        })
572    }
573
574    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
575        self.deserializer()
576    }
577}
578
579enum ChildrenAccess<'a, 'de> {
580    Filled {
581        expected_end: BytesStart<'de>,
582        deserializer: &'a mut Deserializer<'de>,
583        start_depth: i16,
584    },
585    Empty,
586}
587
588impl Drop for ChildrenAccess<'_, '_> {
589    fn drop(&mut self) {
590        let ChildrenAccess::Filled {
591            expected_end,
592            deserializer,
593            start_depth,
594        } = self
595        else {
596            return;
597        };
598
599        deserializer
600            .read_until_element_end(expected_end.name(), *start_depth)
601            .unwrap();
602    }
603}
604
605impl ChildrenAccess<'_, '_> {
606    fn check_end<T>(
607        expected_end: &BytesStart,
608        bytes_end: &BytesEnd,
609        current_depth: i16,
610        start_depth: i16,
611    ) -> Result<Option<T>, Error> {
612        if expected_end.name() != bytes_end.name() && current_depth == start_depth {
613            return Err(Error::custom(format!(
614                "Expected end of element {}, found end of element {}",
615                QName::from_quick_xml(expected_end.name()),
616                QName::from_quick_xml(bytes_end.name())
617            )));
618        }
619        Ok(None)
620    }
621}
622
623impl<'r> de::SeqAccess<'r> for ChildrenAccess<'_, 'r> {
624    type Error = Error;
625
626    type SubAccess<'s>
627        = SubSeqAccess<'s, 'r>
628    where
629        Self: 's;
630
631    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
632    where
633        T: Deserialize<'r>,
634    {
635        let ChildrenAccess::Filled {
636            expected_end,
637            deserializer,
638            start_depth,
639        } = self
640        else {
641            return Ok(None);
642        };
643
644        if deserializer.peek_event().is_none() {
645            return Ok(None);
646        }
647
648        let current_depth = deserializer.current_depth;
649
650        if let Some(Event::End(bytes_end)) = deserializer.peek_event() {
651            return Self::check_end(expected_end, bytes_end, current_depth, *start_depth);
652        }
653
654        deserializer
655            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
656            .map(Some)
657    }
658
659    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
660    where
661        T: Deserialize<'r>,
662    {
663        let ChildrenAccess::Filled {
664            expected_end,
665            deserializer,
666            start_depth,
667        } = self
668        else {
669            return Ok(None);
670        };
671
672        if deserializer.peek_event().is_none() {
673            return Ok(None);
674        }
675
676        let current_depth = deserializer.current_depth;
677
678        if let Some(Event::End(bytes_end)) = deserializer.peek_event() {
679            return Self::check_end(expected_end, bytes_end, current_depth, *start_depth);
680        }
681
682        deserializer
683            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
684            .map(Some)
685    }
686
687    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
688        let ChildrenAccess::Filled { deserializer, .. } = self else {
689            return Ok(SubSeqAccess::Empty);
690        };
691
692        Ok(deserializer.create_sub_seq_access())
693    }
694}
695
696struct SeqAccess<'a, 'r> {
697    deserializer: &'a mut Deserializer<'r>,
698}
699
700#[allow(clippy::large_enum_variant)]
701enum SubSeqAccess<'p, 'r> {
702    Filled {
703        current: Option<Deserializer<'r>>,
704        parent: &'p mut Deserializer<'r>,
705    },
706    Empty,
707}
708
709impl Drop for SubSeqAccess<'_, '_> {
710    fn drop(&mut self) {
711        if let SubSeqAccess::Filled { current, parent } = self {
712            **parent = current.take().expect("SubSeqAccess dropped twice");
713        }
714    }
715}
716
717impl<'r> de::SeqAccess<'r> for SubSeqAccess<'_, 'r> {
718    type Error = Error;
719
720    type SubAccess<'s>
721        = SubSeqAccess<'s, 'r>
722    where
723        Self: 's;
724
725    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
726    where
727        T: Deserialize<'r>,
728    {
729        let Self::Filled { current, .. } = self else {
730            return Ok(None);
731        };
732
733        let deserializer = current.as_mut().expect("SubSeqAccess used after drop");
734
735        if deserializer.peek_event().is_none() {
736            return Ok(None);
737        }
738
739        deserializer
740            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
741            .map(Some)
742    }
743
744    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
745    where
746        T: Deserialize<'r>,
747    {
748        let Self::Filled { current, .. } = self else {
749            return Ok(None);
750        };
751
752        let deserializer = current.as_mut().expect("SubSeqAccess used after drop");
753
754        if deserializer.peek_event().is_none() {
755            return Ok(None);
756        }
757
758        deserializer
759            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
760            .map(Some)
761    }
762
763    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
764        let Self::Filled { current, .. } = self else {
765            return Ok(SubSeqAccess::Empty);
766        };
767
768        Ok(current
769            .as_mut()
770            .expect("SubSeqAccess used after drop")
771            .create_sub_seq_access())
772    }
773}
774
775impl<'r> de::SeqAccess<'r> for SeqAccess<'_, 'r> {
776    type Error = Error;
777
778    type SubAccess<'s>
779        = SubSeqAccess<'s, 'r>
780    where
781        Self: 's;
782
783    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
784    where
785        T: Deserialize<'r>,
786    {
787        if self.deserializer.peek_event().is_none() {
788            return Ok(None);
789        }
790
791        self.deserializer
792            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
793            .map(Some)
794    }
795
796    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
797    where
798        T: Deserialize<'r>,
799    {
800        if self.deserializer.peek_event().is_none() {
801            return Ok(None);
802        }
803
804        self.deserializer
805            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
806            .map(Some)
807    }
808
809    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
810        Ok(SubSeqAccess::Filled {
811            current: Some(self.deserializer.clone()),
812            parent: self.deserializer,
813        })
814    }
815}
816
817struct DataWithD<'a, T> {
818    data: T,
819    deserializer: &'a Deserializer<'a>,
820}
821
822impl<'a, T> DataWithD<'a, T> {
823    fn new(data: T, deserializer: &'a Deserializer<'a>) -> Self {
824        Self { data, deserializer }
825    }
826}
827
828impl<'de> XmlText<'de> for DataWithD<'_, BytesText<'de>> {
829    type NamespaceContext<'a>
830        = &'a Deserializer<'a>
831    where
832        Self: 'a;
833
834    fn into_bytes(self) -> Cow<'de, [u8]> {
835        self.data.into_inner()
836    }
837
838    fn as_bytes(&self) -> &[u8] {
839        self.data.deref()
840    }
841
842    fn into_string(self) -> Cow<'de, str> {
843        match self.data.into_inner() {
844            Cow::Borrowed(bytes) => Cow::Borrowed(std::str::from_utf8(bytes).unwrap()),
845            Cow::Owned(bytes) => Cow::Owned(std::string::String::from_utf8(bytes).unwrap()),
846        }
847    }
848
849    fn as_str(&self) -> &str {
850        std::str::from_utf8(self.data.deref()).unwrap()
851    }
852
853    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
854        self.deserializer
855    }
856}
857
858impl<'de> XmlCData<'de> for DataWithD<'_, BytesCData<'de>> {
859    type NamespaceContext<'a>
860        = &'a Deserializer<'a>
861    where
862        Self: 'a;
863
864    fn into_bytes(self) -> Cow<'de, [u8]> {
865        self.data.into_inner()
866    }
867
868    fn as_bytes(&self) -> &[u8] {
869        self.data.deref()
870    }
871
872    fn into_string(self) -> Cow<'de, str> {
873        match self.data.into_inner() {
874            Cow::Borrowed(bytes) => Cow::Borrowed(std::str::from_utf8(bytes).unwrap()),
875            Cow::Owned(bytes) => Cow::Owned(std::string::String::from_utf8(bytes).unwrap()),
876        }
877    }
878
879    fn as_str(&self) -> &str {
880        std::str::from_utf8(self.data.deref()).unwrap()
881    }
882
883    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
884        self.deserializer
885    }
886}
887
888impl<'de> XmlComment<'de> for DataWithD<'_, BytesText<'de>> {
889    type NamespaceContext<'a>
890        = &'a Deserializer<'a>
891    where
892        Self: 'a;
893
894    fn into_bytes(self) -> Cow<'de, [u8]> {
895        self.data.into_inner()
896    }
897
898    fn as_bytes(&self) -> &[u8] {
899        self.data.deref()
900    }
901
902    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
903        self.deserializer
904    }
905}
906
907struct ClearedByteDecl<'a> {
908    version: Cow<'a, [u8]>,
909    encoding: Option<Cow<'a, [u8]>>,
910    standalone: Option<Cow<'a, [u8]>>,
911}
912
913impl<'a> TryFrom<&'a BytesDecl<'a>> for ClearedByteDecl<'a> {
914    type Error = Error;
915
916    fn try_from(bytes_decl: &'a BytesDecl<'a>) -> Result<Self, Self::Error> {
917        Ok(Self {
918            version: bytes_decl.version()?,
919            encoding: match bytes_decl.encoding() {
920                Some(Ok(encoding)) => Some(encoding),
921                Some(Err(err)) => return Err(Error::QuickXml(err.into())),
922                None => None,
923            },
924            standalone: match bytes_decl.standalone() {
925                Some(Ok(standalone)) => Some(standalone),
926                Some(Err(err)) => return Err(Error::QuickXml(err.into())),
927                None => None,
928            },
929        })
930    }
931}
932
933impl XmlDeclaration for DataWithD<'_, ClearedByteDecl<'_>> {
934    type NamespaceContext<'a>
935        = &'a Deserializer<'a>
936    where
937        Self: 'a;
938
939    fn version(&self) -> &[u8] {
940        self.data.version.as_ref()
941    }
942
943    fn encoding(&self) -> Option<&[u8]> {
944        self.data.encoding.as_deref()
945    }
946
947    fn standalone(&self) -> Option<&[u8]> {
948        self.data.standalone.as_deref()
949    }
950
951    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
952        self.deserializer
953    }
954}
955
956impl XmlProcessingInstruction for DataWithD<'_, BytesPI<'_>> {
957    type NamespaceContext<'a>
958        = &'a Deserializer<'a>
959    where
960        Self: 'a;
961
962    fn target(&self) -> &[u8] {
963        self.data.target()
964    }
965
966    fn content(&self) -> &[u8] {
967        self.data.content()
968    }
969
970    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
971        self.deserializer
972    }
973}
974
975impl<'de> XmlDoctype<'de> for DataWithD<'_, BytesText<'de>> {
976    type NamespaceContext<'a>
977        = &'a Deserializer<'a>
978    where
979        Self: 'a;
980
981    fn into_bytes(self) -> Cow<'de, [u8]> {
982        self.data.into_inner()
983    }
984
985    fn as_bytes(&self) -> &[u8] {
986        self.data.deref()
987    }
988
989    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
990        self.deserializer
991    }
992}
993
994impl<'r> xmlity::Deserializer<'r> for &mut Deserializer<'r> {
995    type Error = Error;
996
997    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
998    where
999        V: de::Visitor<'r>,
1000    {
1001        let event = self.next_event().ok_or_else(|| Error::custom("EOF"))?;
1002
1003        match event {
1004            Event::Start(bytes_start) => {
1005                let element_name = OwnedQuickName(bytes_start.name().0.to_owned());
1006
1007                let value = Visitor::visit_element(
1008                    visitor,
1009                    ElementAccess {
1010                        bytes_start: Some(bytes_start),
1011                        start_depth: self.current_depth,
1012                        deserializer: Some(self),
1013                        empty: false,
1014                        attribute_index: 0,
1015                    },
1016                )?;
1017
1018                let end_event = self.next_event().ok_or_else(|| Error::custom("EOF"))?;
1019
1020                let success = if let Event::End(bytes_end) = &end_event {
1021                    bytes_end.name() == element_name.as_ref()
1022                } else {
1023                    false
1024                };
1025
1026                if success {
1027                    Ok(value)
1028                } else {
1029                    Err(Error::custom("No matching end element"))
1030                }
1031            }
1032            Event::End(_bytes_end) => Err(Error::custom("Unexpected end element")),
1033            Event::Empty(bytes_start) => visitor.visit_element(ElementAccess {
1034                bytes_start: Some(bytes_start),
1035                start_depth: self.current_depth,
1036                deserializer: Some(self),
1037                empty: true,
1038                attribute_index: 0,
1039            }),
1040            Event::Text(bytes_text) => visitor.visit_text(DataWithD::new(bytes_text, self)),
1041            Event::CData(bytes_cdata) => visitor.visit_cdata(DataWithD::new(bytes_cdata, self)),
1042            Event::Comment(bytes_text) => visitor.visit_comment(DataWithD::new(bytes_text, self)),
1043            Event::Decl(bytes_decl) => visitor.visit_decl(DataWithD::new(
1044                ClearedByteDecl::try_from(&bytes_decl)?,
1045                self,
1046            )),
1047            Event::PI(bytes_pi) => visitor.visit_pi(DataWithD::new(bytes_pi, self)),
1048            Event::DocType(bytes_text) => visitor.visit_doctype(DataWithD::new(bytes_text, self)),
1049            Event::Eof => Err(Error::custom("Unexpected EOF")),
1050        }
1051    }
1052
1053    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1054    where
1055        V: de::Visitor<'r>,
1056    {
1057        visitor.visit_seq(SeqAccess { deserializer: self })
1058    }
1059}
1060
1061impl<'r> xmlity::Deserializer<'r> for Deserializer<'r> {
1062    type Error = Error;
1063
1064    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
1065    where
1066        V: de::Visitor<'r>,
1067    {
1068        (&mut self).deserialize_any(visitor)
1069    }
1070
1071    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
1072    where
1073        V: de::Visitor<'r>,
1074    {
1075        (&mut self).deserialize_seq(visitor)
1076    }
1077}
xmlity_quick_xml/de.rs

xmlity_quick_xml/
de.rs
