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

xmlity_quick_xml/
de.rs
