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::ActorAddrs refer to (possibly) remote actors.

Implementations

impl<A: Actor> ActorHandle<A>

A handle to a running (local) actor.

pub fn actor_addr(&self) -> &ActorAddr

The ActorAddr of the actor represented by this handle.

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

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

pub fn stop(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to stop without draining ordinary queued work first.

pub fn kill(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to terminate immediately.

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

A watch that observes the lifecycle state of the actor.

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(?)

pub fn into_any(self) -> AnyActorHandle

Erase this handle’s actor type, preserving only lifecycle access.

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, M> Endpoint<M> for &ActorHandle<A>

where A: Actor + Handler<M>, M: Message,

fn endpoint_location(&self) -> EndpointLocation

The logical location of this endpoint.

fn post<C>(self, cx: &C, message: M)

where C: Actor,

Post message to this endpoint from cx.

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, cx: &'life1 (impl 'async_trait + Actor), proc_id: ProcAddr, 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.

fn update_address_deprecated<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), proc_id: ProcAddr, addr: ChannelAddr, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

The DEPRECATED DO NOT USE generated client method for this enum variant.