xmlity_quick_xml/
de.rs

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

xmlity_quick_xml/
de.rs
