serde_xml_rs/de/
mod.rs

1mod child;
2mod map;
3mod plain;
4mod reader;
5mod seq;
6mod var;
7
8use self::{
9    child::ChildDeserializer,
10    map::MapAccess,
11    plain::PlainTextDeserializer,
12    reader::{Event, RootReader},
13    var::EnumAccess,
14};
15use crate::{
16    config::SerdeXml,
17    error::{Error, Result},
18};
19use log::trace;
20use reader::Reader;
21use serde::{de::Visitor, Deserialize};
22use std::io::Read;
23use xml::EventReader;
24
25/// A convenience method for deserialize some object from a string.
26///
27/// ```rust
28/// # use serde::{Deserialize, Serialize};
29/// # use serde_xml_rs::from_str;
30/// #[derive(Debug, Deserialize, PartialEq)]
31/// struct Item {
32///     name: String,
33///     source: String,
34/// }
35/// # fn main() {
36/// let s = r##"<item><name>hello</name><source>world.rs</source></item>"##;
37/// let item: Item = from_str(s).unwrap();
38/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
39/// # }
40/// ```
41pub fn from_str<'de, T: Deserialize<'de>>(s: &str) -> Result<T> {
42    from_reader(s.as_bytes())
43}
44
45/// A convenience method for deserialize some object from a reader.
46///
47/// ```rust
48/// # use serde::Deserialize;
49/// # use serde_xml_rs::from_reader;
50/// #[derive(Debug, Deserialize, PartialEq)]
51/// struct Item {
52///     name: String,
53///     source: String,
54/// }
55/// # fn main() {
56/// let s = r##"<item><name>hello</name><source>world.rs</source></item>"##;
57/// let item: Item = from_reader(s.as_bytes()).unwrap();
58/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
59/// # }
60/// ```
61pub fn from_reader<'de, T: Deserialize<'de>, R: Read>(reader: R) -> Result<T> {
62    T::deserialize(&mut Deserializer::from_config(SerdeXml::default(), reader))
63}
64
65pub struct Deserializer<R: Read> {
66    reader: RootReader<R>,
67}
68
69impl<R: Read> Deserializer<R> {
70    pub fn new(reader: EventReader<R>) -> Self {
71        Self {
72            reader: RootReader::new(reader, false),
73        }
74    }
75
76    pub fn new_from_reader(reader: R) -> Self {
77        Self::from_config(SerdeXml::default(), reader)
78    }
79
80    pub fn from_config(config: SerdeXml, source: R) -> Self {
81        Self {
82            reader: RootReader::new(
83                config.parser.create_reader(source),
84                config.overlapping_sequences,
85            ),
86        }
87    }
88}
89
90macro_rules! deserialize_type {
91    ($deserialize:ident => $visit:ident) => {
92        fn $deserialize<V: ::serde::de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
93            self.reader.start_element()?;
94            let value = self.reader.chars()?.parse()?;
95            self.reader.end_element()?;
96            visitor.$visit(value)
97        }
98    };
99}
100
101impl<'de, R: Read> serde::Deserializer<'de> for &mut Deserializer<R> {
102    type Error = Error;
103
104    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
105    where
106        V: Visitor<'de>,
107    {
108        Err(Error::Unsupported("deserialize any"))
109    }
110
111    deserialize_type!(deserialize_bool => visit_bool);
112    deserialize_type!(deserialize_i8 => visit_i8);
113    deserialize_type!(deserialize_i16 => visit_i16);
114    deserialize_type!(deserialize_i32 => visit_i32);
115    deserialize_type!(deserialize_i64 => visit_i64);
116    deserialize_type!(deserialize_u8 => visit_u8);
117    deserialize_type!(deserialize_u16 => visit_u16);
118    deserialize_type!(deserialize_u32 => visit_u32);
119    deserialize_type!(deserialize_u64 => visit_u64);
120    deserialize_type!(deserialize_f32 => visit_f32);
121    deserialize_type!(deserialize_f64 => visit_f64);
122
123    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
124    where
125        V: Visitor<'de>,
126    {
127        self.deserialize_string(visitor)
128    }
129
130    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
131    where
132        V: Visitor<'de>,
133    {
134        self.deserialize_string(visitor)
135    }
136
137    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
138    where
139        V: Visitor<'de>,
140    {
141        self.reader.start_element()?;
142        let text = if matches!(self.reader.peek()?, Event::Text(_)) {
143            self.reader.chars()?
144        } else {
145            "".to_string()
146        };
147        let value = visitor.visit_string::<Self::Error>(text)?;
148        self.reader.end_element()?;
149        Ok(value)
150    }
151
152    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>
153    where
154        V: Visitor<'de>,
155    {
156        Err(Error::Unsupported("bytes"))
157    }
158
159    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>
160    where
161        V: Visitor<'de>,
162    {
163        Err(Error::Unsupported("byte buf"))
164    }
165
166    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
167    where
168        V: Visitor<'de>,
169    {
170        match self.reader.peek()? {
171            Event::EndElement => visitor.visit_none(),
172            _ => visitor.visit_some(self),
173        }
174    }
175
176    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
177    where
178        V: Visitor<'de>,
179    {
180        visitor.visit_unit()
181    }
182
183    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
184    where
185        V: Visitor<'de>,
186    {
187        trace!("Root unit struct '{name}'");
188        self.reader.start_element()?;
189        let value = visitor.visit_unit::<Self::Error>()?;
190        self.reader.end_element()?;
191        Ok(value)
192    }
193
194    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
195    where
196        V: Visitor<'de>,
197    {
198        trace!("Root newtype struct '{name}'");
199        self.reader.start_element()?;
200        let value = visitor.visit_newtype_struct(ChildDeserializer::new(self.reader.child()))?;
201        self.reader.end_element()?;
202        Ok(value)
203    }
204
205    fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value>
206    where
207        V: Visitor<'de>,
208    {
209        Err(Error::Unsupported("sequence in document root"))
210    }
211
212    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
213    where
214        V: Visitor<'de>,
215    {
216        trace!("Root tuple");
217        self.reader.start_element()?;
218        let text = self.reader.chars()?;
219        let value = visitor.visit_seq(PlainTextDeserializer::new(&text))?;
220        self.reader.end_element()?;
221        Ok(value)
222    }
223
224    fn deserialize_tuple_struct<V>(
225        self,
226        name: &'static str,
227        len: usize,
228        visitor: V,
229    ) -> Result<V::Value>
230    where
231        V: Visitor<'de>,
232    {
233        trace!("Root tuple struct '{name}'");
234        self.deserialize_tuple(len, visitor)
235    }
236
237    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
238    where
239        V: Visitor<'de>,
240    {
241        trace!("Root map");
242        self.reader.start_element()?;
243        let value = visitor.visit_map(MapAccess::new_map(self.reader.child()))?;
244        self.reader.end_element()?;
245        Ok(value)
246    }
247
248    fn deserialize_struct<V>(
249        self,
250        name: &'static str,
251        fields: &'static [&'static str],
252        visitor: V,
253    ) -> Result<V::Value>
254    where
255        V: Visitor<'de>,
256    {
257        trace!("Root struct '{name}'");
258        let element = self.reader.start_element()?;
259        let value = visitor.visit_map(MapAccess::new_struct(
260            self.reader.child(),
261            element.attributes,
262            fields,
263        ))?;
264        self.reader.end_element()?;
265        Ok(value)
266    }
267
268    fn deserialize_enum<V>(
269        self,
270        name: &'static str,
271        _variants: &'static [&'static str],
272        visitor: V,
273    ) -> Result<V::Value>
274    where
275        V: Visitor<'de>,
276    {
277        trace!("Root enum '{name}'");
278        self.reader.start_element()?;
279        let value = visitor.visit_enum(EnumAccess::new(self.reader.child()))?;
280        self.reader.end_element()?;
281        Ok(value)
282    }
283
284    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
285    where
286        V: Visitor<'de>,
287    {
288        unreachable!()
289    }
290
291    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
292    where
293        V: Visitor<'de>,
294    {
295        unreachable!()
296    }
297}
serde_xml_rs/de/mod.rs

serde_xml_rs/de/
mod.rs
