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

use syn::DeriveInput;
use crate::debug;


fn impl_hierarchical_one_to_n_single_tuple_struct(ast: &DeriveInput) -> proc_macro2::TokenStream {
    let name = &ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let param_tokens = debug::impl_debug_parameter(ast);

    if let syn::Data::Struct(struct_data) = &ast.data {
        let field = struct_data.fields.iter().next().unwrap();
        let field_ty = &field.ty;
        let crate_name = match super::rinecs_crate_name(){
            Ok(crate_name) => crate_name,
            Err(err) => return err.to_compile_error(),
        };
        let component_tokens = quote! {
            impl #impl_generics #crate_name::Component for #name #ty_generics #where_clause {
                type Storage = #crate_name::storage::OneToNForest<#name>;
                type MutStorageCacheGuard = ();
                fn type_name() -> &'static str{
                    concat!(module_path!(), "::", stringify!(#name))
                }

                fn is_reference() -> bool { false }
            }

            impl #impl_generics #crate_name::HierarchicalOneToNComponent for #name #ty_generics #where_clause{

            }

            impl #impl_generics ::std::ops::Deref for #name #ty_generics #where_clause {
                type Target = #field_ty;
                fn deref(&self) -> &#field_ty{
                    &self.0
                }
            }

            impl #impl_generics ::std::ops::DerefMut for #name #ty_generics #where_clause {
                fn deref_mut(&mut self) -> &mut #field_ty{
                    &mut self.0
                }
            }
        };
        param_tokens.into_iter().chain(component_tokens.into_iter()).collect()
    }else{
        unreachable!()
    }
}

fn impl_hierarchical_one_to_n_other_structs(ast: &DeriveInput) -> proc_macro2::TokenStream {
    let name = &ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let param_tokens = debug::impl_debug_parameter(ast);
    let crate_name = match super::rinecs_crate_name(){
        Ok(crate_name) => crate_name,
        Err(err) => return err.to_compile_error(),
    };
    let component_tokens = quote! {
        impl #impl_generics #crate_name::Component for #name #ty_generics #where_clause {
            type Storage = #crate_name::storage::OneToNForest<#name>;
            type MutStorageCacheGuard = ();
            fn type_name() -> &'static str{
                concat!(module_path!(), "::", stringify!(#name))
            }

            fn is_reference() -> bool { false }
        }

        impl #impl_generics #crate_name::HierarchicalOneToNComponent for #name #ty_generics #where_clause{

        }
    };
    param_tokens.into_iter().chain(component_tokens.into_iter()).collect()
}

pub fn impl_hierarchical_one_to_n_component(ast: &DeriveInput) -> proc_macro2::TokenStream {
    match &ast.data{
		syn::Data::Struct(struct_data) => match &struct_data.fields {
            syn::Fields::Unnamed(_) => {
                let fields = struct_data.fields.iter().collect::<Vec<_>>();
                if fields.len() == 1{
                    return impl_hierarchical_one_to_n_single_tuple_struct(ast);
                }
            }
            _ => (),
        }
        _ => ()
	}
    impl_hierarchical_one_to_n_other_structs(ast)
}