Struct acteur::ActorAssistant

pub struct ActorAssistant<A: Actor> { /* fields omitted */ }

This object is provided to the handle method in Receive and Respond traits for each message that an Actor receives.

The Actor's assistant allows to send messages and to execute some task over the system.

#[derive(Debug)]
struct SalaryChanged(u32);

#[derive(Debug)]
struct SayByeForever(String);

#[async_trait]
impl Receive<SalaryChanged> for Employee {
    async fn handle(&mut self, message: SalaryChanged, assistant: &ActorAssistant<Employee>) {
        if self.salary > message.0 {
            assistant.send_to_actor::<Manager, SayByeForever>(self.manager_id, SayByeForever("Betrayer!".to_string()));
        }
         
        self.salary = message.0;
    }
}

Implementations

impl<A: Actor> ActorAssistant<A>

pub async fn send_to_actor<A2: Actor + Receive<M>, M: Debug + Send + 'static, '_>(
    &'_ self,
    actor_id: A2::Id,
    message: M
)

Sends a message to the Actor with the specified Id. If the Actor is not loaded, it will load the actor before, calling its method activate

pub async fn send_to_all_actors<A2: Actor + Receive<M>, M: Debug + Send + 'static, '_>(
    &'_ self,
    message: M
)

Sends a message to all actors independently of the ID. It will only send messages to actors already in Ram (already loaded)

pub async fn schedule_send_to_actor<A2: Actor + Receive<M>, M: Debug + Send + 'static, '_>(
    &'_ self,
    actor_id: A2::Id,
    duration: Duration,
    message: M
)

Schedules to sends a message to the Actor with the specified Id. If the Actor is not loaded, it will load the actor before, calling its method activate

pub async fn schedule_send_to_all_actors<A2: Actor + Receive<M>, M: Debug + Send + 'static, '_>(
    &'_ self,
    duration: Duration,
    message: M
)

Schedules to sends a message to all actors independently of the ID. It will only send messages to actors already in Ram (already loaded)

pub async fn call_actor<A2: Actor + Respond<M>, M: Debug + Send + 'static, '_, '_>(
    &'_ self,
    actor_id: A2::Id,
    message: M
) -> Result<<A2 as Respond<M>>::Response, &'_ str>

Sends a message to the Actor with the specified Id and waits the actor's response . If the Actor is not loaded, it will load the actor before, calling its method activate

pub async fn send_to_service<S: Service + Listen<M>, M: Debug + Send + 'static, '_>(
    &'_ self,
    message: M
)

Sends a message to a Service. If the Service is not loaded, it will load the service before, calling its method initialize

pub async fn call_service<S: Service + Serve<M>, M: Debug + Send + 'static, '_, '_>(
    &'_ self,
    message: M
) -> Result<<S as Serve<M>>::Response, &'_ str>

Sends a message to a Service and waits for its response. If the Service is not loaded, it will load the service before, calling its method initialize

pub async fn stop<'_>(&'_ self)

Enqueues a end command in the Actor messages queue. The actor will consume all mesages before ending. Keep in mind that event is an actor is stopped, a new message in the future can wake up the actor.

pub async fn get_id<'_, '_>(&'_ self) -> &'_ A::Id

Returns the Actor's Id defined by the Actor Trait

pub fn stop_system(&self)

Send an stop message to all actors in the system. Actors will process all the enqued messages before stop

Trait Implementations

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

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.