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