sepserde_derive 0.9.0

XML Serialization and deserialization proc macros for IEEE 2030.5
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::common::YaSerdeAttribute;
use crate::ser::namespace::generate_namespaces_definition;
use proc_macro2::Ident;
use proc_macro2::TokenStream;
use quote::quote;
use syn::Generics;

pub fn implement_serializer(
    name: &Ident,
    root: &str,
    attributes: &YaSerdeAttribute,
    append_attributes: TokenStream,
    inner_inspector: TokenStream,
    generics: &Generics,
) -> TokenStream {
    let namespaces_definition = generate_namespaces_definition(attributes);
    let flatten = attributes.flatten;

    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
    let name_str = attributes.xml_element_name(name);

    quote! {
      impl #impl_generics ::sepserde::YaSerialize for #name #ty_generics #where_clause {
        fn name() -> &'static str
            where
                Self: Sized,
        {
          #name_str
        }
        #[allow(unused_variables)]
        fn serialize<W: ::std::io::Write>(
          &self,
          writer: &mut ::sepserde::ser::Serializer<W>,
        ) -> ::std::result::Result<(), ::std::string::String> where Self: Sized {
          let skip = writer.skip_start_end();

          if !#flatten && !skip {
            let mut child_attributes = ::std::vec![];
            let mut child_attributes_namespace = ::sepserde::xml::namespace::Namespace::empty();

            let yaserde_label = writer.get_start_event_name().unwrap_or_else(|| #root.to_string());
            let struct_start_event =
              ::sepserde::xml::writer::XmlEvent::start_element(yaserde_label.as_ref()) #namespaces_definition;
            #append_attributes

            let event: ::sepserde::xml::writer::events::XmlEvent = struct_start_event.into();

            if let ::sepserde::xml::writer::events::XmlEvent::StartElement {
              name,
              attributes,
              namespace,
            } = event {
              let mut attributes: ::std::vec::Vec<::sepserde::xml::attribute::OwnedAttribute> =
                attributes.into_owned().to_vec().iter().map(|k| k.to_owned()).collect();
              attributes.extend(child_attributes);
              let attributes = if writer.generic() {
                let mut tmp = vec![::sepserde::xml::attribute::OwnedAttribute {
                  name: ::sepserde::xml::name::OwnedName::local("xsi:type"),
                  value: <#name #ty_generics as ::sepserde::YaSerialize>::name().to_owned(),
                }];
                tmp.extend(attributes);
                tmp
              } else {
                attributes
              };

              let all_attributes = attributes.iter().map(|ca| ca.borrow()).collect();

              let mut all_namespaces = namespace.into_owned();
              all_namespaces.extend(&child_attributes_namespace);

              writer.write(::sepserde::xml::writer::events::XmlEvent::StartElement{
                name,
                attributes: ::std::borrow::Cow::Owned(all_attributes),
                namespace: ::std::borrow::Cow::Owned(all_namespaces)
              }).map_err(|e| e.to_string())?;
            } else {
              unreachable!()
            }
          }

          #inner_inspector

          if !#flatten && !skip {
            let struct_end_event = ::sepserde::xml::writer::XmlEvent::end_element();
            writer.write(struct_end_event).map_err(|e| e.to_string())?;
          }

          ::std::result::Result::Ok(())
        }

        fn serialize_attributes(
          &self,
          mut source_attributes: ::std::vec::Vec<::sepserde::xml::attribute::OwnedAttribute>,
          mut source_namespace: ::sepserde::xml::namespace::Namespace,
        ) -> ::std::result::Result<
          (::std::vec::Vec<::sepserde::xml::attribute::OwnedAttribute>, ::sepserde::xml::namespace::Namespace),
          ::std::string::String
        > where Self: Sized {
          let mut child_attributes = ::std::vec::Vec::<::sepserde::xml::attribute::OwnedAttribute>::new();
          let mut child_attributes_namespace = ::sepserde::xml::namespace::Namespace::empty();

          let struct_start_event =
            ::sepserde::xml::writer::XmlEvent::start_element("temporary_element_to_generate_attributes")
            #namespaces_definition;

          #append_attributes
          let event: ::sepserde::xml::writer::events::XmlEvent = struct_start_event.into();

          if let ::sepserde::xml::writer::events::XmlEvent::StartElement { attributes, namespace, .. } = event {
            source_namespace.extend(&namespace.into_owned());
            source_namespace.extend(&child_attributes_namespace);

            let a: ::std::vec::Vec<::sepserde::xml::attribute::OwnedAttribute> =
              attributes.into_owned().to_vec().iter().map(|k| k.to_owned()).collect();
            source_attributes.extend(a);
            source_attributes.extend(child_attributes);

            ::std::result::Result::Ok((source_attributes, source_namespace))
          } else {
            unreachable!();
          }
        }
      }
    }
}