serde_xml_rs/de/
var.rs

1use std::io::Read;
2
3use serde::de::{self, Deserializer as SerdeDeserializer, IntoDeserializer};
4use xml::name::OwnedName;
5use xml::reader::XmlEvent;
6
7use crate::de::Deserializer;
8use crate::error::{Error, Result};
9use crate::expect;
10
11use super::buffer::BufferedXmlReader;
12
13pub struct EnumAccess<'a, R: Read, B: BufferedXmlReader<R>> {
14    de: &'a mut Deserializer<R, B>,
15}
16
17impl<'a, R: 'a + Read, B: BufferedXmlReader<R>> EnumAccess<'a, R, B> {
18    pub fn new(de: &'a mut Deserializer<R, B>) -> Self {
19        EnumAccess { de: de }
20    }
21}
22
23impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::EnumAccess<'de> for EnumAccess<'a, R, B> {
24    type Error = Error;
25    type Variant = VariantAccess<'a, R, B>;
26
27    fn variant_seed<V: de::DeserializeSeed<'de>>(
28        self,
29        seed: V,
30    ) -> Result<(V::Value, VariantAccess<'a, R, B>)> {
31        let name = expect!(
32            self.de.peek()?,
33
34            &XmlEvent::Characters(ref name) |
35            &XmlEvent::StartElement { name: OwnedName { local_name: ref name, .. }, .. } => {
36                seed.deserialize(name.as_str().into_deserializer())
37            }
38        )?;
39        self.de.set_map_value();
40        Ok((name, VariantAccess::new(self.de)))
41    }
42}
43
44pub struct VariantAccess<'a, R: Read, B: BufferedXmlReader<R>> {
45    de: &'a mut Deserializer<R, B>,
46}
47
48impl<'a, R: 'a + Read, B: BufferedXmlReader<R>> VariantAccess<'a, R, B> {
49    pub fn new(de: &'a mut Deserializer<R, B>) -> Self {
50        VariantAccess { de: de }
51    }
52}
53
54impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::VariantAccess<'de>
55    for VariantAccess<'a, R, B>
56{
57    type Error = Error;
58
59    fn unit_variant(self) -> Result<()> {
60        self.de.unset_map_value();
61        match self.de.next()? {
62            XmlEvent::StartElement {
63                name, attributes, ..
64            } => {
65                if attributes.is_empty() {
66                    self.de.expect_end_element(name)
67                } else {
68                    Err(de::Error::invalid_length(attributes.len(), &"0"))
69                }
70            }
71            XmlEvent::Characters(_) => Ok(()),
72            _ => unreachable!(),
73        }
74    }
75
76    fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<T::Value> {
77        seed.deserialize(&mut *self.de)
78    }
79
80    fn tuple_variant<V: de::Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
81        self.de.deserialize_tuple(len, visitor)
82    }
83
84    fn struct_variant<V: de::Visitor<'de>>(
85        self,
86        _fields: &'static [&'static str],
87        visitor: V,
88    ) -> Result<V::Value> {
89        self.de.deserialize_map(visitor)
90    }
91}