easy_xml/
lib.rs

1extern crate easy_xml_derive;
2
3pub type OwnedName = xml::name::OwnedName;
4pub type OwnedAttribute = xml::attribute::OwnedAttribute;
5pub type Namespace = xml::namespace::Namespace;
6pub type XmlVersion = xml::common::XmlVersion;
7
8use std::{
9    borrow::Borrow,
10    cell::RefCell,
11    rc::{Rc, Weak},
12};
13
14#[derive(Debug, Clone)]
15pub struct XmlDocument {
16    pub version: XmlVersion,
17    pub encoding: String,
18    pub standalone: Option<bool>,
19    pub elements: Vec<XmlElement>,
20}
21
22#[derive(Debug, Clone)]
23pub enum XmlElement {
24    Text(String),
25    Node(Rc<RefCell<XmlNode>>),
26    Whitespace(String),
27    Comment(String),
28    CData(String),
29}
30
31#[derive(Debug, Clone)]
32pub struct XmlNode {
33    pub name: OwnedName,
34    pub attributes: Vec<OwnedAttribute>,
35    pub namespace: Namespace,
36    pub elements: Vec<XmlElement>,
37    pub parent: Option<Weak<RefCell<XmlNode>>>,
38}
39
40pub trait XmlDeserialize {
41    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
42    where
43        Self: Sized;
44}
45pub trait XmlSerialize {
46    fn serialize(&self, element: &mut XmlElement)
47    where
48        Self: Sized;
49}
50
51pub mod de;
52pub mod se;
53
54impl XmlNode {
55    pub fn text(&self, string: &mut String) {
56        for e in &self.elements {
57            e.text(string);
58        }
59    }
60
61    pub fn empty() -> Self {
62        XmlNode {
63            name: OwnedName {
64                local_name: String::new(),
65                namespace: None,
66                prefix: None,
67            },
68            attributes: Vec::new(),
69            namespace: Namespace::empty(),
70            elements: Vec::new(),
71            parent: None,
72        }
73    }
74}
75impl XmlElement {
76    pub fn text(&self, string: &mut String) {
77        match self {
78            XmlElement::Text(text) => string.push_str(text.as_str()),
79            XmlElement::Node(node) => {
80                let node = node.as_ref().borrow();
81                node.text(string);
82            }
83            XmlElement::Whitespace(_) => {}
84            XmlElement::Comment(_) => {}
85            XmlElement::CData(_) => {}
86        }
87    }
88}
89
90impl<T: XmlDeserialize> XmlDeserialize for Option<T>
91where
92    T: Sized,
93{
94    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
95    where
96        Self: Sized,
97    {
98        match T::deserialize(element) {
99            Ok(obj) => Ok(Some(obj)),
100            Err(_e) => Ok(None),
101        }
102    }
103}
104
105impl<T: XmlDeserialize> XmlDeserialize for Box<T>
106where
107    T: Sized,
108{
109    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
110    where
111        Self: Sized,
112    {
113        match T::deserialize(element) {
114            Ok(obj) => Ok(Box::new(obj)),
115            Err(e) => Err(e),
116        }
117    }
118}
119
120impl<T: XmlDeserialize> XmlDeserialize for std::rc::Rc<T>
121where
122    T: Sized,
123{
124    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
125    where
126        Self: Sized,
127    {
128        match T::deserialize(element) {
129            Ok(obj) => Ok(std::rc::Rc::new(obj)),
130            Err(e) => Err(e),
131        }
132    }
133}
134
135impl<T: XmlDeserialize> XmlDeserialize for std::sync::Arc<T>
136where
137    T: Sized,
138{
139    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
140    where
141        Self: Sized,
142    {
143        match T::deserialize(element) {
144            Ok(obj) => Ok(std::sync::Arc::new(obj)),
145            Err(e) => Err(e),
146        }
147    }
148}
149
150impl<T: XmlDeserialize> XmlDeserialize for std::cell::Cell<T>
151where
152    T: Sized,
153{
154    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
155    where
156        Self: Sized,
157    {
158        match T::deserialize(element) {
159            Ok(obj) => Ok(std::cell::Cell::new(obj)),
160            Err(e) => Err(e),
161        }
162    }
163}
164
165impl<T: XmlDeserialize> XmlDeserialize for std::cell::RefCell<T>
166where
167    T: Sized,
168{
169    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
170    where
171        Self: Sized,
172    {
173        match T::deserialize(element) {
174            Ok(obj) => Ok(std::cell::RefCell::new(obj)),
175            Err(e) => Err(e),
176        }
177    }
178}
179
180impl XmlDeserialize for String {
181    fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
182    where
183        Self: Sized,
184    {
185        let mut text = String::new();
186        element.text(&mut text);
187        Ok(text)
188    }
189}
190
191macro_rules! impl_de_for_number {
192    ($x:ty) => {
193        impl XmlDeserialize for $x {
194            fn deserialize(element: &XmlElement) -> Result<Self, de::Error>
195            where
196                Self: Sized,
197            {
198                let str = String::deserialize(element)?;
199                let str = str.trim();
200                match str.parse::<$x>() {
201                    Ok(val) => Ok(val),
202                    Err(_) => {
203                        let msg = format!("\"{}\" can not convert to number!", str);
204
205                        Err(de::Error::Other(msg))
206                    }
207                }
208            }
209        }
210    };
211}
212
213impl_de_for_number!(usize);
214impl_de_for_number!(isize);
215
216impl_de_for_number!(u8);
217impl_de_for_number!(u16);
218impl_de_for_number!(u32);
219impl_de_for_number!(u64);
220impl_de_for_number!(u128);
221
222impl_de_for_number!(i8);
223impl_de_for_number!(i16);
224impl_de_for_number!(i32);
225impl_de_for_number!(i64);
226impl_de_for_number!(i128);
227
228impl_de_for_number!(f32);
229impl_de_for_number!(f64);
230impl_de_for_number!(bool);
231
232// --------------------------------------------------------------------------------------------------------------------
233
234impl XmlSerialize for String {
235    fn serialize(&self, node: &mut XmlElement)
236    where
237        Self: Sized,
238    {
239        match node {
240            XmlElement::Text(text) => {
241                text.push_str(self.as_str());
242            }
243            XmlElement::Node(node) => {
244                node.as_ref()
245                    .borrow_mut()
246                    .elements
247                    .push(XmlElement::Text(self.clone()));
248            }
249            _ => {}
250        }
251    }
252}
253
254impl<T: XmlSerialize> XmlSerialize for Option<T> {
255    fn serialize(&self, element: &mut XmlElement)
256    where
257        Self: Sized,
258    {
259        match self {
260            Some(t) => {
261                t.serialize(element);
262            }
263            None => {}
264        }
265    }
266}
267
268impl<T: XmlSerialize> XmlSerialize for Box<T> {
269    fn serialize(&self, element: &mut XmlElement)
270    where
271        Self: Sized,
272    {
273        self.as_ref().serialize(element);
274    }
275}
276impl<T: XmlSerialize> XmlSerialize for Rc<T> {
277    fn serialize(&self, element: &mut XmlElement)
278    where
279        Self: Sized,
280    {
281        self.as_ref().serialize(element);
282    }
283}
284impl<T: XmlSerialize> XmlSerialize for std::sync::Arc<T> {
285    fn serialize(&self, element: &mut XmlElement)
286    where
287        Self: Sized,
288    {
289        self.as_ref().serialize(element);
290    }
291}
292
293impl<T: XmlSerialize> XmlSerialize for std::cell::Cell<T> {
294    fn serialize(&self, element: &mut XmlElement)
295    where
296        Self: Sized,
297    {
298        self.borrow().serialize(element);
299    }
300}
301
302impl<T: XmlSerialize> XmlSerialize for std::cell::RefCell<T> {
303    fn serialize(&self, element: &mut XmlElement)
304    where
305        Self: Sized,
306    {
307        self.borrow().serialize(element);
308    }
309}
310
311macro_rules! impl_se_for_number {
312    ($x:ty) => {
313        impl XmlSerialize for $x {
314            fn serialize(&self, element: &mut XmlElement)
315            where
316                Self: Sized,
317            {
318                match element {
319                    XmlElement::Text(text) => {
320                        text.push_str(self.to_string().as_str());
321                    }
322                    XmlElement::Node(node) => {
323                        node.as_ref()
324                            .borrow_mut()
325                            .elements
326                            .push(XmlElement::Text(self.to_string()));
327                    }
328                    _ => {}
329                }
330            }
331        }
332    };
333}
334
335impl_se_for_number!(usize);
336impl_se_for_number!(isize);
337
338impl_se_for_number!(u8);
339impl_se_for_number!(u16);
340impl_se_for_number!(u32);
341impl_se_for_number!(u64);
342impl_se_for_number!(u128);
343
344impl_se_for_number!(i8);
345impl_se_for_number!(i16);
346impl_se_for_number!(i32);
347impl_se_for_number!(i64);
348impl_se_for_number!(i128);
349
350impl_se_for_number!(f32);
351impl_se_for_number!(f64);
352impl_se_for_number!(bool);
easy_xml/lib.rs

easy_xml/
lib.rs
