Struct ActorHandle

pub struct ActorHandle<A: Actor> { /* private fields */ }

ActorHandles represent a (local) serving actor. It is used to access its messaging and signal ports, as well as to synchronize with its lifecycle (e.g., providing joins). Once dropped, the handle is detached from the underlying actor instance, and there is no longer any way to join it.

Correspondingly, crate::ActorRefs refer to (possibly) remote actors.

Implementations

impl<A: Actor> ActorHandle<A>

A handle to a running (local) actor.

pub fn actor_id(&self) -> &ActorId

The ActorId of the actor represented by this handle.

pub fn drain_and_stop(&self) -> Result<(), ActorError>

Signal the actor to drain its current messages and then stop.

pub fn status(&self) -> Receiver<ActorStatus>

A watch that observes the lifecycle state of the actor.

pub fn send<M: Message>(&self, message: M) -> Result<(), MailboxSenderError>

where A: Handler<M>,

Send a message to the actor. Messages sent through the handle are always queued in process, and do not require serialization.

pub fn port<M: Message>(&self) -> PortHandle<M>

where A: Handler<M>,

Return a port for the provided message type handled by the actor.

pub fn bind<R: Binds<A>>(&self) -> ActorRef<R>

TEMPORARY: bind… TODO: we shoudl also have a default binding(?)

Trait Implementations

impl<A: Actor> Clone for ActorHandle<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Actor> Debug for ActorHandle<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<A: Actor> IntoFuture for ActorHandle<A>

IntoFuture allows users to await the handle to join it. The future resolves when the actor itself has stopped processing messages. The future resolves to the actor’s final status.

type Output = ActorStatus

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <ActorHandle<A> as IntoFuture>::Output> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<A> MailboxAdminMessageClient for ActorHandle<A>

where A: Handler<MailboxAdminMessage>,

fn update_address<'life0, 'life1, 'async_trait>( &'life0 self, caps: &'life1 (impl 'async_trait + CanSend), proc_id: ProcId, addr: ChannelAddr, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

The generated client method for this enum variant.