Struct Sender 

pub struct Sender<T: Send + Sync + 'static> { /* private fields */ }

Sends values to every Receiver of the channel.

Created by channel. Clone it for more producers. The channel closes for the receivers when the last sender is dropped.

Implementations

impl<T: Send + Sync + 'static> Sender<T>

pub fn new(capacity: usize) -> Self

A sender of a new channel holding the last capacity values (rounded up to a power of two), with no receiver yet: each comes from subscribe.

Panics

When capacity is zero, or above usize::MAX / 2.

use nuclei::sync::broadcast::Sender;

let tx = Sender::new(4);
assert!(tx.send(1).is_err(), "no receiver yet");
let mut rx = tx.subscribe();
tx.send(2).unwrap();
assert_eq!(rx.try_recv(), Ok(2));

pub fn send(&self, value: T) -> Result<usize, SendError<T>>

Sends value to every receiver there is now, returning how many.

A send never waits: the channel holds the last capacity values, and a receiver too far behind loses the oldest.

Errors

When there is no receiver; the value is handed back.

use nuclei::sync::broadcast;

let (tx, rx) = broadcast::channel(2);
assert_eq!(tx.send("a"), Ok(1));
drop(rx);
assert_eq!(tx.send("b").unwrap_err().0, "b");

pub fn subscribe(&self) -> Receiver<T>

A new receiver, which takes the values sent from now on.

use nuclei::sync::broadcast;

let (tx, _rx) = broadcast::channel(2);
tx.send(1).unwrap();
let mut late = tx.subscribe();
tx.send(2).unwrap();
assert_eq!(late.try_recv(), Ok(2));

pub fn receiver_count(&self) -> usize

How many receivers there are.

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

A WeakSender of the channel, which does not keep it open. The sender itself stays.

pub fn strong_count(&self) -> usize

How many Senders exist.

pub fn weak_count(&self) -> usize

How many WeakSenders exist.

pub fn len(&self) -> usize

How many values the slowest receiver has yet to take, at most the capacity (older ones are lost to it); zero with no receiver.

use nuclei::sync::broadcast;

let (tx, mut rx) = broadcast::channel(4);
tx.send(1).unwrap();
tx.send(2).unwrap();
assert_eq!(tx.len(), 2);
rx.try_recv().unwrap();
assert_eq!(tx.len(), 1);

pub fn is_empty(&self) -> bool

Whether every receiver took every value it can still take.

pub fn same_channel(&self, other: &Self) -> bool

Whether other sends on the same channel.

pub async fn closed(&self)

Completes once there is no receiver.

use core::future::Future;
use core::pin::pin;
use core::task::{Context, Poll, Waker};
use nuclei::sync::broadcast;

let (tx, rx) = broadcast::channel::<u8>(1);
let mut cx = Context::from_waker(Waker::noop());
let mut closed = pin!(tx.closed());
assert_eq!(closed.as_mut().poll(&mut cx), Poll::Pending);
drop(rx);
assert_eq!(closed.as_mut().poll(&mut cx), Poll::Ready(()));

Trait Implementations

impl<T: Send + Sync + 'static> Clone for Sender<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Send + Sync + 'static> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T: Send + Sync + 'static> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.