spatialos-macro 0.2.4

Procmacro crate used to expand SpatialOS component and types created with spatialos-codegen
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

use proc_macro::TokenStream;
use syn::{Ident, ItemEnum, Variant};

use super::get_value;

#[derive(Debug)]
pub struct VariantAST {
    pub value: u32,
    pub name: Ident,
}

impl From<&Variant> for VariantAST {
    fn from(input: &Variant) -> Self {
        let name = input.ident.clone();
        let value = get_value(&input.attrs).expect("Can't find value for variant");
        Self { name, value }
    }
}

#[derive(Debug)]
pub struct EnumAST<'a> {
    pub name: &'a Ident,
    pub variants: Vec<VariantAST>,
}

impl<'a> From<&'a ItemEnum> for EnumAST<'a> {
    fn from(input: &'a ItemEnum) -> Self {
        let name = &input.ident;
        let variants = input
            .variants
            .iter()
            .map(VariantAST::from)
            .collect::<Vec<_>>();
        Self { name, variants }
    }
}

impl<'a> Into<TokenStream> for EnumAST<'a> {
    fn into(self) -> TokenStream {
        let name = self.name;

        let from_u32 = {
            let variants = self
                .variants
                .iter()
                .map(|variant| {
                    let value = variant.value;
                    let ident = &variant.name;
                    quote! { #value => #name :: #ident}
                })
                .collect::<Vec<_>>();
            quote! {
                impl From<u32> for #name {
                    fn from(data: u32) -> Self {
                        match data {
                            #(#variants,)*
                            _ => panic!("Invalid data")
                        }
                    }
                }
            }
        };

        let into_u32 = {
            let variants = self
                .variants
                .iter()
                .map(|variant| {
                    let value = variant.value;
                    let ident = &variant.name;
                    quote! { #name :: #ident => #value}
                })
                .collect::<Vec<_>>();
            quote! {
                impl Into<u32> for #name {
                    fn into(self) -> u32 {
                        match self {
                            #(#variants,)*
                        }
                    }
                }

                impl Into<u32> for &#name {
                    fn into(self) -> u32 {
                        match *self {
                            #(#variants,)*
                        }
                    }
                }
            }
        };

        let as_ref = {
            quote! {
                impl AsRef<#name> for #name {
                    fn as_ref(&self) -> &#name {
                        self
                    }
                }
            }
        };

        let result = quote! {
            #[automatically_derived]
            #[allow(unused_qualifications)]
            #from_u32

            #[automatically_derived]
            #[allow(unused_qualifications)]
            #into_u32

            #[automatically_derived]
            #[allow(unused_qualifications)]
            #as_ref
        };
        result.into()
    }
}