Trait Actor 

pub trait Actor:
    Sized
    + Send
    + 'static {
    // Provided methods
    fn started<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        ctx: &'life1 mut Context<Self>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn stopped<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        ctx: &'life1 mut Context<Self>,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn start_default<'async_trait>(    ) -> Pin<Box<dyn Future<Output = Result<Addr<Self>>> + Send + 'async_trait>>
       where Self: Default + 'async_trait { ... }
    fn start<'async_trait>(
        self,
    ) -> Pin<Box<dyn Future<Output = Result<Addr<Self>>> + Send + 'async_trait>>
       where Self: 'async_trait { ... }
}

Actors are objects which encapsulate state and behavior. Actors run within a specific execution context Context<A>. The context object is available only during execution. Each actor has a separate execution context.

Roles communicate by exchanging messages. The requester can wait for a response. By Addr referring to the actors, the actors must provide an Handle<T> implementation for this message. All messages are statically typed.

Provided Methods

fn started<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut Context<Self>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called when the actor is first started.

fn stopped<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut Context<Self>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called after an actor is stopped.

fn start_default<'async_trait>() -> Pin<Box<dyn Future<Output = Result<Addr<Self>>> + Send + 'async_trait>>

where Self: Default + 'async_trait,

Construct and start a new actor, returning its address.

This is constructs a new actor using the Default trait, and invokes its start method.

fn start<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<Addr<Self>>> + Send + 'async_trait>>

where Self: 'async_trait,

Start a new actor, returning its address.

Examples

use xactor::*;

struct MyActor;

impl Actor for MyActor {}

#[message(result = "i32")]
struct MyMsg(i32);

#[async_trait::async_trait]
impl Handler<MyMsg> for MyActor {
    async fn handle(&mut self, _ctx: &mut Context<Self>, msg: MyMsg) -> i32 {
        msg.0 * msg.0
    }
}

#[xactor::main]
async fn main() -> Result<()> {
    // Start actor and get its address
    let mut addr = MyActor.start().await?;

    // Send message `MyMsg` to actor via addr
    let res = addr.call(MyMsg(10)).await?;
    assert_eq!(res, 100);
    Ok(())
}

Examples found in repository

examples/main.rs (line 29)

async fn main() -> Result<()> {
    // Exit the program after 3 seconds
    let addr = MyActor.start().await?;
    addr.wait_for_stop().await;
    Ok(())
}

examples/subscriber.rs (line 11)

async fn main() -> std::io::Result<()> {
    let parent_addr = SubscriberParent::new().await.start().await.unwrap();
    parent_addr.wait_for_stop().await;
    Ok(())
}

// Subscriber Parent - A

struct SubscriberParent {
    children_subscribers: Vec<Addr<Subscriber>>,
    message_producer: Addr<MessageProducer>,
}

impl SubscriberParent {
    async fn new() -> SubscriberParent {
        SubscriberParent {
            children_subscribers: Vec::new(),
            message_producer: MessageProducer::new().start().await.unwrap(),
        }
    }
}

#[async_trait::async_trait]
impl Actor for SubscriberParent {
    async fn started(&mut self, ctx: &mut Context<Self>) -> Result<()> {
        println!("Subscriber Parent Started");
        let _ = ctx.address().send(InitializeChildSubscribers);
        Ok(())
    }
}

#[message]
struct InitializeChildSubscribers;

#[async_trait::async_trait]
impl Handler<InitializeChildSubscribers> for SubscriberParent {
    async fn handle(&mut self, _ctx: &mut Context<Self>, _msg: InitializeChildSubscribers) {
        let message_producer_addr = self.message_producer.clone();
        let dummy_ids: Vec<i32> = vec![1, 2, 3, 4, 5];
        let children_unstarted_actors_vec = dummy_ids.into_iter().map(move |id| {
            let id = id.clone();
            let addr = message_producer_addr.clone();

            Subscriber::new(id, addr)
        });

        let children_addr_vec = children_unstarted_actors_vec
            .into_iter()
            .map(|actor| async { actor.start().await.unwrap() });

        let children_addr_vec = futures::future::join_all(children_addr_vec).await;

        self.children_subscribers = children_addr_vec;
    }

examples/ping.rs (line 27)

async fn main() -> Result<()> {
    // start new actor
    let addr = MyActor { count: 10 }.start().await?;

    // send message and get future for result
    let res = addr.call(Ping(10)).await?;
    println!("RESULT: {}", res == 20);

    Ok(())
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T: Message<Result = ()>> Actor for Broker<T>