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}