serde_xml_rs/de/
mod.rs

Help
1use std::{io::Read, marker::PhantomData};
2
3use log::debug;
4use serde::de::{self, Unexpected};
5use serde::forward_to_deserialize_any;
6use xml::name::OwnedName;
7use xml::reader::{EventReader, ParserConfig, XmlEvent};
8
9use self::buffer::{BufferedXmlReader, ChildXmlBuffer, RootXmlBuffer};
10use self::map::MapAccess;
11use self::seq::SeqAccess;
12use self::var::EnumAccess;
13use crate::error::{Error, Result};
14use crate::{debug_expect, expect};
15
16mod buffer;
17mod map;
18mod seq;
19mod var;
20
21/// A convenience method for deserialize some object from a string.
22///
23/// ```rust
24/// # #[macro_use]
25/// # extern crate serde_derive;
26/// # extern crate serde;
27/// # extern crate serde_xml_rs;
28/// # use serde_xml_rs::from_str;
29/// #[derive(Debug, Deserialize, PartialEq)]
30/// struct Item {
31///     name: String,
32///     source: String,
33/// }
34/// # fn main() {
35/// let s = r##"<item name="hello" source="world.rs" />"##;
36/// let item: Item = from_str(s).unwrap();
37/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
38/// # }
39/// ```
40pub fn from_str<'de, T: de::Deserialize<'de>>(s: &str) -> Result<T> {
41    from_reader(s.as_bytes())
42}
43
44/// A convenience method for deserialize some object from a reader.
45///
46/// ```rust
47/// # #[macro_use]
48/// # extern crate serde_derive;
49/// # extern crate serde;
50/// # extern crate serde_xml_rs;
51/// # use serde_xml_rs::from_reader;
52/// #[derive(Debug, Deserialize, PartialEq)]
53/// struct Item {
54///     name: String,
55///     source: String,
56/// }
57/// # fn main() {
58/// let s = r##"<item name="hello" source="world.rs" />"##;
59/// let item: Item = from_reader(s.as_bytes()).unwrap();
60/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
61/// # }
62/// ```
63pub fn from_reader<'de, R: Read, T: de::Deserialize<'de>>(reader: R) -> Result<T> {
64    T::deserialize(&mut Deserializer::new_from_reader(reader))
65}
66
67type RootDeserializer<R> = Deserializer<R, RootXmlBuffer<R>>;
68type ChildDeserializer<'parent, R> = Deserializer<R, ChildXmlBuffer<'parent, R>>;
69
70pub struct Deserializer<
71    R: Read, // Kept as type param to avoid type signature breaking-change
72    B: BufferedXmlReader<R> = RootXmlBuffer<R>,
73> {
74    /// XML document nested element depth
75    depth: usize,
76    buffered_reader: B,
77    is_map_value: bool,
78    non_contiguous_seq_elements: bool,
79    marker: PhantomData<R>,
80}
81
82impl<'de, R: Read> RootDeserializer<R> {
83    pub fn new(reader: EventReader<R>) -> Self {
84        let buffered_reader = RootXmlBuffer::new(reader);
85
86        Deserializer {
87            buffered_reader,
88            depth: 0,
89            is_map_value: false,
90            non_contiguous_seq_elements: false,
91            marker: PhantomData,
92        }
93    }
94
95    pub fn new_from_reader(reader: R) -> Self {
96        let config = ParserConfig::new()
97            .trim_whitespace(true)
98            .whitespace_to_characters(true)
99            .cdata_to_characters(true)
100            .ignore_comments(true)
101            .coalesce_characters(true);
102
103        Self::new(EventReader::new_with_config(reader, config))
104    }
105
106    /// Configures whether the deserializer should search all sibling elements when building a
107    /// sequence. Not required if all XML elements for sequences are adjacent. Disabled by
108    /// default. Enabling this option may incur additional memory usage.
109    ///
110    /// ```rust
111    /// # #[macro_use]
112    /// # extern crate serde_derive;
113    /// # extern crate serde;
114    /// # extern crate serde_xml_rs;
115    /// # use serde_xml_rs::from_reader;
116    /// # use serde::Deserialize;
117    /// #[derive(Debug, Deserialize, PartialEq)]
118    /// struct Foo {
119    ///     bar: Vec<usize>,
120    ///     baz: String,
121    /// }
122    /// # fn main() {
123    /// let s = r##"
124    ///     <foo>
125    ///         <bar>1</bar>
126    ///         <bar>2</bar>
127    ///         <baz>Hello, world</baz>
128    ///         <bar>3</bar>
129    ///         <bar>4</bar>
130    ///     </foo>
131    /// "##;
132    /// let mut de = serde_xml_rs::Deserializer::new_from_reader(s.as_bytes())
133    ///     .non_contiguous_seq_elements(true);
134    /// let foo = Foo::deserialize(&mut de).unwrap();
135    /// assert_eq!(foo, Foo { bar: vec![1, 2, 3, 4], baz: "Hello, world".to_string()});
136    /// # }
137    /// ```
138    pub fn non_contiguous_seq_elements(mut self, set: bool) -> Self {
139        self.non_contiguous_seq_elements = set;
140        self
141    }
142}
143
144impl<'de, R: Read, B: BufferedXmlReader<R>> Deserializer<R, B> {
145    fn child<'a>(&'a mut self) -> Deserializer<R, ChildXmlBuffer<'a, R>> {
146        let Deserializer {
147            buffered_reader,
148            depth,
149            is_map_value,
150            non_contiguous_seq_elements,
151            ..
152        } = self;
153
154        Deserializer {
155            buffered_reader: buffered_reader.child_buffer(),
156            depth: *depth,
157            is_map_value: *is_map_value,
158            non_contiguous_seq_elements: *non_contiguous_seq_elements,
159            marker: PhantomData,
160        }
161    }
162
163    /// Gets the next XML event without advancing the cursor.
164    fn peek(&mut self) -> Result<&XmlEvent> {
165        let peeked = self.buffered_reader.peek()?;
166
167        debug!("Peeked {:?}", peeked);
168        Ok(peeked)
169    }
170
171    /// Gets the XML event at the cursor and advances the cursor.
172    fn next(&mut self) -> Result<XmlEvent> {
173        let next = self.buffered_reader.next()?;
174
175        match next {
176            XmlEvent::StartElement { .. } => {
177                self.depth += 1;
178            }
179            XmlEvent::EndElement { .. } => {
180                self.depth -= 1;
181            }
182            _ => {}
183        }
184        debug!("Fetched {:?}", next);
185        Ok(next)
186    }
187
188    fn set_map_value(&mut self) {
189        self.is_map_value = true;
190    }
191
192    pub fn unset_map_value(&mut self) -> bool {
193        ::std::mem::replace(&mut self.is_map_value, false)
194    }
195
196    /// If `self.is_map_value`: Performs the read operations specified by `f` on the inner content of an XML element.
197    /// `f` is expected to consume the entire inner contents of the element. The cursor will be moved to the end of the
198    /// element.
199    /// If `!self.is_map_value`: `f` will be performed without additional checks/advances for an outer XML element.
200    fn read_inner_value<V: de::Visitor<'de>, T, F: FnOnce(&mut Self) -> Result<T>>(
201        &mut self,
202        f: F,
203    ) -> Result<T> {
204        if self.unset_map_value() {
205            debug_expect!(self.next(), Ok(XmlEvent::StartElement { name, .. }) => {
206                let result = f(self)?;
207                self.expect_end_element(name)?;
208                Ok(result)
209            })
210        } else {
211            f(self)
212        }
213    }
214
215    fn expect_end_element(&mut self, start_name: OwnedName) -> Result<()> {
216        expect!(self.next()?, XmlEvent::EndElement { name, .. } => {
217            if name == start_name {
218                Ok(())
219            } else {
220                Err(Error::Custom { field: format!(
221                    "End tag </{}> didn't match the start tag <{}>",
222                    name.local_name,
223                    start_name.local_name
224                ) })
225            }
226        })
227    }
228
229    fn prepare_parse_type<V: de::Visitor<'de>>(&mut self) -> Result<String> {
230        if let XmlEvent::StartElement { .. } = *self.peek()? {
231            self.set_map_value()
232        }
233        self.read_inner_value::<V, String, _>(|this| {
234            if let XmlEvent::EndElement { .. } = *this.peek()? {
235                return Err(Error::UnexpectedToken {
236                    token: "EndElement".into(),
237                    found: "Characters".into(),
238                });
239            }
240
241            expect!(this.next()?, XmlEvent::Characters(s) => {
242                return Ok(s)
243            })
244        })
245    }
246}
247
248macro_rules! deserialize_type {
249    ($deserialize:ident => $visit:ident) => {
250        fn $deserialize<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
251            let value = self.prepare_parse_type::<V>()?.parse()?;
252            visitor.$visit(value)
253        }
254    };
255}
256
257impl<'de, 'a, R: Read, B: BufferedXmlReader<R>> de::Deserializer<'de>
258    for &'a mut Deserializer<R, B>
259{
260    type Error = Error;
261
262    forward_to_deserialize_any! {
263        identifier
264    }
265
266    fn deserialize_struct<V: de::Visitor<'de>>(
267        self,
268        _name: &'static str,
269        fields: &'static [&'static str],
270        visitor: V,
271    ) -> Result<V::Value> {
272        self.unset_map_value();
273        expect!(self.next()?, XmlEvent::StartElement { name, attributes, .. } => {
274            let map_value = visitor.visit_map(MapAccess::new(
275                self,
276                attributes,
277                fields.contains(&"$value")
278            ))?;
279            self.expect_end_element(name)?;
280            Ok(map_value)
281        })
282    }
283
284    deserialize_type!(deserialize_i8 => visit_i8);
285    deserialize_type!(deserialize_i16 => visit_i16);
286    deserialize_type!(deserialize_i32 => visit_i32);
287    deserialize_type!(deserialize_i64 => visit_i64);
288    deserialize_type!(deserialize_u8 => visit_u8);
289    deserialize_type!(deserialize_u16 => visit_u16);
290    deserialize_type!(deserialize_u32 => visit_u32);
291    deserialize_type!(deserialize_u64 => visit_u64);
292    deserialize_type!(deserialize_f32 => visit_f32);
293    deserialize_type!(deserialize_f64 => visit_f64);
294
295    fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
296        if let XmlEvent::StartElement { .. } = *self.peek()? {
297            self.set_map_value()
298        }
299        self.read_inner_value::<V, V::Value, _>(|this| {
300            if let XmlEvent::EndElement { .. } = *this.peek()? {
301                return visitor.visit_bool(false);
302            }
303            expect!(this.next()?, XmlEvent::Characters(s) => {
304                match s.as_str() {
305                    "true" | "1" => visitor.visit_bool(true),
306                    "false" | "0" => visitor.visit_bool(false),
307                    _ => Err(de::Error::invalid_value(Unexpected::Str(&s), &"a boolean")),
308                }
309
310            })
311        })
312    }
313
314    fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
315        self.deserialize_string(visitor)
316    }
317
318    fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
319        self.deserialize_string(visitor)
320    }
321
322    fn deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
323        self.deserialize_string(visitor)
324    }
325
326    fn deserialize_byte_buf<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
327        self.deserialize_string(visitor)
328    }
329
330    fn deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
331        if let XmlEvent::StartElement { .. } = *self.peek()? {
332            self.set_map_value()
333        }
334        self.read_inner_value::<V, V::Value, _>(
335            |this| expect!(this.peek()?, &XmlEvent::EndElement { .. } => visitor.visit_unit()),
336        )
337    }
338
339    fn deserialize_unit_struct<V: de::Visitor<'de>>(
340        self,
341        _name: &'static str,
342        visitor: V,
343    ) -> Result<V::Value> {
344        self.deserialize_unit(visitor)
345    }
346
347    fn deserialize_newtype_struct<V: de::Visitor<'de>>(
348        self,
349        _name: &'static str,
350        visitor: V,
351    ) -> Result<V::Value> {
352        visitor.visit_newtype_struct(self)
353    }
354
355    fn deserialize_tuple_struct<V: de::Visitor<'de>>(
356        self,
357        _name: &'static str,
358        len: usize,
359        visitor: V,
360    ) -> Result<V::Value> {
361        self.deserialize_tuple(len, visitor)
362    }
363
364    fn deserialize_tuple<V: de::Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
365        let child_deserializer = self.child();
366
367        visitor.visit_seq(SeqAccess::new(child_deserializer, Some(len)))
368    }
369
370    fn deserialize_enum<V: de::Visitor<'de>>(
371        self,
372        _name: &'static str,
373        _variants: &'static [&'static str],
374        visitor: V,
375    ) -> Result<V::Value> {
376        self.read_inner_value::<V, V::Value, _>(|this| visitor.visit_enum(EnumAccess::new(this)))
377    }
378
379    fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
380        if let XmlEvent::StartElement { .. } = *self.peek()? {
381            self.set_map_value()
382        }
383        self.read_inner_value::<V, V::Value, _>(|this| {
384            if let XmlEvent::EndElement { .. } = *this.peek()? {
385                return visitor.visit_str("");
386            }
387            expect!(this.next()?, XmlEvent::Characters(s) => {
388                visitor.visit_string(s)
389            })
390        })
391    }
392
393    fn deserialize_seq<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
394        let child_deserializer = self.child();
395
396        visitor.visit_seq(SeqAccess::new(child_deserializer, None))
397    }
398
399    fn deserialize_map<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
400        self.unset_map_value();
401        expect!(self.next()?, XmlEvent::StartElement { name, attributes, .. } => {
402            let map_value = visitor.visit_map(MapAccess::new(self, attributes, false))?;
403            self.expect_end_element(name)?;
404            Ok(map_value)
405        })
406    }
407
408    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
409        match *self.peek()? {
410            XmlEvent::EndElement { .. } => visitor.visit_none(),
411            _ => visitor.visit_some(self),
412        }
413    }
414
415    fn deserialize_ignored_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
416        self.unset_map_value();
417        let depth = self.depth;
418        loop {
419            self.next()?;
420            if self.depth == depth {
421                break;
422            }
423        }
424        visitor.visit_unit()
425    }
426
427    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
428        match *self.peek()? {
429            XmlEvent::StartElement { .. } => self.deserialize_map(visitor),
430            XmlEvent::EndElement { .. } => self.deserialize_unit(visitor),
431            _ => self.deserialize_string(visitor),
432        }
433    }
434}
serde_xml_rs/de/mod.rs

serde_xml_rs/de/
mod.rs
