Struct System 

pub struct System(/* private fields */);

A System is a scope within which the actors run.

Implementations

impl System

pub fn rc_downgrade(&self) -> SystemWeakRef

impl System

pub fn new(config: SystemConfig) -> Self

Create a new System using the provided config.

pub fn config(&self) -> &SystemConfig

The config with which this System was created.

impl System

pub async fn spawn<Behaviour, Args, Message>( &self, behaviour: Behaviour, args: Args, spawn_opts: SpawnOpts, ) -> Result<ActorID, SysSpawnError>

where Args: Send + 'static, Message: Unpin + Send + 'static, for<'a> Behaviour: Actor<'a, Args, Message>,

Spawn an actor

Example:

use agner_actors::{System, Context, Event};

async fn actor_behaviour(context: &mut Context<&'static str>, actor_name: &'static str) {
    loop {
        if let Event::Message(message) = context.next_event().await {
            eprintln!("[{}] received: {}", actor_name, message);
        }
    }
}
let _ = async {
    let system = System::new(Default::default());

    let alice = system.spawn(actor_behaviour, "Alice", Default::default()).await.expect("Failed to spawn an actor");
    let bob = system.spawn(actor_behaviour, "Bob", Default::default()).await.expect("Failed to spawn an actor");
};

pub async fn exit(&self, actor_id: ActorID, exit_reason: Exit)

Send SigExit to the specified actor.

pub fn wait(&self, actor_id: ActorID) -> impl Future<Output = Exit>

Wait for the specified actor to terminate, and return upon its termination the Exit. In case the actor with the specified actor_id does not exist — return Exit::no_actor() right away.

pub async fn send<M>(&self, to: ActorID, message: M)

where M: Send + 'static,

Send a single message to the specified actor.

pub async fn channel<M>( &self, to: ActorID, ) -> Result<ActorChannel<M>, SysChannelError>

where M: Send + 'static,

Open a channel to the specified actor.

When sending a series of messages to an actor, it may be better from the performance point of view to open a channel to an actor, rather than sending each message separately using System::send::<Message>(&self, ActorID, Message).

pub async fn link(&self, left: ActorID, right: ActorID)

Link two actors

pub async fn put_data<D: Any + Send + Sync + 'static>( &self, actor_id: ActorID, data: D, )

Associate arbitrary data with the specified actor. Upon actor termination that data will be dropped. If no actor with the specified id exists, the data will be dropped right away.

pub async fn get_data<D: Any + Clone>(&self, actor_id: ActorID) -> Option<D>

pub async fn take_data<D: Any>(&self, actor_id: ActorID) -> Option<D>

pub fn all_actors(&self) -> impl Stream<Item = ActorID> + '_

pub async fn actor_info(&self, actor_id: ActorID) -> Option<ActorInfo>

Trait Implementations

impl Clone for System

fn clone(&self) -> System

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for System

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

Formats the value using the given formatter.