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 async fn queue_blocking<F>(&self, f: F) -> Option<()> where
    F: for<'a> FnOnce(&'a mut T) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> + Send + 'static, 

Queue an async function on the state. The future that this function returns can hold the state across await points, meaning it will prevent other functions to be processed until the future is complete.

queue_blocking resolves once the order is sent to the actor, and doesn’t wait for it to be processed by the actor, but cannot have an output value.

To wait for the order to be processed and get an output, use query_blocking.

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

Queue a function on the state. It is more performant to have multiple queue/query in a row, as it can avoid using .await on the internal channel or on a future-based change (queue_blocking/query_blocking).

queue resolves once the order is sent to the actor, and doesn’t wait for it to be processed by the actor, but cannot have an output value.

To wait for the order to be processed and get an output, use query.

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

Queue an async function on the state. The future that this function returns can hold the state across await points, meaning it will prevent other functions to be processed until the future is complete.

query_blocking resolves once the order as been processed by the actor, which allows it to return an output.

If an output is not needed and it is not needed to wait for the order to be processed, use queue_blocking.

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

Queue a function on the state. It is more performant to have multiple queue/query in a row, as it can avoid using .await on the internal channel or on a future-based change (queue_blocking/query_blocking).

query_blocking resolves once the order as been processed by the actor, which allows it to return an output.

If an output is not needed and it is not needed to wait for the order to be processed, use queue_blocking.

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>