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