Struct acteur::Acteur

pub struct Acteur { /* fields omitted */ }

Acteur is the main inteface to the actor runtime. It allows sending messages, stopping the runtime, set configurations, etc. Once contructed with the method "new" you can start sending messages. The system will automatically start any required actor and unload them when not used.

Methods

impl Acteur

pub fn new() -> Acteur

Initializes the system. After this, you can send messages using the send method.

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 an actor with an ID.

This method will execute the Receive::handle implemented for that Message and Actor.

If the actor is not loaded in Ram, this method will load them first by calling their "activate" method.

pub fn send_to_actor_sync<A: Actor + Receive<M>, M: Debug + Send + 'static>(
    &self,
    actor_id: A::Id,
    message: M
)

Same as send_to_actor method, but sync version.

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>

As send_to_actor method, it sends a message to an actor with an ID but this one wait for a response from the actor.

This method will execute the Respond::handle implemented for that Message and Actor.

If the actor is not loaded in Ram, this method will load them first by calling their "activate" method.

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

Same as call_actor method, but sync version.

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

Sends a message to a Service.

This method will execute the Notify::handle implemented for that Message and Service.

If the Service is not loaded in Ram, this method will load them first by calling their "initialize" method.

pub fn send_to_service_sync<S: Service + Notify<M>, M: Debug + Send + 'static>(
    &self,
    message: M
)

Same as send_to_service method, but sync version.

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

As send_to_service method, it sends a message to a Service but this one wait for a response from the actor.

This method will execute the Serve::handle implemented for that Message and Service.

If the Service is not loaded in Ram, this method will load them first by calling their "initialize" method.

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

Same as call_service method, but sync version.

pub fn stop(&self)

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

pub async fn preload_service<'_, S: Service>(&'_ self)

Ensures a service is loaded and running. It ensures that all Service's subscriptions are performed

pub async fn preload_service_sync<'_, S: Service>(&'_ self)

Same as preload_service but sync version

pub fn wait_until_stopped(&self)

Waits until all actors are stopped. If you call "system.stop()" this method will wait untill all actor have consumed all messages before returning.

pub fn get_statistics(&self) -> Vec<(TypeId, Vec<ActorReport>)>

Trait Implementations

impl Clone for Acteur

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Acteur

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

Formats the value using the given formatter.

impl Default for Acteur

fn default() -> Self

Returns the "default value" for a type.