Struct Context 

pub struct Context<A> { /* private fields */ }

Available to the actor in every execution call.

The context is used to interact with the actor system. You can start intervals, send messages to yourself, and stop the actor.

Implementations

impl<A: Actor> Context<A>

Life-cycle

pub fn stop(&self) -> Result<()>

Stop the actor.

impl<A: Actor> Context<A>

Child Actors

pub fn add_child(&mut self, child: impl Into<Sender<()>>)

Add a child actor.

This child actor is held until this context is stopped.

pub fn register_child<M: Message<Response = ()>>( &mut self, child: impl Into<Sender<M>>, )

Register a child actor by Message type.

This actor will be held until this actor is stopped via a Sender.

pub fn send_to_children<M>(&mut self, message: M)

where M: Message<Response = ()> + Clone,

Send a message to all child actors registered with this message type.

impl<A: Actor> Context<A>

Creating Addrs, Callers and Senders to yourself

pub fn weak_address(&self) -> WeakAddr<A>

Create an weak address to the actor.

pub fn weak_sender<M: Message<Response = ()>>(&self) -> WeakSender<M>

where A: Handler<M>,

Create a weak sender to the actor.

pub fn weak_caller<M: Message<Response = R>, R>(&self) -> WeakCaller<M>

where A: Handler<M>,

Create a weak caller to the actor.

impl<A: Actor> Context<A>

Broker Interaction

pub async fn publish<M: Message<Response = ()> + Clone>( &self, message: M, ) -> Result<()>

where A: Handler<M>,

Publish to the broker.

Every actor can publish messages to the broker which will be delivered to all actors that subscribe to the message.

pub async fn subscribe<M: Message<Response = ()> + Clone>( &mut self, ) -> Result<()>

where A: Handler<M>,

Subscribe to a message.

The actor will receive all messages of this type.

impl<A: Actor> Context<A>

Task Handling

pub fn spawn_task( &mut self, task: impl Future<Output = ()> + Send + 'static, ) -> TaskHandle

Spawn a task that will be executed in the background.

The task will be aborted when the actor is stopped.

pub fn interval<M: Message<Response = ()> + Clone + Send + 'static>( &mut self, message: M, duration: Duration, ) -> TaskHandle

where A: Handler<M> + Send + 'static,

Send yourself a message at a regular interval.

Backpressure

Ticks that take longer than 50% of the interval duration to send are skipped to prevent stale message buildup when the actor cannot keep pace with the interval.

pub fn interval_with<M: Message<Response = ()>>( &mut self, message_fn: impl Fn() -> M + Send + Sync + 'static, duration: Duration, ) -> TaskHandle

where A: Handler<M>,

Send yourself a message at a regular interval.

Backpressure

Ticks that take longer than 50% of the interval duration to send are skipped to prevent stale message buildup when the actor cannot keep pace with the interval.

Warning: don’t do anything expensive in the message function, as it will block the interval.

pub fn delayed_send<M: Message<Response = ()>>( &mut self, message_fn: impl Fn() -> M + Send + Sync + 'static, duration: Duration, ) -> TaskHandle

where A: Handler<M>,

Send yourself a message after a delay.

pub fn delayed_exec<F: Future<Output = ()> + Send + 'static>( &mut self, task: F, duration: Duration, ) -> TaskHandle

Execute a task after a delay.

pub fn stop_task(&mut self, handle: TaskHandle)

Stop a very specific task.

impl<A: RestartableActor> Context<A>

Life-cycle

pub fn restart(&self) -> Result<()>

Restart the actor.

Depending on the RestartStrategy of the particular Actor this will do either of two things:

RestartOnly: call the Actor::stopped() and Actor::started() methods in order RecreateFromDefault: create a new instance of the actor and start it.

Trait Implementations

impl<A> Drop for Context<A>

fn drop(&mut self)

Executes the destructor for this type.