Struct actix::Addr

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

The address of an actor.

Methods

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,
    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 Future object gets dropped, the message is cancelled.

pub fn recipient<M: 'static>(self) -> Recipient<M> where
    A: Handler<M>,
    A::Context: ToEnvelope<A, M>,
    M: Message + Send,
    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, M, B> MessageResponse<A, M> for Addr<B> where
    A: Actor,
    M: Message<Result = Self>,
    B: Actor<Context = Context<B>>, 

fn handle<R: ResponseChannel<M>>(self, _: &mut A::Context, tx: Option<R>)

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

impl<A: Actor, M: Message + Send + 'static> Into<Recipient<M>> for Addr<A> where
    A: Handler<M>,
    M::Result: Send,
    A::Context: ToEnvelope<A, M>, 

fn into(self) -> Recipient<M>

Performs the conversion.

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

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

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

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

Formats the value using the given formatter.

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, 

Feeds a slice of this type into the given [Hasher].