Struct Handle 

pub struct Handle<A, E>
where
    A: Send + 'static,
    E: ActorError,
{ /* private fields */ }

Cloneable handle to send actions to actor A with error type E.

Thread-safe. Actions run sequentially on the actor.

Implementations

impl<A, E> Handle<A, E>

where A: Send + 'static, E: ActorError,

pub fn state(&self) -> ActorState

Read the current lifecycle state of the actor.

pub fn spawn_blocking(actor: A) -> (Self, JoinHandle<Result<(), E>>)

Spawn a blocking actor with the default message loop on a new OS thread.

The library runs: receive action → execute → repeat, until the channel disconnects. Use spawn_blocking_with for custom receive loops.

pub fn spawn_blocking_with<F>( actor: A, run: F, ) -> (Self, JoinHandle<Result<(), E>>)

where F: FnOnce(A, Receiver<Action<A>>) -> Result<(), E> + Send + 'static,

Spawn a blocking actor with a custom run loop on a new OS thread.

The closure receives ownership of the actor and the action receiver. Use block_on(action(&mut actor)) to execute received actions.

pub fn call_blocking<R, F>(&self, f: F) -> Result<R, E>

where F: for<'a> FnOnce(&'a mut A) -> ActorFut<'a, Result<R, E>> + Send + 'static, R: Send + 'static,

Send action, block until complete. Works without async runtime.

Example

handle.call_blocking(act_ok!(actor => async move {
    actor.value += 1;
    actor.value
}))?

pub fn shutdown(&self)

Disconnect the action channel, causing the actor’s recv() to return Err.

The actor loop should exit naturally when recv() returns Err. Already-queued messages will be drained before the channel reports disconnection. Does nothing if already shut down.

pub fn wait_stopped_blocking(&self)

Block until the actor has stopped. Returns immediately if already stopped.

Trait Implementations

impl<A, E> Clone for Handle<A, E>

where A: Send + 'static, E: ActorError,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, E> Debug for Handle<A, E>

where A: Send + 'static + Debug, E: ActorError + Debug,

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

Formats the value using the given formatter.

impl<A, E> PartialEq for Handle<A, E>

where A: Send + 'static, E: ActorError,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, E> Eq for Handle<A, E>

where A: Send + 'static, E: ActorError,