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
232impl 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);