Struct ActorSystem 

pub struct ActorSystem { /* private fields */ }

Represents a collection of actors, so that they can be shutdown together.

Implementations

impl ActorSystem

pub fn new() -> Self

pub fn stop(&self)

pub fn spawn_tokio_actor<A: Actor + Send + 'static>( &self, actor: A, ) -> TokioRuntimeHandle<A>

Spawns an actor in a single threaded Tokio runtime and returns a handle to it. The handle can be used to get the sender and future spawner for the actor.

struct MyActor;

impl Actor for MyActor {}

impl Handler<MyMessage> for MyActor {
    fn handle(&mut self, msg: MyMessage) {}
}

// We can use the actor_handle to create senders and future spawners.
let actor_handle = actor_system.spawn_tokio_actor(MyActor);

let sender: MyAdapter = actor_handle.sender();
let future_spawner = actor_handle.future_spawner();

The sender and future spawner can then be passed onto other components that need to send messages to the actor or spawn futures in the runtime of the actor.

pub fn new_tokio_builder<A: Actor + Send + 'static>( &self, ) -> TokioRuntimeBuilder<A>

A more granular way to build a tokio runtime. It allows spawning futures and getting a handle before the actor is constructed (so that the actor can be constructed with the handle, for sending messages to itself).

pub fn spawn_multithread_actor<A: Actor + Send + 'static>( &self, num_threads: usize, make_actor_fn: impl Fn() -> A + Sync + Send + 'static, ) -> MultithreadRuntimeHandle<A>

Spawns a multi-threaded actor which handles messages in a synchronous thread pool. Used similarly to spawn_tokio_actor, but this actor is intended for CPU-bound tasks, can run multiple threads, and does not support futures, timers, or delayed messages.

pub fn new_future_spawner(&self, description: &str) -> Box<dyn FutureSpawner>

Returns a future spawner for the actor system on an independent Tokio runtime. Note: For typical actors, it is recommended we use the future spawner of the actor instead.

This is useful for keeping track of spawned futures and their lifetimes. Behind the scenes, this builds a new EmptyActor each time.

Trait Implementations

impl Clone for ActorSystem

fn clone(&self) -> ActorSystem

Returns a duplicate of the value.

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

Performs copy-assignment from source.