xtor 0.9.10

Async Actor framework for Rust which is blazing fast and rock solid.
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

//! # Xtor: An handler async actor framework.
//! [![Rust](https://github.com/starcoinorg/xtor/actions/workflows/rust.yml/badge.svg)](https://github.com/starcoinorg/xtor/actions/workflows/rust.yml)
//!
//! ## Key features
//! - small: very small codebase
//! - async: allow you to write async code in your actor
//! - full featured: we have built-in types such as `Supervisor` `Broker`
//!   `Caller` and so on
//! - both dynamic and fast: typed message and weak typed event.
//!
//! ## usage
//!
//! add `xtor` to your library
//! ```sh
//! cargo add xtor
//! ```
//!
//! write some code
//! ```
//! use anyhow::Result;
//! use async_trait::async_trait;
//! use xtor::actor::{context::Context, message::Handler, runner::Actor};
//!
//! // first define actor
//! struct HelloActor;
//! impl Actor for HelloActor {}
//!
//! // then define message
//! #[xtor::message(result = "()")]
//! #[derive(Debug)]
//! struct Hello;
//!
//! // then impl the handler
//! #[async_trait]
//! impl Handler<Hello> for HelloActor {
//!     async fn handle(&self, _ctx: &Context, msg: Hello) -> Result<()> {
//!         println!("{:?} received", &msg);
//!         Ok(())
//!     }
//! }
//!
//! // main will finish when all actors died out.
//! #[xtor::main]
//! async fn main() -> Result<()> {
//!     let hello_actor = HelloActor;
//!     let hello_actor_address = hello_actor.spawn().await?;
//!     hello_actor_address.call::<HelloActor, Hello>(Hello).await
//! }
//! ```
//!
//! ## More Examples?
//! please take a look at the examples folder in the [repository](https://github.com/starcoinorg/xtor).

#![feature(type_name_of_val)]
#![feature(once_cell)]

use actor::runner::ACTOR_ID_HANDLE;
use futures::Future;

#[cfg(test)]
mod tests;

pub use xtor_derive::{main, message, test};

/// the core of xtor
pub mod actor;
/// default implemention of broker, supervisor and so on.
pub mod utils;

pub use actor::*;

/// exports to the derive macro
#[inline(always)]
pub async fn await_exit() {
    loop {
        if ACTOR_ID_HANDLE.is_empty() {
            break;
        } else {
            tokio::time::sleep(std::time::Duration::from_millis(1)).await;
        }
    }
}

/// exports to the derive macro
pub fn block_on<F, T>(future: F) -> T
where
    F: Future<Output = T>,
{
    let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime");
    rt.block_on(future)
}