xmlity_quick_xml/
de.rs

1use std::ops::Deref;
2
3use quick_xml::{
4    events::{attributes::Attribute, BytesStart, Event},
5    name::QName as QuickName,
6    NsReader,
7};
8
9use xmlity::{
10    de::{self, Error as _, Unexpected, Visitor},
11    Deserialize, ExpandedName, LocalName, QName, XmlNamespace,
12};
13
14use crate::{xml_namespace_from_resolve_result, HasQuickXmlAlternative, OwnedQuickName};
15
16/// Errors that can occur when using this crate.
17#[derive(Debug, thiserror::Error)]
18pub enum Error {
19    /// Error from the `quick-xml` crate.
20    #[error("Quick XML error: {0}")]
21    QuickXml(#[from] quick_xml::Error),
22    /// Error from the `quick-xml` crate when handling attributes.
23    #[error("Attribute error: {0}")]
24    AttrError(#[from] quick_xml::events::attributes::AttrError),
25    /// IO errors.
26    #[error("IO error: {0}")]
27    Io(#[from] std::io::Error),
28    /// Unexpected segments that occurred when deserializing.
29    #[error("Unexpected: {0}")]
30    Unexpected(xmlity::de::Unexpected),
31    /// Wrong name when trying to deserialize an element;
32    #[error("Wrong name: expected {expected:?}, got {actual:?}")]
33    WrongName {
34        /// The actual name.
35        actual: Box<ExpandedName<'static>>,
36        /// The expected name.
37        expected: Box<ExpandedName<'static>>,
38    },
39    /// Unknown child.
40    #[error("Unknown child")]
41    UnknownChild,
42    /// Invalid string.
43    #[error("Invalid string")]
44    InvalidString,
45    /// Missing field.
46    #[error("Missing field: {field}")]
47    MissingField {
48        /// The name of the field.
49        field: String,
50    },
51    /// No possible variant.
52    #[error("No possible variant: {ident}")]
53    NoPossibleVariant {
54        /// The name of the enum.
55        ident: String,
56    },
57    /// Missing data.
58    #[error("Missing data")]
59    MissingData,
60    /// Custom errors occuring in [`Deserialize`] implementations.
61    #[error("Custom: {0}")]
62    Custom(String),
63}
64
65impl xmlity::de::Error for Error {
66    fn custom<T: ToString>(msg: T) -> Self {
67        Error::Custom(msg.to_string())
68    }
69
70    fn wrong_name(actual: &ExpandedName<'_>, expected: &ExpandedName<'_>) -> Self {
71        Error::WrongName {
72            actual: Box::new(actual.clone().into_owned()),
73            expected: Box::new(expected.clone().into_owned()),
74        }
75    }
76
77    fn unexpected_visit<T>(unexpected: xmlity::de::Unexpected, _expected: &T) -> Self {
78        Error::Unexpected(unexpected)
79    }
80
81    fn missing_field(field: &str) -> Self {
82        Error::MissingField {
83            field: field.to_string(),
84        }
85    }
86
87    fn no_possible_variant(ident: &str) -> Self {
88        Error::NoPossibleVariant {
89            ident: ident.to_string(),
90        }
91    }
92
93    fn missing_data() -> Self {
94        Error::MissingData
95    }
96
97    fn unknown_child() -> Self {
98        Error::UnknownChild
99    }
100
101    fn invalid_string() -> Self {
102        Error::InvalidString
103    }
104}
105
106/// Deserialize from a string.
107pub fn from_str<'a, T>(s: &'a str) -> Result<T, Error>
108where
109    T: Deserialize<'a>,
110{
111    let mut deserializer = Deserializer::from(s.as_bytes());
112    T::deserialize(&mut deserializer)
113}
114
115/// The [`xmlity::Deserializer`] for the `quick-xml` crate.
116///
117/// This currently only supports an underlying reader of type `&[u8]` due to limitations in the `quick-xml` crate.
118#[derive(Debug, Clone)]
119pub struct Deserializer<'i> {
120    reader: NsReader<&'i [u8]>,
121    current_depth: i16,
122    peeked_event: Option<Event<'i>>,
123}
124
125impl<'i> From<NsReader<&'i [u8]>> for Deserializer<'i> {
126    fn from(reader: NsReader<&'i [u8]>) -> Self {
127        Self::new(reader)
128    }
129}
130
131impl<'i> From<&'i [u8]> for Deserializer<'i> {
132    fn from(buffer: &'i [u8]) -> Self {
133        Self::new(NsReader::from_reader(buffer))
134    }
135}
136
137impl<'i> Deserializer<'i> {
138    /// Create a new deserializer from a [`NsReader<&'i [u8]>`].
139    pub fn new(reader: NsReader<&'i [u8]>) -> Self {
140        Self {
141            reader,
142            current_depth: 0,
143            peeked_event: None,
144        }
145    }
146
147    fn read_event(&mut self) -> Result<Option<Event<'i>>, Error> {
148        while let Ok(event) = self.reader.read_event() {
149            match event {
150                Event::Eof => return Ok(None),
151                Event::Text(text) if text.clone().into_inner().trim_ascii().is_empty() => {
152                    continue;
153                }
154                event => return Ok(Some(event)),
155            }
156        }
157
158        Ok(None)
159    }
160
161    fn read_until_element_end(&mut self, name: &QuickName, depth: i16) -> Result<(), Error> {
162        while let Some(event) = self.peek_event() {
163            let correct_name = match event {
164                Event::End(ref e) if e.name() == *name => true,
165                Event::Eof => return Err(Error::Unexpected(Unexpected::Eof)),
166                _ => false,
167            };
168
169            if correct_name && self.current_depth == depth {
170                return Ok(());
171            }
172
173            self.next_event();
174        }
175
176        Err(Error::Unexpected(de::Unexpected::Eof))
177    }
178
179    fn peek_event(&mut self) -> Option<&Event<'i>> {
180        if self.peeked_event.is_some() {
181            return self.peeked_event.as_ref();
182        }
183
184        self.peeked_event = self.read_event().ok().flatten();
185        self.peeked_event.as_ref()
186    }
187
188    fn next_event(&mut self) -> Option<Event<'i>> {
189        let event = if self.peeked_event.is_some() {
190            self.peeked_event.take()
191        } else {
192            self.read_event().ok().flatten()
193        };
194
195        if matches!(event, Some(Event::End(_))) {
196            self.current_depth -= 1;
197        }
198        if matches!(event, Some(Event::Start(_))) {
199            self.current_depth += 1;
200        }
201
202        event
203    }
204
205    fn create_sub_seq_access<'p>(&'p mut self) -> SubSeqAccess<'p, 'i> {
206        SubSeqAccess::Filled {
207            current: Some(self.clone()),
208            parent: self,
209        }
210    }
211
212    fn try_deserialize<T, E>(
213        &mut self,
214        closure: impl for<'a> FnOnce(&'a mut Deserializer<'i>) -> Result<T, E>,
215    ) -> Result<T, E> {
216        let mut sub_deserializer = self.clone();
217        let res = closure(&mut sub_deserializer);
218
219        if res.is_ok() {
220            *self = sub_deserializer;
221        }
222        res
223    }
224
225    fn expand_name<'a>(&self, qname: QuickName<'a>) -> ExpandedName<'a> {
226        let (resolve_result, _) = self.reader.resolve(qname, false);
227        let namespace = xml_namespace_from_resolve_result(resolve_result).map(|ns| ns.into_owned());
228
229        ExpandedName::new(LocalName::from_quick_xml(qname.local_name()), namespace)
230    }
231
232    fn resolve_bytes_start<'a>(&self, bytes_start: &'a BytesStart<'a>) -> ExpandedName<'a> {
233        self.expand_name(bytes_start.name())
234    }
235
236    fn resolve_attribute<'a>(&self, attribute: &'a Attribute<'a>) -> ExpandedName<'a> {
237        self.expand_name(attribute.key)
238    }
239}
240
241struct ElementAccess<'a, 'r> {
242    deserializer: Option<&'a mut Deserializer<'r>>,
243    attribute_index: usize,
244    bytes_start: BytesStart<'r>,
245    start_depth: i16,
246    empty: bool,
247}
248
249impl Drop for ElementAccess<'_, '_> {
250    fn drop(&mut self) {
251        self.try_end().ok();
252    }
253}
254
255impl<'r> ElementAccess<'_, 'r> {
256    fn deserializer(&self) -> &Deserializer<'r> {
257        self.deserializer
258            .as_ref()
259            .expect("Should not be called after ElementAccess has been consumed")
260    }
261
262    fn try_end(&mut self) -> Result<(), Error> {
263        if self.empty {
264            return Ok(());
265        }
266
267        if let Some(deserializer) = self.deserializer.as_mut() {
268            deserializer.read_until_element_end(&self.bytes_start.name(), self.start_depth)?;
269        }
270        Ok(())
271    }
272}
273
274struct AttributeAccess<'a> {
275    name: ExpandedName<'a>,
276    value: String,
277}
278
279impl<'a> de::AttributeAccess<'a> for AttributeAccess<'a> {
280    type Error = Error;
281
282    fn name(&self) -> ExpandedName<'_> {
283        self.name.clone()
284    }
285
286    fn value(&self) -> &str {
287        self.value.as_str()
288    }
289}
290
291struct EmptySeqAccess;
292
293impl<'de> de::SeqAccess<'de> for EmptySeqAccess {
294    type Error = Error;
295    type SubAccess<'s>
296        = EmptySeqAccess
297    where
298        Self: 's;
299
300    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
301    where
302        T: Deserialize<'de>,
303    {
304        Ok(None)
305    }
306
307    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
308    where
309        T: Deserialize<'de>,
310    {
311        Ok(None)
312    }
313
314    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
315        Ok(EmptySeqAccess)
316    }
317}
318
319struct AttributeDeserializer<'a> {
320    name: ExpandedName<'a>,
321    value: String,
322}
323
324impl<'a> xmlity::Deserializer<'a> for AttributeDeserializer<'a> {
325    type Error = Error;
326
327    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
328    where
329        V: Visitor<'a>,
330    {
331        visitor.visit_attribute(AttributeAccess {
332            name: self.name,
333            value: self.value,
334        })
335    }
336
337    fn deserialize_seq<V>(self, _: V) -> Result<V::Value, Self::Error>
338    where
339        V: Visitor<'a>,
340    {
341        Err(Self::Error::Unexpected(de::Unexpected::Seq))
342    }
343}
344
345struct SubAttributesAccess<'a, 'r> {
346    deserializer: &'a Deserializer<'r>,
347    bytes_start: &'a BytesStart<'r>,
348    attribute_index: usize,
349    write_attribute_to: &'a mut usize,
350}
351
352impl Drop for SubAttributesAccess<'_, '_> {
353    fn drop(&mut self) {
354        *self.write_attribute_to = self.attribute_index;
355    }
356}
357
358fn next_attribute<'a, 'de, T: Deserialize<'de>>(
359    deserializer: &'a Deserializer<'_>,
360    bytes_start: &'a BytesStart<'_>,
361    attribute_index: &'a mut usize,
362) -> Result<Option<T>, Error> {
363    let (attribute, key) = loop {
364        let Some(attribute) = bytes_start.attributes().nth(*attribute_index) else {
365            return Ok(None);
366        };
367
368        let attribute = attribute?;
369
370        let key = deserializer.resolve_attribute(&attribute).into_owned();
371
372        const XMLNS_NAMESPACE: XmlNamespace<'static> =
373            XmlNamespace::new_dangerous("http://www.w3.org/2000/xmlns/");
374
375        if key.namespace() == Some(&XMLNS_NAMESPACE) {
376            *attribute_index += 1;
377            continue;
378        }
379
380        break (attribute, key);
381    };
382
383    let value = String::from_utf8(attribute.value.into_owned())
384        .expect("attribute value should be valid utf8");
385
386    let deserializer = AttributeDeserializer { name: key, value };
387
388    let res = T::deserialize(deserializer)?;
389
390    // Only increment the index if the deserialization was successful
391    *attribute_index += 1;
392
393    Ok(Some(res))
394}
395
396impl<'de> de::AttributesAccess<'de> for SubAttributesAccess<'_, 'de> {
397    type Error = Error;
398
399    type SubAccess<'a>
400        = SubAttributesAccess<'a, 'de>
401    where
402        Self: 'a;
403
404    fn next_attribute<T>(&mut self) -> Result<Option<T>, Self::Error>
405    where
406        T: Deserialize<'de>,
407    {
408        next_attribute(
409            self.deserializer,
410            self.bytes_start,
411            &mut self.attribute_index,
412        )
413    }
414
415    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
416        Ok(Self::SubAccess {
417            deserializer: self.deserializer,
418            bytes_start: self.bytes_start,
419            attribute_index: self.attribute_index,
420            write_attribute_to: self.write_attribute_to,
421        })
422    }
423}
424
425impl<'de> de::AttributesAccess<'de> for ElementAccess<'_, 'de> {
426    type Error = Error;
427
428    type SubAccess<'a>
429        = SubAttributesAccess<'a, 'de>
430    where
431        Self: 'a;
432
433    fn next_attribute<T>(&mut self) -> Result<Option<T>, Self::Error>
434    where
435        T: Deserialize<'de>,
436    {
437        next_attribute(
438            self.deserializer
439                .as_ref()
440                .expect("deserializer should be set"),
441            &self.bytes_start,
442            &mut self.attribute_index,
443        )
444    }
445
446    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
447        Ok(Self::SubAccess {
448            bytes_start: &self.bytes_start,
449            attribute_index: self.attribute_index,
450            write_attribute_to: &mut self.attribute_index,
451            deserializer: self
452                .deserializer
453                .as_ref()
454                .expect("Should not be called after ElementAccess has been consumed"),
455        })
456    }
457}
458
459impl<'a, 'de> de::ElementAccess<'de> for ElementAccess<'a, 'de> {
460    type ChildrenAccess = ChildrenAccess<'a, 'de>;
461
462    fn name(&self) -> ExpandedName<'_> {
463        self.deserializer().resolve_bytes_start(&self.bytes_start)
464    }
465
466    fn children(mut self) -> Result<Self::ChildrenAccess, Self::Error> {
467        Ok(if self.empty {
468            ChildrenAccess::Empty
469        } else {
470            let deserializer = self
471                .deserializer
472                .take()
473                .expect("Should not be called after ElementAccess has been consumed");
474
475            ChildrenAccess::Filled {
476                expected_end: QName::from_quick_xml(self.bytes_start.name()).into_owned(),
477                start_depth: self.start_depth,
478                deserializer,
479            }
480        })
481    }
482}
483
484enum ChildrenAccess<'a, 'r> {
485    Filled {
486        expected_end: QName<'static>,
487        deserializer: &'a mut Deserializer<'r>,
488        start_depth: i16,
489    },
490    Empty,
491}
492
493impl Drop for ChildrenAccess<'_, '_> {
494    fn drop(&mut self) {
495        let ChildrenAccess::Filled {
496            expected_end,
497            deserializer,
498            start_depth,
499        } = self
500        else {
501            return;
502        };
503
504        deserializer
505            .read_until_element_end(&OwnedQuickName::new(expected_end).as_ref(), *start_depth)
506            .unwrap();
507    }
508}
509
510impl<'r> de::SeqAccess<'r> for ChildrenAccess<'_, 'r> {
511    type Error = Error;
512
513    type SubAccess<'s>
514        = SubSeqAccess<'s, 'r>
515    where
516        Self: 's;
517
518    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
519    where
520        T: Deserialize<'r>,
521    {
522        let ChildrenAccess::Filled {
523            expected_end,
524            deserializer,
525            start_depth,
526        } = self
527        else {
528            return Ok(None);
529        };
530
531        if deserializer.peek_event().is_none() {
532            return Ok(None);
533        }
534
535        let current_depth = deserializer.current_depth;
536
537        if let Some(Event::End(bytes_end)) = deserializer.peek_event() {
538            if OwnedQuickName::new(expected_end).as_ref() != bytes_end.name()
539                && current_depth == *start_depth
540            {
541                return Err(Error::custom(format!(
542                    "Expected end of element {}, found end of element {}",
543                    expected_end,
544                    QName::from_quick_xml(bytes_end.name())
545                )));
546            }
547
548            return Ok(None);
549        }
550
551        deserializer
552            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
553            .map(Some)
554    }
555
556    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
557    where
558        T: Deserialize<'r>,
559    {
560        let ChildrenAccess::Filled {
561            expected_end,
562            deserializer,
563            start_depth,
564        } = self
565        else {
566            return Ok(None);
567        };
568
569        if deserializer.peek_event().is_none() {
570            return Ok(None);
571        }
572
573        let current_depth = deserializer.current_depth;
574
575        if let Some(Event::End(bytes_end)) = deserializer.peek_event() {
576            if OwnedQuickName::new(expected_end).as_ref() != bytes_end.name()
577                && current_depth == *start_depth
578            {
579                return Err(Error::custom(format!(
580                    "Expected end of element {}, found end of element {}",
581                    expected_end,
582                    QName::from_quick_xml(bytes_end.name())
583                )));
584            }
585
586            return Ok(None);
587        }
588
589        deserializer
590            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
591            .map(Some)
592    }
593
594    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
595        let ChildrenAccess::Filled { deserializer, .. } = self else {
596            return Ok(SubSeqAccess::Empty);
597        };
598
599        Ok(deserializer.create_sub_seq_access())
600    }
601}
602
603struct SeqAccess<'a, 'r> {
604    deserializer: &'a mut Deserializer<'r>,
605}
606
607#[allow(clippy::large_enum_variant)]
608enum SubSeqAccess<'p, 'r> {
609    Filled {
610        current: Option<Deserializer<'r>>,
611        parent: &'p mut Deserializer<'r>,
612    },
613    Empty,
614}
615
616impl Drop for SubSeqAccess<'_, '_> {
617    fn drop(&mut self) {
618        if let SubSeqAccess::Filled { current, parent } = self {
619            **parent = current.take().expect("SubSeqAccess dropped twice");
620        }
621    }
622}
623
624impl<'r> de::SeqAccess<'r> for SubSeqAccess<'_, 'r> {
625    type Error = Error;
626
627    type SubAccess<'s>
628        = SubSeqAccess<'s, 'r>
629    where
630        Self: 's;
631
632    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
633    where
634        T: Deserialize<'r>,
635    {
636        let Self::Filled { current, .. } = self else {
637            return Ok(None);
638        };
639
640        let deserializer = current.as_mut().expect("SubSeqAccess used after drop");
641
642        if deserializer.peek_event().is_none() {
643            return Ok(None);
644        }
645
646        deserializer
647            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
648            .map(Some)
649    }
650
651    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
652    where
653        T: Deserialize<'r>,
654    {
655        let Self::Filled { current, .. } = self else {
656            return Ok(None);
657        };
658
659        let deserializer = current.as_mut().expect("SubSeqAccess used after drop");
660
661        if deserializer.peek_event().is_none() {
662            return Ok(None);
663        }
664
665        deserializer
666            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
667            .map(Some)
668    }
669
670    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
671        let Self::Filled { current, .. } = self else {
672            return Ok(SubSeqAccess::Empty);
673        };
674
675        Ok(current
676            .as_mut()
677            .expect("SubSeqAccess used after drop")
678            .create_sub_seq_access())
679    }
680}
681
682impl<'r> de::SeqAccess<'r> for SeqAccess<'_, 'r> {
683    type Error = Error;
684
685    type SubAccess<'s>
686        = SubSeqAccess<'s, 'r>
687    where
688        Self: 's;
689
690    fn next_element_seq<T>(&mut self) -> Result<Option<T>, Self::Error>
691    where
692        T: Deserialize<'r>,
693    {
694        if self.deserializer.peek_event().is_none() {
695            return Ok(None);
696        }
697
698        self.deserializer
699            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize_seq(deserializer))
700            .map(Some)
701    }
702
703    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
704    where
705        T: Deserialize<'r>,
706    {
707        if self.deserializer.peek_event().is_none() {
708            return Ok(None);
709        }
710
711        self.deserializer
712            .try_deserialize(|deserializer| Deserialize::<'r>::deserialize(deserializer))
713            .map(Some)
714    }
715
716    fn sub_access(&mut self) -> Result<Self::SubAccess<'_>, Self::Error> {
717        Ok(SubSeqAccess::Filled {
718            current: Some(self.deserializer.clone()),
719            parent: self.deserializer,
720        })
721    }
722}
723
724impl<'r> xmlity::Deserializer<'r> for &mut Deserializer<'r> {
725    type Error = Error;
726
727    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
728    where
729        V: de::Visitor<'r>,
730    {
731        let event = self.next_event().ok_or_else(|| Error::custom("EOF"))?;
732
733        match event {
734            Event::Start(bytes_start) => {
735                let element_name = OwnedQuickName(bytes_start.name().0.to_owned());
736
737                let value = Visitor::visit_element(
738                    visitor,
739                    ElementAccess {
740                        bytes_start,
741                        start_depth: self.current_depth,
742                        deserializer: Some(self),
743                        empty: false,
744                        attribute_index: 0,
745                    },
746                )?;
747
748                let end_event = self.next_event().ok_or_else(|| Error::custom("EOF"))?;
749
750                let success = if let Event::End(bytes_end) = &end_event {
751                    bytes_end.name() == element_name.as_ref()
752                } else {
753                    false
754                };
755
756                if success {
757                    Ok(value)
758                } else {
759                    Err(Error::custom("No matching end element"))
760                }
761            }
762            Event::End(_bytes_end) => Err(Error::custom("Unexpected end element")),
763            Event::Empty(bytes_start) => visitor.visit_element(ElementAccess {
764                bytes_start: bytes_start.into_owned().clone(),
765                start_depth: self.current_depth,
766                deserializer: Some(self),
767                empty: true,
768                attribute_index: 0,
769            }),
770            Event::Text(bytes_text) => visitor.visit_text(bytes_text.deref()),
771            Event::CData(bytes_cdata) => visitor.visit_cdata(bytes_cdata.deref()),
772            Event::Comment(bytes_text) => visitor.visit_comment(bytes_text.deref()),
773            Event::Decl(bytes_decl) => visitor.visit_decl(
774                bytes_decl.version()?,
775                match bytes_decl.encoding() {
776                    Some(Ok(encoding)) => Some(encoding),
777                    Some(Err(err)) => return Err(Error::QuickXml(err.into())),
778                    None => None,
779                },
780                match bytes_decl.standalone() {
781                    Some(Ok(standalone)) => Some(standalone),
782                    Some(Err(err)) => return Err(Error::QuickXml(err.into())),
783                    None => None,
784                },
785            ),
786            Event::PI(bytes_pi) => visitor.visit_pi(bytes_pi.deref()),
787            Event::DocType(bytes_text) => visitor.visit_doctype(bytes_text.deref()),
788            Event::Eof => Err(Error::custom("Unexpected EOF")),
789        }
790    }
791
792    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
793    where
794        V: de::Visitor<'r>,
795    {
796        visitor.visit_seq(SeqAccess { deserializer: self })
797    }
798}
799
800impl<'r> xmlity::Deserializer<'r> for Deserializer<'r> {
801    type Error = Error;
802
803    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
804    where
805        V: de::Visitor<'r>,
806    {
807        (&mut self).deserialize_any(visitor)
808    }
809
810    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
811    where
812        V: de::Visitor<'r>,
813    {
814        (&mut self).deserialize_seq(visitor)
815    }
816}
xmlity_quick_xml/de.rs

xmlity_quick_xml/
de.rs
