Struct xtra::MessageChannel

pub struct MessageChannel<M: Message> { /* fields omitted */ }

A message channel is a channel through which you can send only one kind of message, but to any actor that can handle it. It is like Address, but associated with the message type rather than the actor type. Any existing MessageChannels will prevent the dropping of the actor. If this is undesirable, then the WeakMessageChannel struct should be used instead. This struct is created by calling Address::channel, Address::into_channel, or the similar methods on WeakAddress.

Example

struct WhatsYourName;

impl Message for WhatsYourName {
    type Result = &'static str;
}

struct Alice;
struct Bob;

impl Actor for Alice {}
impl Actor for Bob {}

impl SyncHandler<WhatsYourName> for Alice {
    fn handle(&mut self, _: WhatsYourName, _ctx: &mut Context<Self>) -> &'static str {
        "Alice"
    }
}

impl SyncHandler<WhatsYourName> for Bob {
    fn handle(&mut self, _: WhatsYourName, _ctx: &mut Context<Self>) -> &'static str {
        "Bob"
    }
}

#[smol_potat::main]
async fn main() {
    let channels = [Alice.spawn().into_channel(), Bob.spawn().into_channel()];
    let name = ["Alice", "Bob"];

    for (channel, name) in channels.iter().zip(&name) {
        assert_eq!(*name, channel.send(WhatsYourName).await.unwrap());
    }
}

Implementations

impl<M: Message> MessageChannel<M>

pub fn downgrade(&self) -> WeakMessageChannel<M>

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

pub fn into_downgraded(self) -> WeakMessageChannel<M>

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

Trait Implementations

impl<M: Message> MessageChannelExt<M> for MessageChannel<M>

fn is_connected(&self) -> bool

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

fn do_send(&self, message: M) -> Result<(), Disconnected>

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(&self, message: M) -> MessageResponseFuture<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>(self, stream: S) where
    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 channel 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<M: Message> Sink<M> for MessageChannel<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.