moxy-derive 0.0.4

derive macros for moxy crate
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

mod build;
pub(crate) mod core;
mod default;
mod deref;
mod display;
mod forward;
mod get;
pub(crate) mod params;
mod set;
mod traits;
mod r#union;

use proc_macro::TokenStream;

pub(crate) use traits::*;

#[proc_macro_derive(Deref, attributes(moxy))]
pub fn derive_deref(tokens: TokenStream) -> TokenStream {
    match deref::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro_derive(Display, attributes(moxy))]
pub fn derive_display(tokens: TokenStream) -> TokenStream {
    match display::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro_derive(Build, attributes(moxy))]
pub fn derive_build(tokens: TokenStream) -> TokenStream {
    match build::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro_derive(Default, attributes(moxy))]
pub fn derive_default(tokens: TokenStream) -> TokenStream {
    match default::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro_derive(Get, attributes(moxy))]
pub fn derive_get(tokens: TokenStream) -> TokenStream {
    match get::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro_derive(Set, attributes(moxy))]
pub fn derive_set(tokens: TokenStream) -> TokenStream {
    match set::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro_derive(Forward, attributes(moxy))]
pub fn derive_forward(tokens: TokenStream) -> TokenStream {
    match forward::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro_derive(Union, attributes(moxy))]
pub fn derive_union(tokens: TokenStream) -> TokenStream {
    match r#union::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}

#[proc_macro]
pub fn unionize(tokens: TokenStream) -> TokenStream {
    match r#union::unionize::render(tokens) {
        Err(err) => err.to_compile_error().into(),
        Ok(v) => v.into(),
    }
}