Struct ractor::actor::actor_cell::ActorCell

pub struct ActorCell { /* private fields */ }

An ActorCell is a reference to an Actor’s communication channels and provides external access to send messages, stop, kill, and generally interactor with the underlying Actor process.

The input ports contained in the cell will return an error should the underlying actor have terminated and no longer exist.

Implementations

impl ActorCell

pub fn get_id(&self) -> ActorId

Retrieve the super::Actor’s unique identifier ActorId

pub fn get_name(&self) -> Option<ActorName>

Retrieve the super::Actor’s name

pub fn get_status(&self) -> ActorStatus

Retrieve the current status of an super::Actor

Returns the super::Actor’s current ActorStatus

pub fn link(&self, supervisor: ActorCell)

Link this super::Actor to the provided supervisor

• supervisor - The supervisor super::Actor of this actor

pub fn unlink(&self, supervisor: ActorCell)

Unlink this super::Actor from the supervisor if it’s currently linked (if self’s supervisor is supervisor)

• supervisor - The supervisor to unlink this super::Actor from

pub fn monitor(&self, who: ActorCell)

Monitor the provided super::Actor for supervision events. An actor in ractor can only have a single supervisor, denoted by the link function, however they may have multiple monitors. Monitor’s receive copies of the SupervisionEvents, with non-cloneable information removed.

• who: The actor to monitor

pub fn unmonitor(&self, who: ActorCell)

Stop monitoring the provided super::Actor for supervision events.

• who: The actor to stop monitoring

pub fn clear_monitors(&self)

Clear all the self::Actors which are monitored by this self::Actor

pub fn kill(&self)

Kill this super::Actor forcefully (terminates async work)

pub async fn kill_and_wait( &self, timeout: Option<Duration> ) -> Result<(), RactorErr<()>>

Kill this super::Actor forcefully (terminates async work) and wait for the actor shutdown to complete

• timeout - An optional timeout duration to wait for shutdown to occur

Returns [Ok(())] upon the actor being stopped/shutdown. [Err(RactorErr::Messaging(_))] if the channel is closed or dropped (which may indicate some other process is trying to shutdown this actor) or [Err(RactorErr::Timeout)] if timeout was hit before the actor was successfully shut down (when set)

pub fn stop(&self, reason: Option<String>)

Stop this super::Actor gracefully (stopping message processing)

• reason - An optional string reason why the stop is occurring

pub async fn stop_and_wait( &self, reason: Option<String>, timeout: Option<Duration> ) -> Result<(), RactorErr<StopMessage>>

Stop the super::Actor gracefully (stopping messaging processing) and wait for the actor shutdown to complete

• reason - An optional string reason why the stop is occurring
• timeout - An optional timeout duration to wait for shutdown to occur

Returns [Ok(())] upon the actor being stopped/shutdown. [Err(RactorErr::Messaging(_))] if the channel is closed or dropped (which may indicate some other process is trying to shutdown this actor) or [Err(RactorErr::Timeout)] if timeout was hit before the actor was successfully shut down (when set)

pub fn send_message<TMessage>( &self, message: TMessage ) -> Result<(), MessagingErr<TMessage>>

where TMessage: Message,

Send a strongly-typed message, constructing the boxed message on the fly

Note: The type requirement of TActor assures that TMsg is the supported message type for TActor such that we can’t send boxed messages of an unsupported type to the specified actor.

• message - The message to send

Returns [Ok(())] on successful message send, [Err(MessagingErr)] otherwise

pub fn notify_supervisor_and_monitors(&self, evt: SupervisionEvent)

Notify the supervisor and all monitors that a supervision event occurred. Monitors receive a reduced copy of the supervision event which won’t contain the crate::actor::BoxedState and collapses the crate::ActorProcessingErr exception to a String

• evt - The event to send to this super::Actor’s supervisors

Trait Implementations

impl Clone for ActorCell

fn clone(&self) -> ActorCell

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ActorCell

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

Formats the value using the given formatter.

impl<TMessage> From<ActorCell> for ActorRef<TMessage>

fn from(value: ActorCell) -> Self

Converts to this type from the input type.

impl<TActor> From<ActorRef<TActor>> for ActorCell

fn from(value: ActorRef<TActor>) -> Self

Converts to this type from the input type.