| use std::io::Read; |
| |
| use serde::de::{self, IntoDeserializer, Unexpected}; |
| use serde::forward_to_deserialize_any; |
| use xml::attribute::OwnedAttribute; |
| use xml::reader::XmlEvent; |
| |
| use crate::error::{Error, Result}; |
| use crate::Deserializer; |
| |
| use super::buffer::BufferedXmlReader; |
| |
| pub struct MapAccess<'a, R: Read, B: BufferedXmlReader<R>> { |
| attrs: ::std::vec::IntoIter<OwnedAttribute>, |
| /// Cache of attribute value, populated when visitor calls `next_key_seed`; should be read & emptied straight after |
| /// by visitor call to `next_value_seed` |
| next_attr_value: Option<String>, |
| de: &'a mut Deserializer<R, B>, |
| /// Whether this `MapAccess` is to deserialize all inner contents of an outer element. |
| inner_value: bool, |
| } |
| |
| impl<'a, R: 'a + Read, B: BufferedXmlReader<R>> MapAccess<'a, R, B> { |
| pub fn new( |
| de: &'a mut Deserializer<R, B>, |
| attrs: Vec<OwnedAttribute>, |
| inner_value: bool, |
| ) -> Self { |
| MapAccess { |
| attrs: attrs.into_iter(), |
| next_attr_value: None, |
| de: de, |
| inner_value: inner_value, |
| } |
| } |
| } |
| |
| impl<'de, 'a, R: 'a + Read, B: BufferedXmlReader<R>> de::MapAccess<'de> for MapAccess<'a, R, B> { |
| type Error = Error; |
| |
| fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> { |
| debug_assert_eq!(self.next_attr_value, None); |
| match self.attrs.next() { |
| // Read all attributes first |
| Some(OwnedAttribute { name, value }) => { |
| self.next_attr_value = Some(value); |
| seed.deserialize(name.local_name.into_deserializer()) |
| .map(Some) |
| } |
| None => match *self.de.peek()? { |
| XmlEvent::StartElement { ref name, .. } => seed |
| .deserialize( |
| if !self.inner_value { |
| name.local_name.as_str() |
| } else { |
| "$value" |
| } |
| .into_deserializer(), |
| ) |
| .map(Some), |
| XmlEvent::Characters(_) => seed.deserialize("$value".into_deserializer()).map(Some), |
| // Any other event: assume end of map values (actual check for `EndElement` done by the originating |
| // `Deserializer`) |
| _ => Ok(None), |
| }, |
| } |
| } |
| |
| fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> { |
| match self.next_attr_value.take() { |
| Some(value) => seed.deserialize(AttrValueDeserializer(value)), |
| None => { |
| if !self.inner_value { |
| if let XmlEvent::StartElement { .. } = *self.de.peek()? { |
| self.de.set_map_value(); |
| } |
| } |
| let result = seed.deserialize(&mut *self.de)?; |
| Ok(result) |
| } |
| } |
| } |
| |
| fn size_hint(&self) -> Option<usize> { |
| self.attrs.size_hint().1 |
| } |
| } |
| |
| struct AttrValueDeserializer(String); |
| |
| macro_rules! deserialize_type_attr { |
| ($deserialize:ident => $visit:ident) => { |
| fn $deserialize<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { |
| visitor.$visit(self.0.parse()?) |
| } |
| }; |
| } |
| |
| impl<'de> de::Deserializer<'de> for AttrValueDeserializer { |
| type Error = Error; |
| |
| fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { |
| visitor.visit_string(self.0) |
| } |
| |
| deserialize_type_attr!(deserialize_i8 => visit_i8); |
| deserialize_type_attr!(deserialize_i16 => visit_i16); |
| deserialize_type_attr!(deserialize_i32 => visit_i32); |
| deserialize_type_attr!(deserialize_i64 => visit_i64); |
| deserialize_type_attr!(deserialize_u8 => visit_u8); |
| deserialize_type_attr!(deserialize_u16 => visit_u16); |
| deserialize_type_attr!(deserialize_u32 => visit_u32); |
| deserialize_type_attr!(deserialize_u64 => visit_u64); |
| deserialize_type_attr!(deserialize_f32 => visit_f32); |
| deserialize_type_attr!(deserialize_f64 => visit_f64); |
| |
| fn deserialize_enum<V: de::Visitor<'de>>( |
| self, |
| _name: &str, |
| _variants: &'static [&'static str], |
| visitor: V, |
| ) -> Result<V::Value> { |
| visitor.visit_enum(self.0.into_deserializer()) |
| } |
| |
| fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { |
| visitor.visit_some(self) |
| } |
| |
| fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { |
| match self.0.as_str() { |
| "true" | "1" => visitor.visit_bool(true), |
| "false" | "0" => visitor.visit_bool(false), |
| _ => Err(de::Error::invalid_value( |
| Unexpected::Str(&self.0), |
| &"a boolean", |
| )), |
| } |
| } |
| |
| forward_to_deserialize_any! { |
| char str string unit seq bytes map unit_struct newtype_struct tuple_struct |
| struct identifier tuple ignored_any byte_buf |
| } |
| } |