Struct coerce::actor::refs::LocalActorRef

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

A reference to a local Actor instance

Implementations

impl<A: Actor> LocalActorRef<A>

pub fn send_blocking<Msg: Message>( &self, msg: Msg ) -> Result<Msg::Result, ActorRefErr>where A: Handler<Msg>,

pub fn stop_blocking(&self) -> Result<(), ActorRefErr>

pub fn exec_blocking<F, R>(&self, f: F) -> Result<R, ActorRefErr>where F: FnMut(&mut A) -> R + 'static + Send + Sync, R: 'static + Send + Sync,

impl<A: Actor> LocalActorRef<A>

pub fn sender(&self) -> &UnboundedSender<MessageHandler<A>>

Get the direct reference to the actor mailbox’s [

[UnboundedSender][tokio::sync::mpsc::unbounded::UnboundedSender]

impl<A: Actor> LocalActorRef<A>

pub fn new( id: ActorId, sender: UnboundedSender<MessageHandler<A>>, path: ActorPath ) -> Self

Creates a LocalActorRef instance from an ActorId, UnboundSender<MessageHandler<A>>, a system_id (Uuid) and an ActorPath.

Generally this should not be used directly.

pub fn actor_id(&self) -> &ActorId

Returns a reference to the ActorId of the target Actor

pub fn actor_path(&self) -> &ActorPath

Returns a reference to the ActorPath of the target Actor

pub async fn send<Msg: Message>( &self, msg: Msg ) -> Result<Msg::Result, ActorRefErr>where A: Handler<Msg>,

Sends a message to the target Actor and waits for the message to be processed and for a result to be available.

Example

Send a [Status][lifecycle::Status] message (a built-in message that every actor can handle), and return the result, which is an ActorStatus.

use coerce::actor::{
    Actor,
    LocalActorRef,
    context::ActorStatus,
    lifecycle::Status
};

async fn get_status<A: Actor>(actor: &LocalActorRef<A>) -> Option<ActorStatus> {
    actor.send(Status).await.ok()
}

pub fn notify<Msg: Message>(&self, msg: Msg) -> Result<(), ActorRefErr>where A: Handler<Msg>,

Sends a message to the target Actor but doesn’t wait for the message to be processed.

Example

Send a [Stop][lifecycle::Stop] message, which is a message every actor can handle, but don’t wait for it to be processed.

use coerce::actor::{
    Actor,
    LocalActorRef,
    lifecycle::Stop,
};

fn stop_actor<A: Actor>(actor: &LocalActorRef<A>) {
    let _ = actor.notify(Stop(None));
}

pub async fn exec<F, R>(&self, f: F) -> Result<R, ActorRefErr>where F: FnMut(&mut A) -> R + 'static + Send + Sync, R: 'static + Send + Sync,

pub fn notify_exec<F>(&self, f: F) -> Result<(), ActorRefErr>where F: FnMut(&mut A) + 'static + Send + Sync,

pub async fn status(&self) -> Result<ActorStatus, ActorRefErr>

Sends a [Status][lifecycle::Status] message, returning the current [ActorStatus][context::ActorStatus]

pub async fn stop(&self) -> Result<(), ActorRefErr>

Attempts to stop the target Actor, waiting for completion

pub fn describe(&self, describe: Describe) -> Result<(), ActorRefErr>

pub fn is_valid(&self) -> bool

pub fn notify_stop(&self) -> Result<(), ActorRefErr>

Attempts to stop the target Actor, without waiting for completion

impl<A: Actor> LocalActorRef<A>

pub fn scheduled_notify<M: Message>( &self, message: M, delay: Duration ) -> ScheduledNotify<A, M>where A: Handler<M>,

Spawns an asynchronous task that sleeps for the provided duration and finally sends the provided message to the target Actor.

Returns a handle to the scheduled notification for cancellation.

Trait Implementations

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Actor> CoreActorRef for LocalActorRef<A>

fn actor_id(&self) -> &ActorId

fn actor_path(&self) -> &ActorPath

fn actor_type(&self) -> &'static str

fn status<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<ActorStatus, ActorRefErr>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn stop<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<(), ActorRefErr>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn describe(&self, describe: Describe) -> Result<(), ActorRefErr>

fn notify_stop(&self) -> Result<(), ActorRefErr>

fn notify_child_terminated(&self, id: ActorId) -> Result<(), ActorRefErr>

fn is_valid(&self) -> bool

fn as_any(&self) -> &dyn Any

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

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

Formats the value using the given formatter.

impl<A: Actor> From<LocalActorRef<A>> for ActorRef<A>

fn from(r: LocalActorRef<A>) -> Self

Converts to this type from the input type.

impl<A: Actor> From<LocalActorRef<A>> for BoxedActorRef

fn from(r: LocalActorRef<A>) -> Self

Converts to this type from the input type.

impl<A, M: Message> From<LocalActorRef<A>> for Receiver<M>where A: Handler<M> + Actor,

fn from(actor_ref: LocalActorRef<A>) -> Self

Converts to this type from the input type.

impl From<LocalActorRef<RemoteClient>> for RemoteClientRef

fn from(client: LocalActorRef<RemoteClient>) -> Self

Converts to this type from the input type.

impl<A: Actor> Hash for LocalActorRef<A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A, M: Message> MessageReceiver<M> for LocalActorRef<A>where A: Handler<M> + Actor,

fn actor_id(&self) -> &ActorId

fn send<'life0, 'async_trait>( &'life0 self, msg: M ) -> Pin<Box<dyn Future<Output = Result<M::Result, ActorRefErr>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn notify(&self, msg: M) -> Result<(), ActorRefErr>

impl<A: Actor> PartialEq for LocalActorRef<A>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Routes for LocalActorRef<ShardingApi>

fn routes(&self, router: Router) -> Router

impl<W: Actor + Clone> WorkerRefExt<W> for LocalActorRef<Worker<W>>

fn dispatch<'life0, 'async_trait, M>( &'life0 mut self, message: M ) -> Pin<Box<dyn Future<Output = Result<M::Result, ActorRefErr>> + Send + 'async_trait>>where W: Handler<M>, M: 'async_trait + Message, Self: 'async_trait, 'life0: 'async_trait,

impl<A: Actor> Deref for LocalActorRef<A>

type Target = LocalActorRefInner<A>

The resulting type after dereferencing.

fn deref(&self) -> &LocalActorRefInner<A>

Dereferences the value.

impl<A: Actor> Eq for LocalActorRef<A>