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
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

#![macro_use]
#![cfg_attr(not(feature = "std"), no_std)]
#![allow(dead_code)]
#![allow(async_fn_in_trait)]
#![doc = include_str!("../README.md")]

pub(crate) mod fmt;

mod actor;
mod drop;
pub use {actor::*, ector_macros};

// Reexport mutex types
pub mod mutex {
    pub use embassy_sync::blocking_mutex::raw::*;
}

#[cfg(feature = "test-utils")]
pub mod testutils;

/// Spawn an actor given a spawner and the actors name, type and instance.
///
/// actor! is a macro that simplifies the process of spawning an actor. It creates a new ActorContext and spawns the actor with the given spawner.
///
/// # Arguments
///
/// `actor!(spawner, name, type, instance, [mutex type], [queue size]);`
///
/// |             |                                                                                                        |
/// | ----------- | ------------------------------------------------------------------------------------------------------ |
/// | spawner     | The spawner to use to spawn the actor (i.e. embassy_executor::Spawner)                                 |
/// | name        | The name of the actor, used to generate the task name                                                  |
/// | type        | The type of the actor, must implement the Actor trait                                                  |
/// | instance    | The instance of the actor to spawn                                                                     |
/// | mutex type  | The type of mutex to use for the actor. (defaults to embassy_sync::blocking_mutex::raw::NoopRawMutex)  |
/// | queue size  | The size of the actor's message queue. (defaults to 1)                                                 |
///
///
/// # Example
///
/// ```rust ignore
/// use ector::*;
///
/// type Addr = DynamicAddress<Request<String, String>>;
///
/// struct Server;
///
/// impl Actor for Server {
///     type Message = Request<String, String>;
///     async fn on_mount<M>(&mut self, _: Addr, 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;
///        }
///    }
/// }
///
/// #[embassy_executor::main]
/// async fn main(s: embassy_executor::Spawner) {
///     let server_addr: Addr = actor!(s, server, Server, Server).into();
///     loop {
///          let r = server_addr.request("Hello".to_string()).await;
///          println!("Server returned {}", r);
///     }
/// }
///
/// ```
#[macro_export]
macro_rules! actor {
    ($spawner:ident, $name:ident, $ty:ty, $instance:expr) => {{
        ::ector::actor!(
            $spawner,
            $name,
            $ty,
            $instance,
            ::ector::mutex::NoopRawMutex,
            1
        )
    }};

    ($spawner:ident, $name:ident, $ty:ty, $instance:expr, $mutex:ty) => {{ ::ector::actor!($spawner, $name, $ty, $instance, $mutex, 1) }};

    ($spawner:ident, $name:ident, $ty:ty, $instance:expr, $queue_size:expr) => {{
        ::ector::actor!(
            $spawner,
            $name,
            $ty,
            $instance,
            ::ector::mutex::NoopRawMutex,
            $queue_size
        )
    }};

    ($spawner:ident, $name:ident, $ty:ty, $instance:expr, $mutex:ty, $queue_size:expr) => {{
        static CONTEXT: ::ector::ActorContext<$ty, $mutex, $queue_size> =
            ::ector::ActorContext::new();
        ::ector::spawn_context!(
            CONTEXT,
            $spawner,
            $name,
            $ty,
            $instance,
            $mutex,
            $queue_size
        )
    }};
}

/// Spawn an ActorContext for a given spawner
#[macro_export]
macro_rules! spawn_context {
    ($context:ident, $spawner:ident, $name:ident, $ty:ty, $instance:expr) => {{
        ::ector::spawn_context!(
            $context,
            $spawner,
            $name,
            $ty,
            $instance,
            ::ector::mutex::NoopRawMutex,
            1
        )
    }};

    ($context:ident, $spawner:ident, $name:ident, $ty:ty, $instance:expr, $mutex:ty) => {{ ::ector::spawn_context!($context, $spawner, $name, $ty, $instance, $mutex, 1) }};

    ($context:ident, $spawner:ident, $name:ident, $ty:ty, $instance:expr, $queue_size:expr) => {{
        ::ector::spawn_context!(
            $context,
            $spawner,
            $name,
            $ty,
            $instance,
            ::ector::mutex::NoopRawMutex,
            $queue_size
        )
    }};

    ($context:ident, $spawner:ident, $name:ident, $ty:ty, $instance:expr, $mutex:ty, $queue_size:expr) => {{
        #[embassy_executor::task]
        async fn $name(a: &'static ::ector::ActorContext<$ty, $mutex, $queue_size>, instance: $ty) {
            a.mount(instance).await
        }

        let address = $context.address();
        $spawner.spawn($name(&$context, $instance)).unwrap();
        address
    }};
}