Struct xtra::Address

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

An Address is a reference to an actor through which Messages can be sent. It can be cloned, and when all Addresses are dropped, the actor will be stopped. Therefore, any existing Addresses will inhibit the dropping of an actor. If this is undesirable, then the WeakAddress struct should be used instead. This struct is created by calling the Actor::create or Actor::spawn methods.

Methods

impl<A: Actor + Send> Address<A>

Important traits for WeakAddress<A>

impl<A: Actor> AddressExt<A> for WeakAddress<A>

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

Create a weak address to the actor. Unlike with the strong variety of address (this kind), an actor will not be prevented from being dropped if only weak addresses exist.

Important traits for WeakAddress<A>

impl<A: Actor> AddressExt<A> for WeakAddress<A>

pub fn into_downgraded(self) -> WeakAddress<A>

Converts this address into a weak address to the actor. Unlike with the strong variety of address (this kind), an actor will not be prevented from being dropped if only weak addresses exist.

pub fn channel<M: Message>(&self) -> MessageChannel<M> where
    A: Handler<M>, 

Gets a message channel to the actor. Like an address, a message channel allows messages to be sent to an actor. Unlike an address, rather than allowing you to send any kind of message to one kind of actor, a message channel allows you to send one kind of message to any kind of actor.

pub fn into_channel<M: Message>(self) -> MessageChannel<M> where
    A: Handler<M>, 

Converts this address into a message channel to the actor. Like an address, a message channel allows messages to be sent to an actor. Unlike an address, rather than allowing you to send any kind of message to one kind of actor, a message channel allows you to send one kind of message to any kind of actor.

Trait Implementations

impl<A: Actor> AddressExt<A> for Address<A>

fn is_connected(&self) -> bool

Returns whether the actor referred to by this address is running and accepting messages.

fn do_send<M>(&self, message: M) -> Result<(), Disconnected> where
    M: Message,
    A: Handler<M> + Send, 

Sends a Message to the actor, and does not wait for a response. If this returns Err(Disconnected), then the actor is stopped and not accepting messages. If this returns Ok(()), the will be delivered, but may not be handled in the event that the actor stops itself (by calling Context::stop) before it was handled.

fn send<M>(&self, message: M) -> MessageResponseFuture<M> where
    M: Message,
    A: Handler<M> + Send,
    M::Result: Send, 

Sends a Message to the actor, and waits for a response. If this returns Err(Disconnected), then the actor is stopped and not accepting messages.

fn attach_stream<S, M>(self, stream: S) where
    M: Message,
    A: Handler<M> + Send,
    S: Stream<Item = M> + Send + Unpin + 'static,
    Self: Sized + Send + Sink<M, Error = Disconnected> + 'static, 

This is supported on feature="with-tokio-0_2" and feature="with-async_std-1" only.

Attaches a stream to this actor such that all messages produced by it are forwarded to the actor. This could, for instance, be used to forward messages from a socket to the actor (after the messages have been appropriately mapped). This is a convenience method over explicitly forwarding a stream to this address, spawning that future onto the executor, and mapping the error away (because disconnects are expected and will simply mean that the stream is no longer being forwarded).

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Actor> Drop for Address<A>

fn drop(&mut self)

Executes the destructor for this type.

impl<M, A> Sink<M> for Address<A> where
    M: Message,
    A: Actor + Handler<M> + Send, 

type Error = Disconnected

The type of value produced by the sink when an error occurs.

fn poll_ready(
    self: Pin<&mut Self>,
    ctx: &mut Context
) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, message: M) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush(
    self: Pin<&mut Self>,
    ctx: &mut Context
) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close(
    self: Pin<&mut Self>,
    ctx: &mut Context
) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.