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
119
120
121
122

use proc_macro2::Span;
use syn::{DeriveInput, Meta, NestedMeta, Ident};
use crate::debug;
use crate::changes::*;

fn hierarchical_storage(ast: &DeriveInput, name: &Ident, ty_generics: &syn::TypeGenerics) -> proc_macro2::TokenStream{
    let storage = ast.attrs.iter()
        .filter_map(|attr| attr.parse_meta().ok().and_then(|meta| match meta {
            Meta::List(ref list) if list.path.is_ident("storage") => Some(list.clone()),
            _ => None,
        }))
        .next()
        .and_then(|list| list.nested.first().and_then(|attr| match attr {
            NestedMeta::Meta(item) => Some(item.clone()),
            _ => None,
        }))
        .and_then(|attr| match attr {
            Meta::Path(path) => Some(path.segments.first().unwrap().ident.clone()),
            _ => None,
        })
        .unwrap_or(Ident::new("Forest", Span::call_site()));
    let crate_name = match super::rinecs_crate_name(){
        Ok(crate_name) => crate_name,
        Err(err) => return err.to_compile_error(),
    };

    let storage = quote!(#crate_name::storage::#storage<#name #ty_generics>);

    if changes(ast){
        quote!(#crate_name::storage::Changed<#storage, #name #ty_generics>)
    }else if autochanges(ast) {
        quote!(#crate_name::storage::AutoChanged<#storage, #name #ty_generics>)
    }else{
        storage
    }
}


fn impl_hierarchical_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);

    let storage = hierarchical_storage(ast, name, &ty_generics);
    let crate_name = match super::rinecs_crate_name(){
        Ok(crate_name) => crate_name,
        Err(err) => return err.to_compile_error(),
    };

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

                fn is_reference() -> bool { false }
            }

            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_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 storage = hierarchical_storage(ast, name, &ty_generics);
    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 = #storage;
            type MutStorageCacheGuard = ();
            fn type_name() -> &'static str{
                concat!(module_path!(), "::", stringify!(#name))
            }

            fn is_reference() -> bool { false }
        }
    };
    param_tokens.into_iter().chain(component_tokens.into_iter()).collect()
}

pub fn impl_hierarchical_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_single_tuple_struct(ast);
                }
            }
            _ => (),
        }
        _ => ()
	}
    impl_hierarchical_other_structs(ast)
}