xmlity 0.0.9

A (de)serialization library for XML
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

use crate::{de, ser::SerializeSeq, Deserialize, Deserializer, Serialize};

macro_rules! impl_serialize_tuple {
    (@impl $(($name:ident, $index:tt)),+) => {
        impl<$($name: Serialize),+> Serialize for ($($name,)+) {
            fn serialize<S: crate::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
                let mut seq = serializer.serialize_seq()?;
                $(seq.serialize_element(&self.$index)?;)+
                seq.end()
            }
        }
    };
    //Recursive case
    (($first_name:ident, $first_index:tt) $(,($name:ident, $index:tt))*) => {
        impl_serialize_tuple!(@impl ($first_name, $first_index) $(,($name, $index))*);
        impl_serialize_tuple!($(($name, $index)),*);
    };
    //Base case
    () => {};
}

impl_serialize_tuple!(
    (T16, 15),
    (T15, 14),
    (T14, 13),
    (T13, 12),
    (T12, 11),
    (T11, 10),
    (T10, 9),
    (T9, 8),
    (T8, 7),
    (T7, 6),
    (T6, 5),
    (T5, 4),
    (T4, 3),
    (T3, 2),
    (T2, 1),
    (T1, 0)
);

macro_rules! impl_deserialize_tuple {
    (@impl $(($name:ident)),+) => {
        impl<'de, $($name: Deserialize<'de>),*> Deserialize<'de> for ($($name,)*) {
            fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
                struct __Visitor<'__visitor, $($name),*> {
                    marker: ::core::marker::PhantomData<($($name,)*)>,
                    lifetime: ::core::marker::PhantomData<&'__visitor ()>,
                }
                impl<'__visitor, $($name: Deserialize<'__visitor>),*> de::Visitor<'__visitor> for __Visitor<'__visitor, $($name),*> {
                    type Value = ($($name,)*);
                    fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                        ::core::fmt::Formatter::write_str(formatter, "tuple")
                    }
                    fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
                    where
                        S: crate::de::SeqAccess<'__visitor>,
                    {
                        Ok(($(
                            seq.next_element_seq::<$name>()?.ok_or_else(de::Error::missing_data)?,
                        )*))
                    }
                    fn visit_none<E>(self) -> Result<Self::Value, E>
                    where
                        E: de::Error,
                    {
                        Ok(($(
                            <$name as Deserialize<'__visitor>>::deserialize(crate::types::utils::NoneDeserializer::new())?,
                        )*))
                    }
                }
                deserializer.deserialize_seq(__Visitor {
                    marker: ::core::marker::PhantomData,
                    lifetime: ::core::marker::PhantomData,
                })
            }
        }
    };
    //Recursive case
    (($first_name:ident) $(,($name:ident))*) => {
        impl_deserialize_tuple!(@impl ($first_name) $(,($name))*);
        impl_deserialize_tuple!($(($name)),*);
    };
    //Base case
    () => {};
}

impl_deserialize_tuple!(
    (T16),
    (T15),
    (T14),
    (T13),
    (T12),
    (T11),
    (T10),
    (T9),
    (T8),
    (T7),
    (T6),
    (T5),
    (T4),
    (T3),
    (T2),
    (T1)
);