1 use crate::{
2     de::{escape::EscapedDeserializer, Deserializer},
3     errors::serialize::DeError,
4     events::Event,
5 };
6 use serde::de::{self, Deserializer as SerdeDeserializer};
7 use std::io::BufRead;
8 
9 /// An enum access
10 pub struct EnumAccess<'a, R: BufRead> {
11     de: &'a mut Deserializer<R>,
12 }
13 
14 impl<'a, R: BufRead> EnumAccess<'a, R> {
new(de: &'a mut Deserializer<R>) -> Self15     pub fn new(de: &'a mut Deserializer<R>) -> Self {
16         EnumAccess { de }
17     }
18 }
19 
20 impl<'de, 'a, R: 'a + BufRead> de::EnumAccess<'de> for EnumAccess<'a, R> {
21     type Error = DeError;
22     type Variant = VariantAccess<'a, R>;
23 
variant_seed<V: de::DeserializeSeed<'de>>( self, seed: V, ) -> Result<(V::Value, VariantAccess<'a, R>), DeError>24     fn variant_seed<V: de::DeserializeSeed<'de>>(
25         self,
26         seed: V,
27     ) -> Result<(V::Value, VariantAccess<'a, R>), DeError> {
28         let decoder = self.de.reader.decoder();
29         let de = match self.de.peek()? {
30             Some(Event::Text(t)) => EscapedDeserializer::new(t.to_vec(), decoder, true),
31             Some(Event::Start(e)) => EscapedDeserializer::new(e.name().to_vec(), decoder, false),
32             Some(e) => return Err(DeError::InvalidEnum(e.to_owned())),
33             None => return Err(DeError::Eof),
34         };
35         let name = seed.deserialize(de)?;
36         Ok((name, VariantAccess { de: self.de }))
37     }
38 }
39 
40 pub struct VariantAccess<'a, R: BufRead> {
41     de: &'a mut Deserializer<R>,
42 }
43 
44 impl<'de, 'a, R: BufRead> de::VariantAccess<'de> for VariantAccess<'a, R> {
45     type Error = DeError;
46 
unit_variant(self) -> Result<(), DeError>47     fn unit_variant(self) -> Result<(), DeError> {
48         match self.de.next(&mut Vec::new())? {
49             Event::Start(e) => self.de.read_to_end(e.name()),
50             Event::Text(_) => Ok(()),
51             _ => unreachable!(),
52         }
53     }
54 
newtype_variant_seed<T: de::DeserializeSeed<'de>>( self, seed: T, ) -> Result<T::Value, DeError>55     fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(
56         self,
57         seed: T,
58     ) -> Result<T::Value, DeError> {
59         seed.deserialize(&mut *self.de)
60     }
61 
tuple_variant<V: de::Visitor<'de>>( self, len: usize, visitor: V, ) -> Result<V::Value, DeError>62     fn tuple_variant<V: de::Visitor<'de>>(
63         self,
64         len: usize,
65         visitor: V,
66     ) -> Result<V::Value, DeError> {
67         self.de.deserialize_tuple(len, visitor)
68     }
69 
struct_variant<V: de::Visitor<'de>>( self, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, DeError>70     fn struct_variant<V: de::Visitor<'de>>(
71         self,
72         fields: &'static [&'static str],
73         visitor: V,
74     ) -> Result<V::Value, DeError> {
75         self.de.deserialize_struct("", fields, visitor)
76     }
77 }
78