Struct simple_actor::Actor

pub struct Actor<T: 'static + Send>(_);

Actor wrapping a state.

Cloning the actor provides an handle to the same actor.

Implementations

impl<T: 'static + Send> Actor<T>

pub fn new(state: T) -> (Self, impl Future<Output = ()>)

Creates a new Actor with default inbound channel capacity (1024).

Returned future must be spawned in an async executor.

pub fn new_with_capacity(
    state: T,
    capacity: usize
) -> (Self, impl Future<Output = ()>)

Creates a new Actor with given capacity for its inbound channel.

Returned future must be spawned in an async executor.

pub fn invoke_async<F, R>(&self, invoke: F) -> impl Future<Output = Option<R>> where
    F: for<'a> FnOnce(&'a mut T) -> Pin<Box<dyn Future<Output = R> + Send + 'a>> + Send + 'static,
    R: 'static + Send, 

Interacts with the state using a closure returning a future. This future holds the mutable reference to the state, and prevents the actor to process further invokes until this future ends.

The future needs to be boxed using [futures::FutureExt::boxed].

Returns None if the actor is no longer running.

pub async fn invoke<F, R>(&self, invoke: F) -> Option<R> where
    F: FnOnce(&mut T) -> R + 'static + Send,
    R: 'static + Send, 

Interact with the state using a closure.

Returns None if the actor is no longer running.

pub fn is_active(&self) -> bool

Tells if the actor still accepts new invokes.

pub fn shutdown(&self)

Stop the actor, which will process every already queued invokes before really stopping.

Trait Implementations

impl<T: 'static + Send> Clone for Actor<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: 'static + Send> Hash for Actor<T>

fn hash<Hasher: Hasher>(&self, hasher: &mut Hasher)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T: 'static + Send> PartialEq<Actor<T>> for Actor<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: 'static + Send> Eq for Actor<T>