ector 0.9.0

Ector is an open source async, no-alloc actor framework for embedded devices.
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

use {
    ector::{mutex::NoopRawMutex, *},
    embassy_time::{Duration, Timer},
};

#[embassy_executor::main]
async fn main(s: embassy_executor::Spawner) {
    let server_0_addr: DynamicAddress<Request<String, String>> =
        actor!(s, server_0, Server, Server).into();
    let server_1_addr = actor!(s, server_1, Server, Server, NoopRawMutex).into();
    let server_2_addr = actor!(s, server_2, Server, Server, 2).into();
    let server_3_addr = actor!(s, server_3, Server, Server, NoopRawMutex, 2).into();

    static SERVER_4: ActorContext<Server> = ActorContext::new();
    static SERVER_5: ActorContext<Server, NoopRawMutex, 2> = ActorContext::new();
    let server_4_addr = spawn_context!(SERVER_4, s, server_4, Server, Server).into();
    let server_5_addr =
        spawn_context!(SERVER_5, s, server_5, Server, Server, NoopRawMutex, 2).into();

    // Array of DynamicAddress
    let servers = [
        server_0_addr,
        server_1_addr,
        server_2_addr,
        server_3_addr,
        server_4_addr,
        server_5_addr,
    ];
    loop {
        for (i, server) in servers.iter().enumerate() {
            let r = server.request("Hello".to_string()).await;
            println!("Server {} returned {}", i, r);
            Timer::after(Duration::from_secs(1)).await;
        }
    }
}

pub struct Server;

impl Actor for Server {
    type Message = Request<String, String>;
    async fn on_mount<M>(&mut self, _: DynamicAddress<Request<String, String>>, mut inbox: M) -> !
    where
        M: Inbox<Self::Message>,
    {
        println!("Server started!");

        loop {
            let motd = inbox.next().await;
            let m = motd.as_ref().clone();
            motd.reply(m).await;
        }
    }
}