xavier-derive 0.1.7

Derive module of Xavier. Xavier is a lightweight and versatile XML parsing library designed to streamline the process of handling XML data with ease and efficiency.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use proc_macro2::TokenStream;
use quote::quote;
use syn::DeriveInput;
use crate::common::meta::{MetaInfo, MetaName};
use crate::common::naming::names::XmlNames;
use crate::deserialize::parser::complex::tokens::segments::TokenSegments;

pub struct XmlComplex;

impl XmlComplex {
    pub fn parse(input: &DeriveInput) -> TokenStream {

        let obj_meta_info = MetaInfo::from_name(&input.attrs, MetaName::XML);
        let xml_tag_name = XmlNames::root(&input, obj_meta_info.as_ref());

        let tokens = TokenSegments::tokens_from(input, obj_meta_info.as_ref());
        let declarations = tokens.declarations;
        let attribute_setters = tokens.attribute_setters;
        let field_setters = tokens.field_setters;
        let sibling_setters = tokens.sibling_setters;
        let value_setters = tokens.value_setters;
        let xmlns_setter = tokens.xmlns_setter;
        let constructor =  tokens.constructor;
        let gen = quote! {

            #(#declarations)*

            if let Some(start_event) = start_event {
                for xa_attribute in start_event.attributes() {
                    let xa_attr_name = String::from_utf8(xa_attribute.as_ref()?.key.0.to_vec())?;
                    let xa_attr_value = xavier::deserialize::decode::decode_xml(&String::from_utf8(xa_attribute.as_ref()?.value.to_vec())?);

                    #(#attribute_setters)*
                    #xmlns_setter
                }
            }

            loop {
                match reader.read_event() {
                    Err(error) =>  {
                        return Err(PError::new(&format!("Error at position {}: {:?}", reader.buffer_position(), error)))
                    },
                    Ok(::xavier::quick_xml::events::Event::Start(event)) => {
                        let xa_tag_name = String::from_utf8(event.name().0.to_vec())?;

                        #(#field_setters)*
                        #(#sibling_setters)*
                    },
                    Ok(::xavier::quick_xml::events::Event::Empty(event)) => {
                        let xa_tag_name = String::from_utf8(event.name().0.to_vec())?;
                        #(#field_setters)*
                        #(#sibling_setters)*
                    },
                    Ok(::xavier::quick_xml::events::Event::Text(event)) => {
                        #(#value_setters)*
                    },
                    Ok(::xavier::quick_xml::events::Event::CData(event)) => {
                        #(#value_setters)*
                    },
                    Ok(::xavier::quick_xml::events::Event::End(event)) => {
                        let end_tag_name = if let Some(outer_tag_name) = outer_tag_name {
                            outer_tag_name
                        } else {
                            #xml_tag_name
                        };
                        if String::from_utf8(event.name().0.to_vec())? == end_tag_name {
                            #constructor
                        }
                    },
                    Ok(::xavier::quick_xml::events::Event::Eof) => { break },
                    Ok(::xavier::quick_xml::events::Event::Decl(_)) => {},
                    Ok(::xavier::quick_xml::events::Event::PI(_)) => {},
                    Ok(::xavier::quick_xml::events::Event::DocType(_)) => {},
                    Ok(::xavier::quick_xml::events::Event::Comment(_)) => {}
                };
            };
            Err(xavier::PError::new("Error object not found"))
        };

        let mut result = quote! {};
        result.extend(gen);
        result
    }
}