yaaf 0.2.0

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

#![forbid(unsafe_code)]

//! Yet Another Actor Framework
//!
//! A simple, local actor framework.
//!
//! # Key Features
//!
//! - Compile time checks on message publishing.
//! - Simple UX.
//!
//! ## Example
//!
//! ```rust
//! # use ::std::time::Duration;
//! # use ::tokio::time::sleep;
//! # use ::yaaf::prelude::*;
//! #
//! #[derive(Clone, Debug)]
//! struct Ping;
//! #[derive(Clone, Debug)]
//! struct Pong;
//!
//! // A long-lived Source that can publish events.
//! #[derive(Source)]
//! #[publish(Ping)]
//! struct Server;
//!
//! #[async_trait]
//! impl Source for Server {
//!     async fn run(mut self, mut ctx: Context<Self>) {
//!         // Broadcast a message to all handlers
//!         ctx.publish(Ping);
//!     }
//! }
//!
//! // An Actor that receives and sends events.
//! #[derive(Actor)]
//! #[handle(Ping)]
//! #[publish(Pong)]
//! struct Paddle;
//!
//! #[async_trait]
//! impl Handler<Ping> for Paddle {
//!     async fn handle(&mut self, ctx: &mut Context<Self>, _message: Ping) {
//!         // Broadcast a message to all handlers
//!         ctx.publish(Pong);
//!     }
//! }
//!
//! // An Actor that only receives events
//! #[derive(Actor)]
//! #[handle(Pong)]
//! struct Floor;
//!
//! #[async_trait]
//! impl Handler<Pong> for Floor {
//!     async fn handle(&mut self, _ctx: &mut Context<Self>, _message: Pong) {
//!         println!("Received message");
//!     }
//! }
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn ::std::error::Error>> {
//!     let mut system = System::new().await?;
//!
//!     let server = Server;
//!     let paddle1 = Paddle;
//!     let paddle2 = Paddle;
//!     let floor = Floor;
//!
//!     system.add_source(server).await?;
//!
//!     let paddle_addr = system.add_actor(paddle1).await?;
//!     system.add_actor(paddle2).await?;
//!     let floor_addr = system.add_actor(floor).await?;
//!
//!     // Send messages directly to actors
//!     paddle_addr.tell(Ping);
//!     floor_addr.tell(Pong);
//!
//!     sleep(Duration::from_millis(50));
//!
//!     system.shutdown().await?;
//!     Ok(())
//! }
//! ```

mod actor;
mod context;
mod handler;
mod mailbox;
mod message;
mod publisher;
mod router;
mod source;
mod system;

pub mod error;
pub mod prelude;

pub use crate::actor::ActorAddress;
pub use crate::handler::HandlerRegistered;
pub use crate::message::Message;
#[doc(inline)]
pub use crate::prelude::*;
pub use crate::publisher::Publisher;
pub use crate::source::SourceMeta;