derived 0.4.2

Derive macros for automating the boring stuff
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

use ::quote::quote;
use ::syn::Ident;

#[derive(Clone)]
pub enum DefExpr {
    Numeric,
    Boolean,
    Float,
    Char,
    Unit,
    CustomTuple(String),
    CustomArray(String),
}

impl DefExpr {
    /// Returns the base token's default value
    pub(super) fn into_base_token(self) -> quote::__private::TokenStream {
        match self {
            DefExpr::Boolean => {
                quote! {
                    false
                }
            }
            DefExpr::Char => {
                quote! {
                    '\0'
                }
            }
            DefExpr::Float => {
                quote! {
                    0.0
                }
            }
            DefExpr::Numeric => {
                quote! {
                    0
                }
            }
            DefExpr::Unit => {
                quote! {
                    ()
                }
            }
            DefExpr::CustomTuple(custom) => {
                let custom: quote::__private::TokenStream = custom.parse().unwrap();
                quote! {
                    (#custom)
                }
            }
            DefExpr::CustomArray(custom) => {
                let custom: quote::__private::TokenStream = custom.parse().unwrap();
                quote! {
                    [#custom]
                }
            }
        }
    }
    /// Returns tokens that finally resolves to `field: expr,`
    pub(super) fn into_tokens(self, ident: &Ident) -> quote::__private::TokenStream {
        let ret = self.into_base_token();
        quote! {
            #ident: #ret,
        }
    }
}

macro_rules! gen_defset {
    ($($ty:ty => $defexpr:expr),*) => {
        lazy_static::lazy_static! {
            pub(super) static ref CONSTDEF: ::std::collections::HashMap<&'static str, DefExpr> = {
                let mut hm = ::std::collections::HashMap::new();
                $(
                    hm.insert(stringify!($ty), $defexpr);
                )*
                hm
            };
        }
    };
}

gen_defset! {
    u8 => DefExpr::Numeric,
    i8 => DefExpr::Numeric,
    u16 => DefExpr::Numeric,
    i16 => DefExpr::Numeric,
    u32 => DefExpr::Numeric,
    i32 => DefExpr::Numeric,
    u64 => DefExpr::Numeric,
    i64 => DefExpr::Numeric,
    u128 => DefExpr::Numeric,
    i128 => DefExpr::Numeric,
    bool => DefExpr::Boolean,
    usize => DefExpr::Numeric,
    isize => DefExpr::Numeric,
    char => DefExpr::Char,
    f32  => DefExpr::Float,
    f64  => DefExpr::Float,
    () => DefExpr::Unit
}