warcrwlock 3.0.1

A crate in Rust that provides an attribute macro for structs and traits. Rewrite code using under the hood asynchronous reference (Arc) and asynchronous writing and read(RWlock) control elements.
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

use proc_macro2::TokenStream;
use quote::quote;
use syn::{ItemStruct, Ident};

use crate::helpers::{to_token_stream, full_base_struct_name, filter_generics};

mod util;

pub fn expansion(item_struct: ItemStruct, possible_reader_ident : Option<Ident>) -> TokenStream {
    let core_structure = util::normalizations::core_normalization(item_struct.clone());
    let wrapper_structure = util::normalizations::wrapper_normalization(item_struct.clone());
    let possible_reader_structure = if let Some(reader_ident) = possible_reader_ident {
        Some(util::reader_normalization::wrapper_normalization(item_struct.clone(),Some(reader_ident)))
    }else{None};
    //let import_other_attribute = to_token_stream(&format!("warcrwlock::{}",crate::helpers::ONLY_READ));
    let imports = quote! {
        use std::{
            fmt::Debug,
            ops::{Deref, DerefMut},
            sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
        };              
    };
    
    let vis = item_struct.vis.clone();
    let helpers =
    util::generations::generation_help_strutures_and_impls(&wrapper_structure);
    //panic!("helpers : \n{}",helpers.to_string());
    let fields = item_struct.fields.clone();
    let original_ident = item_struct.ident.clone();    
    let core_ident = to_token_stream(full_base_struct_name(original_ident.clone()));
    if let syn::Fields::Named(fields_named) = fields {
        let access_methods = util::generations::generation_access_fields_for_wrapper(
            item_struct.ident.clone(),
            fields_named.clone(),
            item_struct.generics.clone(),
            false
        );
        let possible_reader_access_methods = if let Some(reader_structure) = possible_reader_structure.clone(){
            Some(util::generations::generation_access_fields_for_wrapper(reader_structure.ident, fields_named, reader_structure.generics, true))
        } else{
            None
        };
              
        let struct_is_root = crate::helpers::struct_is_root(&item_struct).unwrap();
        let use_accessor = if struct_is_root{
            quote!(use crate::*;)
        }else{
            quote!(use super::*;)
        };
        let generics = item_struct.generics.clone();
        let filtered_generics = filter_generics(&generics);
        let reply = quote! {
            #vis type  #core_ident #generics = _core:: #original_ident #filtered_generics;
                #imports
                mod _core{                 
                    #use_accessor
                    #core_structure
                }
                #wrapper_structure
                #access_methods
                #possible_reader_structure
                #possible_reader_access_methods
                #helpers
        };
        return reply;
    }
    panic!("Structure fields must be named.")
}