gesha-macros 0.0.4

Macors for Gesha proejct
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

#[macro_export]
macro_rules! impl_enum_serde {
    (
        $enum_name:ident {
            $(
                $type:ident: [
                    $(($variant:ident, $value:expr)),*
                ],
            )*
        }
    ) => {
        impl serde::Serialize for $enum_name {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: ::serde::Serializer,
            {
                match *self {
                    $($(
                        $enum_name::$variant => $crate::private_impl_serialize_variant!{
                            $type [serializer, $value]
                        },
                    )*)*
                }
            }
        }
        impl<'de> serde::Deserialize<'de> for $enum_name {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct VisitorImpl;
                impl<'de> serde::de::Visitor<'de> for VisitorImpl {
                    type Value = $enum_name;
                    fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                        let variants = vec![
                            $($(stringify!($value),)*)*
                        ];
                        write!(formatter, "{}", variants.join(" or "))
                    }
                    $(
                        $crate::private_impl_deserialize_variant! {
                            $enum_name,
                            $type [$($value => $variant),*]
                        }
                    )*
                }
                deserializer.deserialize_any(VisitorImpl)
            }
        }
    };
}

#[macro_export]
macro_rules! private_impl_deserialize_variant {
    ($enum_name:ident, u64 [ $($value:expr => $variant:ident),* ]) => {
        $crate::private_impl_deserialize_variant! { $enum_name, visit_u64, u64 [$($value => $variant),*] }
    };
    ($enum_name:ident, i64 [ $($value:expr => $variant:ident),* ]) => {
        $crate::private_impl_deserialize_variant! { $enum_name, visit_i64, i64 [$($value => $variant),*] }
    };
    ($enum_name:ident, str [ $($value:expr => $variant:ident),* ]) => {
        $crate::private_impl_deserialize_variant! { $enum_name, visit_str, &str [$($value => $variant),*] }
    };
    ($enum_name:ident, bool [ $($value:expr => $variant:ident),* ]) => {
        $crate::private_impl_deserialize_variant! { $enum_name, visit_bool, bool [$($value => $variant),*] }
    };
    ($enum_name:ident, null [ $($value:expr => $variant:ident),* ]) => {
        $crate::private_impl_deserialize_variant! { $enum_name, visit_unit [$($value => $variant),*] }
    };
    (
        $enum_name:ident,
        $fn_name:ident,
        $type:ty [ $($value:expr => $variant:ident),* ]
    ) => {
        fn $fn_name<E>(self, value: $type) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            match value {
                $(
                    $value => Ok($enum_name::$variant),
                )*
                _ => Err(E::unknown_variant(&value.to_string(), &[
                    $(stringify!($value)),*
                ])),
            }
        }
    };
    (
        $enum_name:ident,
        visit_unit [ $($value:expr => $variant:ident),* ]
    ) => {
        fn visit_unit<E>(self) -> Result<Self::Value, E>
        where
            E: serde::de::Error,
        {
            $(
                Ok($enum_name::$variant)
            ),*
        }
    };
}

#[macro_export]
macro_rules! private_impl_serialize_variant {
    (u64 [$serializer:ident, $value:expr]) => {
        $serializer.serialize_u64($value)
    };
    (i64 [$serializer:ident, $value:expr]) => {
        $serializer.serialize_i64($value)
    };
    (str [$serializer:ident, $value:expr]) => {
        $serializer.serialize_str($value)
    };
    (bool [$serializer:ident, $value:expr]) => {
        $serializer.serialize_bool($value)
    };
    (null [$serializer:ident, $value:expr]) => {
        $serializer.serialize_none()
    };
}