Struct crossbus::address::Sender

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

A message producer that deliver messages to the Receiver

Implementations

impl<M: Message> Sender<M>

pub fn as_receiver(&self) -> Receiver<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();
assert_eq!(sender.message_number(), 3)

pub fn send(&self, msg: M) -> Result<(), QueueError<M>>where M: Send,

directly push a message into the queue

the message will be inserted the queue and notify the receiver to wake

let sender = addr.sender();
sender.send(Num(1));

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

downgrade to WeakSender which can later be upgraded

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

Trait Implementations

impl<M: Message> Clone for Sender<M>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

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

fn into(self) -> Sender<M>

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

impl<M: Message> Unpin for Sender<M>