Struct actix::Unsync

pub struct Unsync;

Unsync destination of the actor

Actor has to run in the same thread as owner of the address.

Trait Implementations

impl<T, A, M> ToEnvelope<Unsync, A, M> for T where     A: Actor<Context = T> + Handler<M>,     M: Message + 'static,     T: AsyncContext<A>,

fn pack(msg: M, tx: Option<UnsyncSender<M::Result>>) -> UnsyncEnvelope<A>

Pack message into suitable envelope

impl<A: Actor> Destination<A> for Unsync where     A::Context: AsyncContext<A>,

type Transport = UnsyncAddrSender<A>

fn connected(tx: &Self::Transport) -> bool

Indicates if actor is still alive

impl<A, M> MessageDestination<A, M> for Unsync where     M: Message + 'static,     A: Handler<M>,     A::Context: AsyncContext<A> + ToEnvelope<Self, A, M>,

type Envelope = UnsyncEnvelope<A>

type ResultSender = Sender<M::Result>

type ResultReceiver = Receiver<M::Result>

fn do_send(tx: &Self::Transport, msg: M)

Send message unconditionally

fn send(tx: &Self::Transport, msg: M) -> Request<Self, A, M>

Send asynchronous message and wait for response.

fn try_send(tx: &Self::Transport, msg: M) -> Result<(), SendError<M>>

Try send message

fn recipient(tx: Self::Transport) -> Recipient<Self, M>

Get recipient for specific message type.

impl<M> MessageRecipient<M> for Unsync where     M: Message + 'static,

type Envelope = MessageEnvelope<M>

type Transport = Box<UnsyncSender<M>>

type SendError = SendError<M>

type MailboxError = MailboxError

type Request = UnsyncRecipientRequest<M>

fn do_send(tx: &Self::Transport, msg: M) -> Result<(), SendError<M>>

Send message unconditionally

fn send(tx: &Self::Transport, msg: M) -> UnsyncRecipientRequest<M>

Send asynchronous message and wait for response.

fn try_send(tx: &Self::Transport, msg: M) -> Result<(), SendError<M>>

Try send message

fn clone(tx: &Self::Transport) -> Self::Transport

Clone transport