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

xmlity_quick_xml/
de.rs
