Struct ActorRef 

pub struct ActorRef<A>
where
    A: Actor + Handler<A>,
{ /* private fields */ }

Typed, cloneable handle to a running actor.

Use this to send messages with ask, subscribe to events with subscribe, or stop the actor with ask_stop or tell_stop. Cloning an ActorRef is cheap — all clones share the same underlying channels.

Implementations

impl<A> ActorRef<A>

where A: Actor + Handler<A>,

pub const fn new( path: ActorPath, sender: HandleHelper<A>, stop_sender: Sender<Option<Sender<()>>>, event_receiver: EventReceiver<<A as Actor>::Event>, ) -> Self

pub async fn tell(&self, message: A::Message) -> Result<(), Error>

Sends a message to the actor without waiting for a response (fire-and-forget).

pub async fn ask(&self, message: A::Message) -> Result<A::Response, Error>

Sends message to the actor and waits for a response.

Returns the actor’s response on success, or an error if the actor has stopped or the message channel is full.

pub async fn ask_timeout( &self, message: A::Message, timeout: Duration, ) -> Result<A::Response, Error>

Sends message and waits up to timeout for a response, returning Error::Timeout if the deadline is exceeded.

pub async fn ask_stop(&self) -> Result<(), Error>

Requests the actor to stop gracefully and waits for it to confirm shutdown.

The actor will finish its current message, run pre_stop and post_stop, and stop its children before terminating. Returns an error if the actor has already stopped.

pub async fn tell_stop(&self)

Sends a stop signal without waiting for the actor to confirm shutdown (fire-and-forget).

pub fn path(&self) -> ActorPath

Returns the hierarchical path of this actor.

pub fn is_closed(&self) -> bool

Returns true if the actor’s mailbox is closed, meaning the actor has stopped.

pub async fn closed(&self)

Waits until the actor has fully terminated.

pub fn subscribe(&self) -> EventReceiver<<A as Actor>::Event>

Returns a broadcast receiver for this actor’s events.

Each subscriber receives every future event independently. Use this receiver directly or wrap it in a Sink to process events asynchronously.

Trait Implementations

impl<A> Clone for ActorRef<A>

where A: Actor + Handler<A>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.