Struct Handle 

pub struct Handle<Msg> { /* private fields */ }

A handle to send messages to or stop an Actor.

Implementations

impl<Msg> Handle<Msg>

pub fn stop(&self)

Stops the Actor associated with this handle. Does not wait for the actor to finish.

Example

handle.stop();

pub fn restart(&self)

Restarts the Actor by re-running Actor::init and Actor::sources. Does not wait for the actor to finish.

Example

handle.restart();

pub fn is_alive(&self) -> bool

Returns true if the Actor is still running.

Example

if handle.is_alive() {
    handle.send(Msg::Ping);
}

pub fn send<M: Into<Msg>>(&self, msg: M) -> bool

Sends a message to the Actor, returning true if the message was delivered or false if the actor is no longer running. Takes advantage of From<_> implementations on the message type.

Example

// Given `#[derive(From)] enum Msg { Inc(u32) }`:
handle.send(Msg::Inc(1));
handle.send(1u32); // works via From<u32>

pub fn send_in<M>(&self, msg: M, duration: Duration)

where Msg: 'static + Send, M: 'static + Send + Into<Msg>,

Sends a message to the Actor after the given duration, failing silently if it is no longer running.

Example

handle.send_in(Msg::Timeout, Duration::from_secs(5));

pub async fn req<Req, Res>(&self, req: Req) -> Result<Res, ReqErr>

where Msg: From<Request<Req, Res>>,

Sends a request and awaits a response. Requires Msg: From<Request<Req, Res>>.

Example

#[derive(From)]
enum Msg {
    GetCount(Request<(), u32>),
}

// sender side:
let count: u32 = handle.req(()).await?;

// receiver side, inside handle():
Msg::GetCount(req) => req.reply(self.count),

pub async fn reqw<F, Req, Res>( &self, to_req: F, req: Req, ) -> Result<Res, ReqErr>

where F: Fn(Request<Req, Res>) -> Msg,

Like Handle::req, but uses a wrapper function to convert the Request into the message type. Useful when the message variant can’t implement From<Request<Req, Res>>.

Example

enum Msg {
    GetCount(Request<(), u32>),
}

let count: u32 = handle.reqw(Msg::GetCount, ()).await?;

pub async fn req_timeout<Req, Res>( &self, req: Req, timeout: Duration, ) -> Result<Res, ReqErr>

where Msg: From<Request<Req, Res>>,

Like Handle::req, but fails with ReqErr::Timeout if no response within the given Duration.

Example

let count: u32 = handle.req_timeout((), Duration::from_secs(1)).await?;

pub async fn reqw_timeout<F, Req, Res>( &self, to_req: F, req: Req, timeout: Duration, ) -> Result<Res, ReqErr>

where F: Fn(Request<Req, Res>) -> Msg,

Like Handle::reqw, but fails with ReqErr::Timeout if no response within the given Duration.

Example

let count: u32 = handle.reqw_timeout(Msg::GetCount, (), Duration::from_secs(1)).await?;

Trait Implementations

impl<Msg> Clone for Handle<Msg>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.