Struct Addr

pub struct Addr<A: Actor> { /* private fields */ }

The address of an actor.

Implementations

impl<A: Actor> Addr<A>

pub fn new(tx: AddressSender<A>) -> Addr<A>

pub fn connected(&self) -> bool

Returns whether the actor is still alive.

pub fn do_send<M>(&self, msg: M)

where M: Message + Send, M::Result: Send, A: Handler<M>, A::Context: ToEnvelope<A, M>,

Sends a message unconditionally, ignoring any potential errors.

The message is always queued, even if the mailbox for the receiver is full. If the mailbox is closed, the message is silently dropped.

pub fn try_send<M>(&self, msg: M) -> Result<(), SendError<M>>

where M: Message + Send + 'static, M::Result: Send, A: Handler<M>, A::Context: ToEnvelope<A, M>,

Tries to send a message.

This method fails if actor’s mailbox is full or closed. This method registers the current task in the receiver’s queue.

pub fn send<M>(&self, msg: M) -> Request<A, M>

where M: Message + Send + 'static, M::Result: Send, A: Handler<M>, A::Context: ToEnvelope<A, M>,

Sends an asynchronous message and waits for a response.

The communication channel to the actor is bounded. If the returned request future gets dropped, the message is cancelled.

pub fn recipient<M>(self) -> Recipient<M>

where A: Handler<M>, A::Context: ToEnvelope<A, M>, M: Message + Send + 'static, M::Result: Send,

Returns the Recipient for a specific message type.

pub fn downgrade(&self) -> WeakAddr<A>

Returns a downgraded WeakAddr.

Trait Implementations

impl<A: Actor> Clone for Addr<A>

fn clone(&self) -> Addr<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Actor> Debug for Addr<A>

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

Formats the value using the given formatter.

impl<A, M: Message + Send + 'static> From<Addr<A>> for Recipient<M>

where A: Handler<M> + Actor, M::Result: Send, A::Context: ToEnvelope<A, M>,

fn from(addr: Addr<A>) -> Self

Converts to this type from the input type.

impl<A, M: Message + Send + 'static> From<Addr<A>> for WeakRecipient<M>

where A: Handler<M> + Actor, M::Result: Send, A::Context: ToEnvelope<A, M>,

fn from(addr: Addr<A>) -> WeakRecipient<M>

Converts to this type from the input type.

impl<A: Actor> Hash for Addr<A>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A, M, B> MessageResponse<A, M> for Addr<B>

where A: Actor, M: Message<Result = Self>, B: Actor,

fn handle(self, _: &mut A::Context, tx: Option<OneshotSender<Self>>)

impl<A: Actor> PartialEq for Addr<A>

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: Actor> Eq for Addr<A>