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

xmlity_quick_xml/
de.rs
