interthread 3.1.0

Auto implementation of the Actor Model
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::model::{ add_bounds, ImplVars, OneshotChannel, ConstVars, ModelOutput, MethodNew, ModelGenerics ,GenWork};
use quote::quote;
use proc_macro2::TokenStream;
use syn::{Generics,ReturnType,Type,parse_quote,FnArg,Signature };
use proc_macro_error::abort;

#[derive(Clone)]
pub struct TySend {
    send: Option<syn::Meta>,
}

impl TySend {

    pub fn set_send(&mut self, meta: syn::Meta ){
        self.send = Some(meta); 
    }

    pub fn is_send(&self)-> bool{
        !self.send.is_some()
    }

    pub fn is_not_send(&self)-> bool{
        self.send.is_some()
    }
    
    pub fn get_send(&mut self) -> Option<syn::Meta> {
        self.send.clone()
    }

    pub fn get_play_actor_init_block( impl_vars: &ImplVars, play_actor_init: &TokenStream ) -> TokenStream {

        let ImplVars{oneshot, met_new, const_vars, script_name,
            direct_play_mut_token,..} = impl_vars;
        let ConstVars{play,short_actor,short_error,actor,.. } = const_vars;
        if let Some(met_new) = met_new {

             let init_block = match &met_new.mod_output {

                ModelOutput::Result(path,_ ) => {
                    let ok_msg = quote!{ #path :: Ok (())};
                    let ok_send_call = oneshot.send_call(ok_msg,script_name,play);

                    let err_msg = quote!{ #path :: Err (#short_error)};
                    let err_send_call = oneshot.send_call(err_msg,script_name,play);

                    quote!{

                        let #direct_play_mut_token #actor = 

                            match  #play_actor_init {
                                #path :: Ok ( #short_actor ) => { #ok_send_call ; #short_actor },
                                #path :: Err (#short_error ) => { let _ = #err_send_call ; return }
                            };

                    }

                },
                ModelOutput::Option(path)   => {
                    let some_msg = quote!{ #path :: Some (())};
                    let some_send_call = oneshot.send_call(some_msg,script_name,play);

                    let none_msg = quote!{ #path :: None };
                    let none_send_call = oneshot.send_call(none_msg,script_name,play);

                    quote!{

                        let #direct_play_mut_token #actor = 

                            match  #play_actor_init {
                                #path :: Some ( #short_actor ) => { #some_send_call ; #short_actor },
                                #path :: None  => { let _ = #none_send_call ; return }
                            };

                    }
                },
                ModelOutput::None       => {

                    let send_call = oneshot.send_call(quote!{()},script_name,play);

                    quote!{

                        let #direct_play_mut_token #actor = #play_actor_init ;
                        let _ = #send_call ;

                    }
                }
            };
            return init_block;
        } else { 
            panic!("InternalError model::argument::send::TySend::get_play_actor_init Expecting this call when 'met_new' is Some.")
        }


    }
    
    /// for signature method 'new'; extract ReturnType and return a Type for oneshot::Sender ( when model is !Send ) 
    pub fn get_oneshot_fn_arg_sender_type( met_new_sig: &Signature, oneshot: &OneshotChannel ) -> FnArg {

        let ty = match &met_new_sig.output {
            ReturnType::Default => {abort!(met_new_sig,"InternalError.'argument::send::TySend::get_oneshot_fn_arg_sender_type'. Unexpected return type for method 'new'.")},
            ReturnType::Type(_,ty) => {*ty.clone()},
        };

        let old: Type = parse_quote!(Self);
        let new: Type = parse_quote!(());
        let new_ty = crate::model::replace(&ty,&old,&new);

        syn::parse2(oneshot.pat_type_send(&new_ty)).unwrap()
    }

    /// Returns updated Generics for method 'play'
    pub fn add_model_gen_bounds_and_update_play_gen(&self, met_new: Option<&mut MethodNew>, mod_gen: &mut ModelGenerics ) -> Option<Generics> {

        if self.is_not_send(){
            let mut play_gen = mod_gen.private_gen.clone();
            let met_new = met_new.unwrap();
            
            // extend params
            play_gen.params.extend( met_new.met.sig.generics.params.iter().cloned());
            // extend predicates
            if let Some(w_c) = &met_new.met.sig.generics.where_clause {
                play_gen.make_where_clause().predicates.extend(w_c.predicates.iter().cloned());
            }

            let new_sig = met_new.met.sig.clone();
            // add model bounds for 'live_gen' and 'met_new_gen' if they are present in method arguments
            for gen in [&mut met_new.met.sig.generics, &mut mod_gen.live_gen ]{
                let mut gen_work = GenWork::new(gen,self.is_send());
                gen_work.retain_i(&new_sig);
                for param in &gen_work.difference(){
                    add_bounds(param,gen);
                }
            }
            return Some(play_gen);
        }
        None
    }

}



impl Default for TySend {
    fn default()  -> TySend {
        Self{ send: None } 
    }
}