structural_derive 0.4.3

Implementation detail of the structural 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

use std::fmt;

use typed_arena::Arena;

macro_rules! declare_arenas {
    (
        $( $field_name:ident : $arena_type:ty , )*
    ) => {
        pub(crate) struct Arenas {
            $( $field_name : Arena<$arena_type>, )*
        }

        impl Arenas{
            pub(crate) fn alloc<T>(&self, value:T)-> &T
            where
                Self:AllocMethods<T>
            {
                self.alloc_ref(value)
            }
        }

        impl Default for Arenas{
            fn default()->Self{
                Arenas{
                    $( $field_name:Arena::new(), )*
                }
            }
        }

        impl fmt::Debug for Arenas{
            fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{
                fmt::Debug::fmt("Arenas{..}",f)
            }
        }

        pub(crate) trait AllocMethods<T>{
            fn alloc_ref(&self, value: T) -> &T;
        }


        $(
            impl AllocMethods<$arena_type> for Arenas{
                fn alloc_ref(&self, value: $arena_type) -> &$arena_type {
                    self.$field_name.alloc(value)
                }
            }

        )*

    }
}

declare_arenas! {
    string: String,
    ident: syn::Ident,
    types: syn::Type,
    lit_int: syn::LitInt,
    type_param_bounds: crate::structural_alias_impl_mod::TypeParamBounds,
}