Struct cooper::Actor

pub struct Actor<S> where
    S: Send + 'static,  { /* fields omitted */ }

The Actor.

This is an async command processor that serializes requests around an internal state. Each request runs to completion, atomically, in the order received, and thus tasks do not need to lock or protect the state for access.

Implementations

impl<S> Actor<S> where
    S: Default + Send + 'static, 

pub fn new() -> Self

Create a new actor with a default state

impl<S> Actor<S> where
    S: Send + 'static, 

pub fn from_state(state: S) -> Self

Creates a new actor from an initial state

pub async fn cast<F>(&self, f: F) where
    F: for<'a> FnOnce(&'a mut S) -> BoxFuture<'a, ()>,
    F: 'static + Send, 

This is a totally asynchronous opertion. Awaiting the returned future only waits for the operation to be placed in the queue. It does not wait for the operation to be executed.

pub async fn call<F, R>(&self, f: F) -> R where
    F: for<'a> FnOnce(&'a mut S) -> BoxFuture<'a, R>,
    F: 'static + Send,
    R: 'static + Send + Debug, 

A call is a synchronous opertion within the async task. It will queue the request, wait for it to execute, and return the result.

pub async fn flush(&self)

Blocks the calling task until all requests up to this point have been processed.

Note that if there are clones of the actor, additional requests may get queued after this one, so the queue is not guaranteed to be empty when this returns; just that all the requests prior to this one have completed.

Trait Implementations

impl<S: Clone> Clone for Actor<S> where
    S: Send + 'static, 

fn clone(&self) -> Actor<S>

Returns a copy of the value.

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

Performs copy-assignment from source.