1 use std::{io::Read, marker::PhantomData};
2
3 use log::debug;
4 use serde::de::{self, Unexpected};
5 use serde::forward_to_deserialize_any;
6 use xml::name::OwnedName;
7 use xml::reader::{EventReader, ParserConfig, XmlEvent};
8
9 use self::buffer::{BufferedXmlReader, ChildXmlBuffer, RootXmlBuffer};
10 use self::map::MapAccess;
11 use self::seq::SeqAccess;
12 use self::var::EnumAccess;
13 use crate::error::{Error, Result};
14 use crate::{debug_expect, expect};
15
16 mod buffer;
17 mod map;
18 mod seq;
19 mod 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 /// ```
from_str<'de, T: de::Deserialize<'de>>(s: &str) -> Result<T>40 pub 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 /// ```
from_reader<'de, R: Read, T: de::Deserialize<'de>>(reader: R) -> Result<T>63 pub 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
67 type RootDeserializer<R> = Deserializer<R, RootXmlBuffer<R>>;
68 type ChildDeserializer<'parent, R> = Deserializer<R, ChildXmlBuffer<'parent, R>>;
69
70 pub 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
82 impl<'de, R: Read> RootDeserializer<R> {
new(reader: EventReader<R>) -> Self83 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
new_from_reader(reader: R) -> Self95 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 /// ```
non_contiguous_seq_elements(mut self, set: bool) -> Self138 pub fn non_contiguous_seq_elements(mut self, set: bool) -> Self {
139 self.non_contiguous_seq_elements = set;
140 self
141 }
142 }
143
144 impl<'de, R: Read, B: BufferedXmlReader<R>> Deserializer<R, B> {
child<'a>(&'a mut self) -> Deserializer<R, ChildXmlBuffer<'a, R>>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.
peek(&mut self) -> Result<&XmlEvent>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.
next(&mut self) -> Result<XmlEvent>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
set_map_value(&mut self)188 fn set_map_value(&mut self) {
189 self.is_map_value = true;
190 }
191
unset_map_value(&mut self) -> bool192 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.
read_inner_value<V: de::Visitor<'de>, T, F: FnOnce(&mut Self) -> Result<T>>( &mut self, f: F, ) -> Result<T>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
expect_end_element(&mut self, start_name: OwnedName) -> Result<()>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
prepare_parse_type<V: de::Visitor<'de>>(&mut self) -> Result<String>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
248 macro_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
257 impl<'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
deserialize_struct<V: de::Visitor<'de>>( self, _name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value>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
deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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
deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>314 fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
315 self.deserialize_string(visitor)
316 }
317
deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>318 fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
319 self.deserialize_string(visitor)
320 }
321
deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>322 fn deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
323 self.deserialize_string(visitor)
324 }
325
deserialize_byte_buf<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>326 fn deserialize_byte_buf<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
327 self.deserialize_string(visitor)
328 }
329
deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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
deserialize_unit_struct<V: de::Visitor<'de>>( self, _name: &'static str, visitor: V, ) -> Result<V::Value>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
deserialize_newtype_struct<V: de::Visitor<'de>>( self, _name: &'static str, visitor: V, ) -> Result<V::Value>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
deserialize_tuple_struct<V: de::Visitor<'de>>( self, _name: &'static str, len: usize, visitor: V, ) -> Result<V::Value>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
deserialize_tuple<V: de::Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value>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
deserialize_enum<V: de::Visitor<'de>>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value>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
deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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
deserialize_seq<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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
deserialize_map<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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
deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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
deserialize_ignored_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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
deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value>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 }
435