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>, attribute: bool) -> ExpandedName<'a> {
229        let (resolve_result, _) = self.reader.resolve(qname, attribute);
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(), false)
237    }
238
239    fn resolve_attribute<'a>(&'a self, attribute: &'a Attribute<'a>) -> ExpandedName<'a> {
240        self.resolve_qname(attribute.key, true)
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 default_namespace(&self) -> Option<XmlNamespace<'_>> {
285        let name = format!("a");
286        let (_, namespace) = self
287            .resolve_qname(QuickName(name.as_bytes()), false)
288            .into_parts();
289
290        namespace.map(XmlNamespace::into_owned)
291    }
292
293    fn resolve_prefix(&self, prefix: xmlity::Prefix<'_>) -> Option<XmlNamespace<'_>> {
294        let name = format!("{prefix}:a");
295        let (_, namespace) = self
296            .resolve_qname(QuickName(name.as_bytes()), false)
297            .into_parts();
298
299        namespace.map(XmlNamespace::into_owned)
300    }
301}
302
303struct AttributeAccess<'a, 'v> {
304    name: ExpandedName<'v>,
305    value: Cow<'v, [u8]>,
306    deserializer: &'a Deserializer<'a>,
307}
308
309impl<'de> de::AttributeAccess<'de> for AttributeAccess<'_, 'de> {
310    type Error = Error;
311
312    fn name(&self) -> ExpandedName<'de> {
313        self.name.clone()
314    }
315
316    /// Deserializes the value of the attribute.
317    fn value<T>(self) -> Result<T, Self::Error>
318    where
319        T: Deserialize<'de>,
320    {
321        T::deserialize(TextDeserializer {
322            value: self.value,
323            deserializer: self.deserializer,
324        })
325    }
326}
327
328struct TextDeserializer<'a, 'v> {
329    value: Cow<'v, [u8]>,
330    deserializer: &'a Deserializer<'a>,
331}
332
333impl<'de> de::XmlText<'de> for TextDeserializer<'_, 'de> {
334    type NamespaceContext<'a>
335        = &'a Deserializer<'a>
336    where
337        Self: 'a;
338
339    fn into_bytes(self) -> Cow<'de, [u8]> {
340        self.value
341    }
342
343    fn as_bytes(&self) -> &[u8] {
344        self.value.as_ref()
345    }
346
347    fn into_string(self) -> Cow<'de, str> {
348        match self.value {
349            Cow::Borrowed(bytes) => Cow::Borrowed(std::str::from_utf8(bytes).unwrap()),
350            Cow::Owned(_) => Cow::Owned(String::from_utf8(self.value.into_owned()).unwrap()),
351        }
352    }
353
354    fn as_str(&self) -> &str {
355        std::str::from_utf8(self.value.as_ref()).unwrap()
356    }
357
358    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
359        self.deserializer
360    }
361}
362
363impl<'de> de::Deserializer<'de> for TextDeserializer<'_, 'de> {
364    type Error = Error;
365
366    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
367    where
368        V: Visitor<'de>,
369    {
370        visitor.visit_text(self)
371    }
372
373    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
374    where
375        V: Visitor<'de>,
376    {
377        visitor.visit_text(self)
378    }
379}
380
381struct EmptySeqAccess;
382
383impl<'de> de::SeqAccess<'de> for EmptySeqAccess {
384    type Error = Error;
385    type SubAccess<'s>
386        = EmptySeqAccess
387    where
388        Self: 's;
389
390    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
391    where
392        T: Deserialize<'de>,
393    {
394        Ok(None)
395    }
396
397    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
398    where
399        T: Deserialize<'de>,
400    {
401        Ok(None)
402    }
403
404    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
405        Ok(EmptySeqAccess)
406    }
407}
408
409struct AttributeDeserializer<'a, 'v> {
410    name: ExpandedName<'v>,
411    value: Cow<'v, [u8]>,
412    deserializer: &'a Deserializer<'a>,
413}
414
415impl<'de> xmlity::Deserializer<'de> for AttributeDeserializer<'_, 'de> {
416    type Error = Error;
417
418    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
419    where
420        V: Visitor<'de>,
421    {
422        visitor.visit_attribute(AttributeAccess {
423            name: self.name,
424            value: self.value,
425            deserializer: self.deserializer,
426        })
427    }
428
429    fn deserialize_seq<V>(self, _: V) -> Result<V::Value, Self::Error>
430    where
431        V: Visitor<'de>,
432    {
433        Err(Self::Error::Unexpected(de::Unexpected::Seq))
434    }
435}
436
437struct SubAttributesAccess<'a, 'r> {
438    deserializer: &'a Deserializer<'r>,
439    bytes_start: &'a BytesStart<'r>,
440    attribute_index: usize,
441    write_attribute_to: &'a mut usize,
442}
443
444impl Drop for SubAttributesAccess<'_, '_> {
445    fn drop(&mut self) {
446        *self.write_attribute_to = self.attribute_index;
447    }
448}
449
450fn key_is_declaration(key: &ExpandedName) -> bool {
451    key.namespace() == Some(&XmlNamespace::XMLNS)
452        || (key.local_name() == &LocalName::new_dangerous("xmlns") && key.namespace().is_none())
453}
454
455fn next_attribute<'a, 'de, T: Deserialize<'de>>(
456    deserializer: &'a Deserializer<'_>,
457    bytes_start: &'a BytesStart<'_>,
458    attribute_index: &'a mut usize,
459) -> Result<Option<T>, Error> {
460    while let Some(attribute) = bytes_start.attributes().nth(*attribute_index) {
461        let attribute = attribute?;
462
463        let key = deserializer.resolve_attribute(&attribute).into_owned();
464
465        if key_is_declaration(&key) {
466            *attribute_index += 1;
467            continue;
468        }
469
470        let deserializer: AttributeDeserializer<'_, 'static> = AttributeDeserializer {
471            name: key,
472            value: Cow::Owned(attribute.value.into_owned()),
473            deserializer,
474        };
475
476        let res = T::deserialize(deserializer)?;
477
478        // Only increment the index if the deserialization was successful
479        *attribute_index += 1;
480
481        return Ok(Some(res));
482    }
483
484    Ok(None)
485}
486
487impl<'de> de::AttributesAccess<'de> for SubAttributesAccess<'_, 'de> {
488    type Error = Error;
489
490    type SubAccess<'a>
491        = SubAttributesAccess<'a, 'de>
492    where
493        Self: 'a;
494
495    fn next_attribute<T>(&mut self) -> Result<Option<T>, Self::Error>
496    where
497        T: Deserialize<'de>,
498    {
499        next_attribute(
500            self.deserializer,
501            self.bytes_start,
502            &mut self.attribute_index,
503        )
504    }
505
506    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
507        Ok(Self::SubAccess {
508            deserializer: self.deserializer,
509            bytes_start: self.bytes_start,
510            attribute_index: self.attribute_index,
511            write_attribute_to: self.write_attribute_to,
512        })
513    }
514}
515
516impl<'de> de::AttributesAccess<'de> for ElementAccess<'_, 'de> {
517    type Error = Error;
518
519    type SubAccess<'a>
520        = SubAttributesAccess<'a, 'de>
521    where
522        Self: 'a;
523
524    fn next_attribute<T>(&mut self) -> Result<Option<T>, Self::Error>
525    where
526        T: Deserialize<'de>,
527    {
528        next_attribute(
529            self.deserializer
530                .as_ref()
531                .expect("deserializer should be set"),
532            self.bytes_start
533                .as_ref()
534                .expect("bytes_start should be set"),
535            &mut self.attribute_index,
536        )
537    }
538
539    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
540        Ok(Self::SubAccess {
541            bytes_start: self
542                .bytes_start
543                .as_ref()
544                .expect("Should not be called after ElementAccess has been consumed"),
545            attribute_index: self.attribute_index,
546            write_attribute_to: &mut self.attribute_index,
547            deserializer: self
548                .deserializer
549                .as_ref()
550                .expect("Should not be called after ElementAccess has been consumed"),
551        })
552    }
553}
554
555impl<'a, 'de> de::ElementAccess<'de> for ElementAccess<'a, 'de> {
556    type ChildrenAccess = ChildrenAccess<'a, 'de>;
557    type NamespaceContext<'b>
558        = &'b Deserializer<'de>
559    where
560        Self: 'b;
561
562    fn name(&self) -> ExpandedName<'_> {
563        self.deserializer().resolve_bytes_start(
564            self.bytes_start
565                .as_ref()
566                .expect("bytes_start should be set"),
567        )
568    }
569
570    fn children(mut self) -> Result<Self::ChildrenAccess, Self::Error> {
571        Ok(if self.empty {
572            ChildrenAccess::Empty
573        } else {
574            let deserializer = self
575                .deserializer
576                .take()
577                .expect("Should not be called after ElementAccess has been consumed");
578
579            ChildrenAccess::Filled {
580                expected_end: self
581                    .bytes_start
582                    .take()
583                    .expect("Should not be called after ElementAccess has been consumed"),
584                start_depth: self.start_depth,
585                deserializer,
586            }
587        })
588    }
589
590    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
591        self.deserializer()
592    }
593}
594
595enum ChildrenAccess<'a, 'de> {
596    Filled {
597        expected_end: BytesStart<'de>,
598        deserializer: &'a mut Deserializer<'de>,
599        start_depth: i16,
600    },
601    Empty,
602}
603
604impl Drop for ChildrenAccess<'_, '_> {
605    fn drop(&mut self) {
606        let ChildrenAccess::Filled {
607            expected_end,
608            deserializer,
609            start_depth,
610        } = self
611        else {
612            return;
613        };
614
615        deserializer
616            .read_until_element_end(expected_end.name(), *start_depth)
617            .unwrap();
618    }
619}
620
621impl ChildrenAccess<'_, '_> {
622    fn check_end<T>(
623        expected_end: &BytesStart,
624        bytes_end: &BytesEnd,
625        current_depth: i16,
626        start_depth: i16,
627    ) -> Result<Option<T>, Error> {
628        if expected_end.name() != bytes_end.name() && current_depth == start_depth {
629            return Err(Error::custom(format!(
630                "Expected end of element {}, found end of element {}",
631                QName::from_quick_xml(expected_end.name()),
632                QName::from_quick_xml(bytes_end.name())
633            )));
634        }
635        Ok(None)
636    }
637}
638
639impl<'r> de::SeqAccess<'r> for ChildrenAccess<'_, 'r> {
640    type Error = Error;
641
642    type SubAccess<'s>
643        = SubSeqAccess<'s, 'r>
644    where
645        Self: 's;
646
647    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
648    where
649        T: Deserialize<'r>,
650    {
651        let ChildrenAccess::Filled {
652            expected_end,
653            deserializer,
654            start_depth,
655        } = self
656        else {
657            return Ok(None);
658        };
659
660        if deserializer.peek_event().is_none() {
661            return Ok(None);
662        }
663
664        let current_depth = deserializer.current_depth;
665
666        if let Some(Event::End(bytes_end)) = deserializer.peek_event() {
667            return Self::check_end(expected_end, bytes_end, current_depth, *start_depth);
668        }
669
670        deserializer
671            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
672            .map(Some)
673    }
674
675    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
676    where
677        T: Deserialize<'r>,
678    {
679        let ChildrenAccess::Filled {
680            expected_end,
681            deserializer,
682            start_depth,
683        } = self
684        else {
685            return Ok(None);
686        };
687
688        if deserializer.peek_event().is_none() {
689            return Ok(None);
690        }
691
692        let current_depth = deserializer.current_depth;
693
694        if let Some(Event::End(bytes_end)) = deserializer.peek_event() {
695            return Self::check_end(expected_end, bytes_end, current_depth, *start_depth);
696        }
697
698        deserializer
699            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
700            .map(Some)
701    }
702
703    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
704        let ChildrenAccess::Filled { deserializer, .. } = self else {
705            return Ok(SubSeqAccess::Empty);
706        };
707
708        Ok(deserializer.create_sub_seq_access())
709    }
710}
711
712struct SeqAccess<'a, 'r> {
713    deserializer: &'a mut Deserializer<'r>,
714}
715
716#[allow(clippy::large_enum_variant)]
717enum SubSeqAccess<'p, 'r> {
718    Filled {
719        current: Option<Deserializer<'r>>,
720        parent: &'p mut Deserializer<'r>,
721    },
722    Empty,
723}
724
725impl Drop for SubSeqAccess<'_, '_> {
726    fn drop(&mut self) {
727        if let SubSeqAccess::Filled { current, parent } = self {
728            **parent = current.take().expect("SubSeqAccess dropped twice");
729        }
730    }
731}
732
733impl<'r> de::SeqAccess<'r> for SubSeqAccess<'_, 'r> {
734    type Error = Error;
735
736    type SubAccess<'s>
737        = SubSeqAccess<'s, 'r>
738    where
739        Self: 's;
740
741    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
742    where
743        T: Deserialize<'r>,
744    {
745        let Self::Filled { current, .. } = self else {
746            return Ok(None);
747        };
748
749        let deserializer = current.as_mut().expect("SubSeqAccess used after drop");
750
751        if deserializer.peek_event().is_none() {
752            return Ok(None);
753        }
754
755        deserializer
756            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
757            .map(Some)
758    }
759
760    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
761    where
762        T: Deserialize<'r>,
763    {
764        let Self::Filled { current, .. } = self else {
765            return Ok(None);
766        };
767
768        let deserializer = current.as_mut().expect("SubSeqAccess used after drop");
769
770        if deserializer.peek_event().is_none() {
771            return Ok(None);
772        }
773
774        deserializer
775            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
776            .map(Some)
777    }
778
779    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
780        let Self::Filled { current, .. } = self else {
781            return Ok(SubSeqAccess::Empty);
782        };
783
784        Ok(current
785            .as_mut()
786            .expect("SubSeqAccess used after drop")
787            .create_sub_seq_access())
788    }
789}
790
791impl<'r> de::SeqAccess<'r> for SeqAccess<'_, 'r> {
792    type Error = Error;
793
794    type SubAccess<'s>
795        = SubSeqAccess<'s, 'r>
796    where
797        Self: 's;
798
799    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
800    where
801        T: Deserialize<'r>,
802    {
803        if self.deserializer.peek_event().is_none() {
804            return Ok(None);
805        }
806
807        self.deserializer
808            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
809            .map(Some)
810    }
811
812    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
813    where
814        T: Deserialize<'r>,
815    {
816        if self.deserializer.peek_event().is_none() {
817            return Ok(None);
818        }
819
820        self.deserializer
821            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
822            .map(Some)
823    }
824
825    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
826        Ok(SubSeqAccess::Filled {
827            current: Some(self.deserializer.clone()),
828            parent: self.deserializer,
829        })
830    }
831}
832
833struct DataWithD<'a, T> {
834    data: T,
835    deserializer: &'a Deserializer<'a>,
836}
837
838impl<'a, T> DataWithD<'a, T> {
839    fn new(data: T, deserializer: &'a Deserializer<'a>) -> Self {
840        Self { data, deserializer }
841    }
842}
843
844impl<'de> XmlText<'de> for DataWithD<'_, BytesText<'de>> {
845    type NamespaceContext<'a>
846        = &'a Deserializer<'a>
847    where
848        Self: 'a;
849
850    fn into_bytes(self) -> Cow<'de, [u8]> {
851        self.data.into_inner()
852    }
853
854    fn as_bytes(&self) -> &[u8] {
855        self.data.deref()
856    }
857
858    fn into_string(self) -> Cow<'de, str> {
859        match self.data.into_inner() {
860            Cow::Borrowed(bytes) => Cow::Borrowed(std::str::from_utf8(bytes).unwrap()),
861            Cow::Owned(bytes) => Cow::Owned(std::string::String::from_utf8(bytes).unwrap()),
862        }
863    }
864
865    fn as_str(&self) -> &str {
866        std::str::from_utf8(self.data.deref()).unwrap()
867    }
868
869    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
870        self.deserializer
871    }
872}
873
874impl<'de> XmlCData<'de> for DataWithD<'_, BytesCData<'de>> {
875    type NamespaceContext<'a>
876        = &'a Deserializer<'a>
877    where
878        Self: 'a;
879
880    fn into_bytes(self) -> Cow<'de, [u8]> {
881        self.data.into_inner()
882    }
883
884    fn as_bytes(&self) -> &[u8] {
885        self.data.deref()
886    }
887
888    fn into_string(self) -> Cow<'de, str> {
889        match self.data.into_inner() {
890            Cow::Borrowed(bytes) => Cow::Borrowed(std::str::from_utf8(bytes).unwrap()),
891            Cow::Owned(bytes) => Cow::Owned(std::string::String::from_utf8(bytes).unwrap()),
892        }
893    }
894
895    fn as_str(&self) -> &str {
896        std::str::from_utf8(self.data.deref()).unwrap()
897    }
898
899    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
900        self.deserializer
901    }
902}
903
904impl<'de> XmlComment<'de> for DataWithD<'_, BytesText<'de>> {
905    type NamespaceContext<'a>
906        = &'a Deserializer<'a>
907    where
908        Self: 'a;
909
910    fn into_bytes(self) -> Cow<'de, [u8]> {
911        self.data.into_inner()
912    }
913
914    fn as_bytes(&self) -> &[u8] {
915        self.data.deref()
916    }
917
918    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
919        self.deserializer
920    }
921}
922
923struct ClearedByteDecl<'a> {
924    version: Cow<'a, [u8]>,
925    encoding: Option<Cow<'a, [u8]>>,
926    standalone: Option<Cow<'a, [u8]>>,
927}
928
929impl<'a> TryFrom<&'a BytesDecl<'a>> for ClearedByteDecl<'a> {
930    type Error = Error;
931
932    fn try_from(bytes_decl: &'a BytesDecl<'a>) -> Result<Self, Self::Error> {
933        Ok(Self {
934            version: bytes_decl.version()?,
935            encoding: match bytes_decl.encoding() {
936                Some(Ok(encoding)) => Some(encoding),
937                Some(Err(err)) => return Err(Error::QuickXml(err.into())),
938                None => None,
939            },
940            standalone: match bytes_decl.standalone() {
941                Some(Ok(standalone)) => Some(standalone),
942                Some(Err(err)) => return Err(Error::QuickXml(err.into())),
943                None => None,
944            },
945        })
946    }
947}
948
949impl XmlDeclaration for DataWithD<'_, ClearedByteDecl<'_>> {
950    type NamespaceContext<'a>
951        = &'a Deserializer<'a>
952    where
953        Self: 'a;
954
955    fn version(&self) -> &[u8] {
956        self.data.version.as_ref()
957    }
958
959    fn encoding(&self) -> Option<&[u8]> {
960        self.data.encoding.as_deref()
961    }
962
963    fn standalone(&self) -> Option<&[u8]> {
964        self.data.standalone.as_deref()
965    }
966
967    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
968        self.deserializer
969    }
970}
971
972impl XmlProcessingInstruction for DataWithD<'_, BytesPI<'_>> {
973    type NamespaceContext<'a>
974        = &'a Deserializer<'a>
975    where
976        Self: 'a;
977
978    fn target(&self) -> &[u8] {
979        self.data.target()
980    }
981
982    fn content(&self) -> &[u8] {
983        self.data.content()
984    }
985
986    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
987        self.deserializer
988    }
989}
990
991impl<'de> XmlDoctype<'de> for DataWithD<'_, BytesText<'de>> {
992    type NamespaceContext<'a>
993        = &'a Deserializer<'a>
994    where
995        Self: 'a;
996
997    fn into_bytes(self) -> Cow<'de, [u8]> {
998        self.data.into_inner()
999    }
1000
1001    fn as_bytes(&self) -> &[u8] {
1002        self.data.deref()
1003    }
1004
1005    fn namespace_context(&self) -> Self::NamespaceContext<'_> {
1006        self.deserializer
1007    }
1008}
1009
1010impl<'r> xmlity::Deserializer<'r> for &mut Deserializer<'r> {
1011    type Error = Error;
1012
1013    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1014    where
1015        V: de::Visitor<'r>,
1016    {
1017        let event = self.next_event().ok_or_else(|| Error::custom("EOF"))?;
1018
1019        match event {
1020            Event::Start(bytes_start) => {
1021                let element_name = OwnedQuickName(bytes_start.name().0.to_owned());
1022
1023                let value = Visitor::visit_element(
1024                    visitor,
1025                    ElementAccess {
1026                        bytes_start: Some(bytes_start),
1027                        start_depth: self.current_depth,
1028                        deserializer: Some(self),
1029                        empty: false,
1030                        attribute_index: 0,
1031                    },
1032                )?;
1033
1034                let end_event = self.next_event().ok_or_else(|| Error::custom("EOF"))?;
1035
1036                let success = if let Event::End(bytes_end) = &end_event {
1037                    bytes_end.name() == element_name.as_ref()
1038                } else {
1039                    false
1040                };
1041
1042                if success {
1043                    Ok(value)
1044                } else {
1045                    Err(Error::custom("No matching end element"))
1046                }
1047            }
1048            Event::End(_bytes_end) => Err(Error::custom("Unexpected end element")),
1049            Event::Empty(bytes_start) => visitor.visit_element(ElementAccess {
1050                bytes_start: Some(bytes_start),
1051                start_depth: self.current_depth,
1052                deserializer: Some(self),
1053                empty: true,
1054                attribute_index: 0,
1055            }),
1056            Event::Text(bytes_text) => visitor.visit_text(DataWithD::new(bytes_text, self)),
1057            Event::CData(bytes_cdata) => visitor.visit_cdata(DataWithD::new(bytes_cdata, self)),
1058            Event::Comment(bytes_text) => visitor.visit_comment(DataWithD::new(bytes_text, self)),
1059            Event::Decl(bytes_decl) => visitor.visit_decl(DataWithD::new(
1060                ClearedByteDecl::try_from(&bytes_decl)?,
1061                self,
1062            )),
1063            Event::PI(bytes_pi) => visitor.visit_pi(DataWithD::new(bytes_pi, self)),
1064            Event::DocType(bytes_text) => visitor.visit_doctype(DataWithD::new(bytes_text, self)),
1065            Event::Eof => Err(Error::custom("Unexpected EOF")),
1066        }
1067    }
1068
1069    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1070    where
1071        V: de::Visitor<'r>,
1072    {
1073        visitor.visit_seq(SeqAccess { deserializer: self })
1074    }
1075}
1076
1077impl<'r> xmlity::Deserializer<'r> for Deserializer<'r> {
1078    type Error = Error;
1079
1080    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
1081    where
1082        V: de::Visitor<'r>,
1083    {
1084        (&mut self).deserialize_any(visitor)
1085    }
1086
1087    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
1088    where
1089        V: de::Visitor<'r>,
1090    {
1091        (&mut self).deserialize_seq(visitor)
1092    }
1093}
xmlity_quick_xml/de.rs

xmlity_quick_xml/
de.rs
