Struct crossbus::address::Receiver

pub struct Receiver<M: Message> { /* private fields */ }

A message consumer that poll messages from the Sender

Implementations

impl<M: Message> Receiver<M>

pub fn as_sender(&self) -> Sender<M>

create an instance of Sender from Receiver

pub fn capacity(&self) -> usize

get the capcity of the channel

it will remain the usize::MAX when created, but can be updated via set_capacity

pub fn set_capacity(&self, cap: usize)

set the capcity of message queue

when the messages reach the capcity it will transimit the queue to state STATUSFULL where no more messages will be received

pub fn message_number(&self) -> usize

get the number of messages remain in the queue

struct Num(uisze);
impl Message for Num {}

struct CrossBus;
impl Actor for CrossBus {
    ...
}

let (addr, _) = CrossBus::start();
let sender = addr.sender();
sender.send(Num(1)).unwrap();
sender.send(Num(2)).unwrap();
sender.send(Num(3)).unwrap();
let receiver = addr.receiver();
assert_eq!(receiver.message_number(), 3)

pub fn set_close(&self)

mark the underlying data exchange gets closed.

NOTE that the underlying message queue wont get closed if any of the following meets:

• at least one sender is alive
• no sender, but messages remains

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

downgrade to WeakReceiver which can later be upgraded

NOTE that the underlying data could be moved or consumed or otherwise

Trait Implementations

impl<M: Message> Debug for Receiver<M>

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

Formats the value using the given formatter.

impl<M: Message> Drop for Receiver<M>

fn drop(&mut self)

Executes the destructor for this type.

impl<M: Message> Into<Receiver<M>> for Addr<M>

fn into(self) -> Receiver<M>

Converts this type into the (usually inferred) input type.

impl<M: Message> Stream for Receiver<M>

type Item = M

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut CoreContext<'_> ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.