1 //! Serde `Deserializer` module 2 3 use crate::{ 4 de::{escape::EscapedDeserializer, Deserializer, INNER_VALUE}, 5 errors::serialize::DeError, 6 events::{attributes::Attribute, BytesStart, Event}, 7 }; 8 use serde::de::{self, DeserializeSeed, IntoDeserializer}; 9 use std::io::BufRead; 10 11 enum MapValue { 12 Empty, 13 Attribute { value: Vec<u8> }, 14 Nested, 15 InnerValue, 16 } 17 18 /// A deserializer for `Attributes` 19 pub(crate) struct MapAccess<'a, R: BufRead> { 20 start: BytesStart<'static>, 21 de: &'a mut Deserializer<R>, 22 position: usize, 23 value: MapValue, 24 } 25 26 impl<'a, R: BufRead> MapAccess<'a, R> { 27 /// Create a new MapAccess new(de: &'a mut Deserializer<R>, start: BytesStart<'static>) -> Result<Self, DeError>28 pub fn new(de: &'a mut Deserializer<R>, start: BytesStart<'static>) -> Result<Self, DeError> { 29 let position = start.attributes().position; 30 Ok(MapAccess { 31 de, 32 start, 33 position, 34 value: MapValue::Empty, 35 }) 36 } 37 next_attr(&mut self) -> Result<Option<Attribute>, DeError>38 fn next_attr(&mut self) -> Result<Option<Attribute>, DeError> { 39 let mut attributes = self.start.attributes(); 40 attributes.position = self.position; 41 let next_att = attributes.next(); 42 self.position = attributes.position; 43 Ok(next_att.transpose()?) 44 } 45 } 46 47 impl<'a, 'de, R: BufRead> de::MapAccess<'de> for MapAccess<'a, R> { 48 type Error = DeError; 49 next_key_seed<K: DeserializeSeed<'de>>( &mut self, seed: K, ) -> Result<Option<K::Value>, Self::Error>50 fn next_key_seed<K: DeserializeSeed<'de>>( 51 &mut self, 52 seed: K, 53 ) -> Result<Option<K::Value>, Self::Error> { 54 let attr_key_val = self 55 .next_attr()? 56 .map(|a| (a.key.to_owned(), a.value.into_owned())); 57 let decoder = self.de.reader.decoder(); 58 let has_value_field = self.de.has_value_field; 59 if let Some((key, value)) = attr_key_val { 60 // try getting map from attributes (key= "value") 61 self.value = MapValue::Attribute { value }; 62 seed.deserialize(EscapedDeserializer::new(key, decoder, false)) 63 .map(Some) 64 } else { 65 // try getting from events (<key>value</key>) 66 match self.de.peek()? { 67 Some(Event::Text(_)) | Some(Event::Start(_)) if has_value_field => { 68 self.value = MapValue::InnerValue; 69 seed.deserialize(INNER_VALUE.into_deserializer()).map(Some) 70 } 71 Some(Event::Start(e)) => { 72 let name = e.local_name().to_owned(); 73 self.value = MapValue::Nested; 74 seed.deserialize(EscapedDeserializer::new(name, decoder, false)) 75 .map(Some) 76 } 77 _ => Ok(None), 78 } 79 } 80 } 81 next_value_seed<K: DeserializeSeed<'de>>( &mut self, seed: K, ) -> Result<K::Value, Self::Error>82 fn next_value_seed<K: DeserializeSeed<'de>>( 83 &mut self, 84 seed: K, 85 ) -> Result<K::Value, Self::Error> { 86 match std::mem::replace(&mut self.value, MapValue::Empty) { 87 MapValue::Attribute { value } => seed.deserialize(EscapedDeserializer::new( 88 value, 89 self.de.reader.decoder(), 90 true, 91 )), 92 MapValue::Nested | MapValue::InnerValue => seed.deserialize(&mut *self.de), 93 MapValue::Empty => Err(DeError::EndOfAttributes), 94 } 95 } 96 } 97