Struct acteur::ServiceAssistant

pub struct ServiceAssistant<S: Service> { /* fields omitted */ }

This object is provided to the handle method in the Receive trait for each message that an Actor receives. The Actor's assistant allows to send messages and to execute some task over the system.

use acteur::{Acteur, Service, Listen, ServiceConfiguration, ServiceAssistant};

#[derive(Debug)]
struct EmployeeTaxesCalculator {
    tax_rate: f32,
}

#[async_trait::async_trait]
impl Service for EmployeeTaxesCalculator {
    async fn initialize(system: &ServiceAssistant<Self>) -> (Self, ServiceConfiguration) {
        let service = EmployeeTaxesCalculator {
            tax_rate: 0.21,
        };

        let service_conf = ServiceConfiguration::default();

        (service, service_conf)
    }
}

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

#[async_trait::async_trait]
impl Listen<EmployeeSalaryChange> for EmployeeTaxesCalculator {

    async fn handle(&self, message: EmployeeSalaryChange, system: &ServiceAssistant<Self>) {
        system.stop_system();
    }
}

Implementations

impl<S: Service> ServiceAssistant<S>

pub async fn send_to_actor<'_, A: Actor + Receive<M>, M: Debug + Send + 'static>(
    &'_ self,
    actor_id: A::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 call_actor<'_, '_, A: Actor + Respond<M>, M: Debug + Send + 'static>(
    &'_ self,
    actor_id: A::Id,
    message: M
) -> Result<<A 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<'_, S1: 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<'_, '_, S1: Service + Serve<M>, M: Debug + Send + 'static>(
    &'_ self,
    message: M
) -> Result<<S1 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 fn stop_system(&self)

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

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

Trait Implementations

impl<S: Service> Clone for ServiceAssistant<S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Service> Debug for ServiceAssistant<S>

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

Formats the value using the given formatter.