serde_xml_rs2/de/
mod.rs

1use std::io::Read;
2
3use serde::de;
4use xml::reader::{EventReader, ParserConfig, XmlEvent};
5use xml::name::OwnedName;
6
7use error::{Error, ErrorKind, Result};
8use self::map::MapAccess;
9use self::seq::SeqAccess;
10use self::var::EnumAccess;
11
12mod map;
13mod seq;
14mod var;
15
16/// A convenience method for deserialize some object from a string.
17///
18/// ```rust
19/// # #[macro_use]
20/// # extern crate serde_derive;
21/// # extern crate serde;
22/// # extern crate serde_xml_rs;
23/// # use serde_xml_rs::from_str;
24/// #[derive(Debug, Deserialize, PartialEq)]
25/// struct Item {
26///     name: String,
27///     source: String,
28/// }
29/// # fn main() {
30/// let s = r##"<item name="hello" source="world.rs" />"##;
31/// let item: Item = from_str(s).unwrap();
32/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
33/// # }
34/// ```
35pub fn from_str<'de, T: de::Deserialize<'de>>(s: &str) -> Result<T> {
36    from_reader(s.as_bytes())
37}
38
39
40/// A convenience method for deserialize some object from a reader.
41///
42/// ```rust
43/// # #[macro_use]
44/// # extern crate serde_derive;
45/// # extern crate serde;
46/// # extern crate serde_xml_rs;
47/// # use serde_xml_rs::from_reader;
48/// #[derive(Debug, Deserialize, PartialEq)]
49/// struct Item {
50///     name: String,
51///     source: String,
52/// }
53/// # fn main() {
54/// let s = r##"<item name="hello" source="world.rs" />"##;
55/// let item: Item = from_reader(s.as_bytes()).unwrap();
56/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
57/// # }
58/// ```
59pub fn from_reader<'de, R: Read, T: de::Deserialize<'de>>(reader: R) -> Result<T> {
60    T::deserialize(&mut Deserializer::new_from_reader(reader))
61}
62
63pub struct Deserializer<R: Read> {
64    depth: usize,
65    reader: EventReader<R>,
66    peeked: Option<XmlEvent>,
67    is_map_value: bool,
68}
69
70impl<'de, R: Read> Deserializer<R> {
71    pub fn new(reader: EventReader<R>) -> Self {
72        Deserializer {
73            depth: 0,
74            reader: reader,
75            peeked: None,
76            is_map_value: false,
77        }
78    }
79
80    pub fn new_from_reader(reader: R) -> Self {
81        let config = ParserConfig::new()
82            .trim_whitespace(true)
83            .whitespace_to_characters(true)
84            .cdata_to_characters(true)
85            .ignore_comments(true)
86            .coalesce_characters(true);
87
88        Self::new(EventReader::new_with_config(reader, config))
89    }
90
91    fn peek(&mut self) -> Result<&XmlEvent> {
92        if self.peeked.is_none() {
93            self.peeked = Some(self.inner_next()?);
94        }
95        debug_expect!(self.peeked.as_ref(), Some(peeked) => {
96            debug!("Peeked {:?}", peeked);
97            Ok(peeked)
98        })
99    }
100
101    fn inner_next(&mut self) -> Result<XmlEvent> {
102        loop {
103            match self.reader.next().map_err(ErrorKind::Syntax)? {
104                XmlEvent::StartDocument { .. } |
105                XmlEvent::ProcessingInstruction { .. } |
106                XmlEvent::Comment(_) => { /* skip */ },
107                other => return Ok(other),
108            }
109        }
110    }
111
112    fn next(&mut self) -> Result<XmlEvent> {
113        let next = if let Some(peeked) = self.peeked.take() {
114            peeked
115        } else {
116            self.inner_next()?
117        };
118        match next {
119            XmlEvent::StartElement { .. } => {
120                self.depth += 1;
121            },
122            XmlEvent::EndElement { .. } => {
123                self.depth -= 1;
124            },
125            _ => {},
126        }
127        debug!("Fetched {:?}", next);
128        Ok(next)
129    }
130
131    fn set_map_value(&mut self) {
132        self.is_map_value = true;
133    }
134
135    pub fn unset_map_value(&mut self) -> bool {
136        ::std::mem::replace(&mut self.is_map_value, false)
137    }
138
139    fn read_inner_value<V: de::Visitor<'de>, T, F: FnOnce(&mut Self) -> Result<T>>(
140        &mut self,
141        f: F,
142    ) -> Result<T> {
143        if self.unset_map_value() {
144            debug_expect!(self.next(), Ok(XmlEvent::StartElement { name, .. }) => {
145                let result = f(self)?;
146                self.expect_end_element(name)?;
147                Ok(result)
148            })
149        } else {
150            f(self)
151        }
152    }
153
154    fn expect_end_element(&mut self, start_name: OwnedName) -> Result<()> {
155        expect!(self.next()?, XmlEvent::EndElement { name, .. } => {
156            if name == start_name {
157                Ok(())
158            } else {
159                Err(ErrorKind::Custom(format!(
160                    "End tag </{}> didn't match the start tag <{}>",
161                    name.local_name,
162                    start_name.local_name
163                )).into())
164            }
165        })
166    }
167
168    fn prepare_parse_type<V: de::Visitor<'de>>(&mut self) -> Result<String> {
169        if let XmlEvent::StartElement { .. } = *self.peek()? {
170            self.set_map_value()
171        }
172        self.read_inner_value::<V, String, _>(|this| {
173            if let XmlEvent::EndElement { .. } = *this.peek()? {
174                return Err(
175                    ErrorKind::UnexpectedToken("EndElement".into(), "Characters".into()).into(),
176                );
177            }
178
179            expect!(this.next()?, XmlEvent::Characters(s) => {
180                return Ok(s)
181            })
182        })
183    }
184}
185
186macro_rules! deserialize_type {
187    ($deserialize:ident => $visit:ident) => {
188        fn $deserialize<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
189            let value = self.prepare_parse_type::<V>()?.parse()?;
190            visitor.$visit(value)
191        }
192    }
193}
194
195impl<'de, 'a, R: Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
196    type Error = Error;
197
198    forward_to_deserialize_any! {
199         identifier
200    }
201
202    fn deserialize_struct<V: de::Visitor<'de>>(
203        self,
204        _name: &'static str,
205        fields: &'static [&'static str],
206        visitor: V,
207    ) -> Result<V::Value> {
208        self.unset_map_value();
209        expect!(self.next()?, XmlEvent::StartElement { name, attributes, .. } => {
210            let map_value = visitor.visit_map(MapAccess::new(
211                self,
212                attributes,
213                fields.contains(&"$value")
214            ))?;
215            self.expect_end_element(name)?;
216            Ok(map_value)
217        })
218    }
219
220    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
221    where
222        V: de::Visitor<'de>,
223    {
224        visitor.visit_newtype_struct(self)
225    }
226
227    deserialize_type!(deserialize_i8 => visit_i8);
228    deserialize_type!(deserialize_i16 => visit_i16);
229    deserialize_type!(deserialize_i32 => visit_i32);
230    deserialize_type!(deserialize_i64 => visit_i64);
231    deserialize_type!(deserialize_u8 => visit_u8);
232    deserialize_type!(deserialize_u16 => visit_u16);
233    deserialize_type!(deserialize_u32 => visit_u32);
234    deserialize_type!(deserialize_u64 => visit_u64);
235    deserialize_type!(deserialize_f32 => visit_f32);
236    deserialize_type!(deserialize_f64 => visit_f64);
237    deserialize_type!(deserialize_bool => visit_bool);
238
239    fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
240        self.deserialize_string(visitor)
241    }
242
243    fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
244        self.deserialize_string(visitor)
245    }
246
247    fn deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
248        self.deserialize_string(visitor)
249    }
250
251    fn deserialize_byte_buf<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
252        self.deserialize_string(visitor)
253    }
254
255    fn deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
256        if let XmlEvent::StartElement { .. } = *self.peek()? {
257            self.set_map_value()
258        }
259        self.read_inner_value::<V, V::Value, _>(
260            |this| expect!(this.peek()?, &XmlEvent::EndElement { .. } => visitor.visit_unit()),
261        )
262    }
263
264    fn deserialize_unit_struct<V: de::Visitor<'de>>(
265        self,
266        _name: &'static str,
267        visitor: V,
268    ) -> Result<V::Value> {
269        self.deserialize_unit(visitor)
270    }
271
272    fn deserialize_tuple_struct<V: de::Visitor<'de>>(
273        self,
274        _name: &'static str,
275        len: usize,
276        visitor: V,
277    ) -> Result<V::Value> {
278        self.deserialize_tuple(len, visitor)
279    }
280
281    fn deserialize_tuple<V: de::Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
282        visitor.visit_seq(SeqAccess::new(self, Some(len))?)
283    }
284
285    fn deserialize_enum<V: de::Visitor<'de>>(
286        self,
287        _name: &'static str,
288        _variants: &'static [&'static str],
289        visitor: V,
290    ) -> Result<V::Value> {
291        self.read_inner_value::<V, V::Value, _>(|this| visitor.visit_enum(EnumAccess::new(this)))
292    }
293
294    fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
295        if let XmlEvent::StartElement { .. } = *self.peek()? {
296            self.set_map_value()
297        }
298        self.read_inner_value::<V, V::Value, _>(|this| {
299            if let XmlEvent::EndElement { .. } = *this.peek()? {
300                return visitor.visit_str("");
301            }
302            expect!(this.next()?, XmlEvent::Characters(s) => {
303                visitor.visit_string(s)
304            })
305        })
306    }
307
308    fn deserialize_seq<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
309        expect!(self.next(), Ok(XmlEvent::StartElement { name, .. }) => {
310                let result = visitor.visit_seq(SeqAccess::new(self, None)?);
311                self.expect_end_element(name)?;
312                result
313        })
314    }
315
316    fn deserialize_map<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
317        self.unset_map_value();
318        expect!(self.next()?, XmlEvent::StartElement { name, attributes, .. } => {
319            let map_value = visitor.visit_map(MapAccess::new(self, attributes, false))?;
320            self.expect_end_element(name)?;
321            Ok(map_value)
322        })
323    }
324
325    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
326        match *self.peek()? {
327            XmlEvent::EndElement { .. } => visitor.visit_none(),
328            _ => visitor.visit_some(self),
329        }
330    }
331
332    fn deserialize_ignored_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
333        self.unset_map_value();
334        let depth = self.depth;
335        loop {
336            self.next()?;
337            if self.depth == depth {
338                break;
339            }
340        }
341        visitor.visit_unit()
342    }
343
344    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
345        match *self.peek()? {
346            XmlEvent::StartElement { .. } => self.deserialize_map(visitor),
347            XmlEvent::EndElement { .. } => self.deserialize_unit(visitor),
348            _ => self.deserialize_string(visitor),
349        }
350    }
351}
serde_xml_rs2/de/mod.rs

serde_xml_rs2/de/
mod.rs
