1 use std::io::Read;
2 
3 use serde::de::{self, Deserializer as SerdeDeserializer, IntoDeserializer};
4 use xml::name::OwnedName;
5 use xml::reader::XmlEvent;
6 
7 use crate::de::Deserializer;
8 use crate::error::{Error, Result};
9 use crate::expect;
10 
11 use super::buffer::BufferedXmlReader;
12 
13 pub struct EnumAccess<'a, R: Read, B: BufferedXmlReader<R>> {
14     de: &'a mut Deserializer<R, B>,
15 }
16 
17 impl<'a, R: 'a + Read, B: BufferedXmlReader<R>> EnumAccess<'a, R, B> {
new(de: &'a mut Deserializer<R, B>) -> Self18     pub fn new(de: &'a mut Deserializer<R, B>) -> Self {
19         EnumAccess { de: de }
20     }
21 }
22 
23 impl<'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 
variant_seed<V: de::DeserializeSeed<'de>>( self, seed: V, ) -> Result<(V::Value, VariantAccess<'a, R, B>)>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 
44 pub struct VariantAccess<'a, R: Read, B: BufferedXmlReader<R>> {
45     de: &'a mut Deserializer<R, B>,
46 }
47 
48 impl<'a, R: 'a + Read, B: BufferedXmlReader<R>> VariantAccess<'a, R, B> {
new(de: &'a mut Deserializer<R, B>) -> Self49     pub fn new(de: &'a mut Deserializer<R, B>) -> Self {
50         VariantAccess { de: de }
51     }
52 }
53 
54 impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::VariantAccess<'de>
55     for VariantAccess<'a, R, B>
56 {
57     type Error = Error;
58 
unit_variant(self) -> Result<()>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 
newtype_variant_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<T::Value>76     fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<T::Value> {
77         seed.deserialize(&mut *self.de)
78     }
79 
tuple_variant<V: de::Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value>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 
struct_variant<V: de::Visitor<'de>>( self, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value>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 }
92