rustorm_codegen 0.20.0

code gen provides macro for generating code on data access objects on table metadata
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

use quote;
use syn;

pub fn impl_from_dao(ast: &syn::MacroInput) -> quote::Tokens {
    let name = &ast.ident;
    let fields: Vec<(&syn::Ident, &syn::Ty)> = match ast.body {
        syn::Body::Struct(ref data) => {
            match *data {
                syn::VariantData::Struct(ref fields) => {
                    fields
                        .iter()
                        .map(|f| {
                            let ident = f.ident.as_ref().unwrap();
                            let ty = &f.ty;
                            (ident, ty)
                        })
                        .collect::<Vec<_>>()
                }
                _ => panic!("Only struct is supported for #[derive(FromDao)]"),
            }
        }
        syn::Body::Enum(_) => panic!("#[derive(FromDao)] can only be used with structs"),
    };
    let from_fields: Vec<quote::Tokens> = fields
        .iter()
        .map(|&(field, _ty)| {
            quote! { #field: dao.get(stringify!(#field)).unwrap(),}
        })
        .collect();

    quote! {
        impl rustorm_dao::FromDao for  #name {

            fn from_dao(dao: &rustorm_dao::Dao) -> Self {
                #name {
                    #(#from_fields)*
                }

            }
        }
    }
}

pub fn impl_to_dao(ast: &syn::MacroInput) -> quote::Tokens {
    let name = &ast.ident;
    let generics = &ast.generics;
    let fields: Vec<(&syn::Ident, &syn::Ty)> = match ast.body {
        syn::Body::Struct(ref data) => {
            match *data {
                syn::VariantData::Struct(ref fields) => {
                    fields
                        .iter()
                        .map(|f| {
                            let ident = f.ident.as_ref().unwrap();
                            let ty = &f.ty;
                            (ident, ty)
                        })
                        .collect::<Vec<_>>()
                }
                _ => panic!("Only struct is supported for #[derive(ToDao)]"),
            }
        }
        syn::Body::Enum(_) => panic!("#[derive(ToDao)] can only be used with structs"),
    };
    let from_fields: &Vec<quote::Tokens> = &fields
        .iter()
        .map(|&(field, _ty)| {
            quote! { dao.insert(stringify!(#field), &self.#field);}
        })
        .collect();

    quote! {
        impl #generics rustorm_dao::ToDao for #name #generics {
            fn to_dao(&self) -> rustorm_dao::Dao {
                let mut dao = rustorm_dao::Dao::new();
                #(#from_fields)*
                dao
            }
        }

    }
}

#[cfg(test)]
mod tests {}