act_rs_smol 0.1.0

Act.rs smol is a minimal smol oriented actor framework.
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

/**

    Generates an async oriented actor to be instantiated within an async runtime context.

    The state type that is provided to the produced spawn method must implement:

    ActorStateAsync

    or

    async fn pre_run_async(&mut sel) -> bool;

    async fn run_async(&mut self) -> bool;

    async fn post_run_async(self);

    directly

    Also smol::{Executor, Task} and paste::paste must be in module scope.

    The latter is a macro from the [paste crate](https://crates.io/crates/paste).

    Works with version 1.0.15 and above.



    The name of the state type is generated from the provided $actor_type.

    As part of the macro output process "State" is appended to the provided $actor_type macro identity parameter, this type is required by the generated spawn method.
    


    The returned bool values from the pre_run_async and run_async method implementations indicate whether or not the actors execution should proceed.

    The post_run_async method is called regardless.

*/
#[macro_export]
macro_rules! impl_mac_task_actor
{

    ($actor_type:ident) =>
    {

        paste!
        {

            pub struct $actor_type
            {
            }

            impl $actor_type
            {

                pub fn spawn(state: [<$actor_type State>], ex: &Executor)
                {
                    
                    let task = ex.spawn(async move {

                        $actor_type::run(state).await;

                    });

                    task.detach();

                }

                pub fn spawn_attached(state: [<$actor_type State>], ex: &Executor) -> Task<()>
                {
                    
                    ex.spawn(async move {
                
                        $actor_type::run(state).await;

                    })

                }

                async fn run(mut state: [<$actor_type State>])
                {

                    let mut proceed = true; 
                    
                    if state.pre_run_async().await
                    {

                        while proceed
                        {
                            
                            proceed = state.run_async().await;
                
                        }

                    }

                    state.post_run_async().await;

                }

            }
            
        }

    }

}

/**
 * Similar to impl_mac_task_actor, but the produced spawn method takes an actor state builder object instead of the actor state itself.
 * 
 * Requires everything that impl_mac_task_actor does, but also that an actor state builder type with a method "build_async" that returns an optional actor state object share the scope of the macro call.
 * 
 * The actor state builder type name consists of the provided actor type name with "StateBuilder" appended.
 * 
 * Note that if build_async returns a None value then none of the run methods are called (including post_run_async).
*/
#[macro_export]
macro_rules! impl_mac_task_actor_built_state
{

    ($actor_type:ident) =>
    {

        paste!
        {

            pub struct $actor_type
            {
            }

            impl $actor_type
            {

                pub fn spawn(state_builder: [<$actor_type StateBuilder>], ex: &Executor)
                {
                    
                    let task = ex.spawn(async move {

                        $actor_type::run(state_builder).await;

                    });

                    task.detach();

                }

                pub fn spawn_attached(state_builder: [<$actor_type StateBuilder>], ex: &Executor) -> Task<()>
                {
                    
                    let task = ex.spawn(async move {

                        $actor_type::run(state_builder).await;

                    })

                }

                async fn run(mut state_builder: [<$actor_type StateBuilder>])
                {

                    let mut opt_state = state_builder.build_async().await;

                    if let Some(mut state) = opt_state
                    {

                        let mut proceed = true; 
                        
                        if state.pre_run_async().await
                        {

                            while proceed
                            {
                                
                                proceed = state.run_async().await;
                    
                            }

                        }

                        state.post_run_async().await;

                    }

                }

            }
            
        }

    }

}