Struct xtra::WeakAddress

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

A WeakAddress is a reference to an actor through which Messages can be sent. It can be cloned. Unlike Address, a WeakAddress will not inhibit the dropping of an actor. It is created by the Address::downgrade or Address::into_downgraded methods.

Implementations

impl<A: Actor> WeakAddress<A>

pub fn channel<M: Message>(&self) -> WeakMessageChannel<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. This method involves a clone of the address, and as such is slightly more expensive than WeakAddress::into_channel.

pub fn into_channel<M: Message>(self) -> WeakMessageChannel<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. This method does not clone the address, and as such is slightly less expensive than WeakAddress::channel.

Trait Implementations

impl<A: Actor> AddressExt<A> for WeakAddress<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>, 

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>, 

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, K>(self, stream: S) where
    K: Into<KeepRunning> + Send,
    M: Message<Result = K>,
    A: Handler<M>,
    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" and feature="with-wasm_bindgen-0_2" and feature="with-smol-0_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 WeakAddress<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, M> Into<WeakMessageChannel<M>> for WeakAddress<A> where
    A: Handler<M>,
    M: Message, 

fn into(self) -> WeakMessageChannel<M>

Performs the conversion.

impl<M, A> Sink<M> for WeakAddress<A> where
    M: Message,
    A: Handler<M>, 

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.