Struct piper::Sender

pub struct Sender<T> { /* fields omitted */ }

The sending side of a channel.

This struct is created by the chan function. See its documentation for more.

Senders can be cloned and implement Sink.

Examples

use smol::Task;

let (s1, r) = piper::chan(100);
let s2 = s1.clone();

let t1 = Task::spawn(async move { s1.send(1).await });
let t2 = Task::spawn(async move { s2.send(2).await });

let msg1 = r.recv().await.unwrap();
let msg2 = r.recv().await.unwrap();
assert_eq!(msg1 + msg2, 3);

Implementations

impl<T> Sender<T>

pub async fn send<'_>(&'_ self, msg: T)

Sends a message into the channel.

If the channel is full, this method waits until there is space for a message in the channel. If there are no receivers on this channel, sending waits forever.

Examples

use smol::Task;

let (s, r) = piper::chan(1);

let t = Task::spawn(async move {
    s.send(1).await;
    s.send(2).await;
});

assert_eq!(r.recv().await, Some(1));
assert_eq!(r.recv().await, Some(2));
assert_eq!(r.recv().await, None);

pub fn capacity(&self) -> usize

Returns the channel capacity.

Examples

let (s, _) = piper::chan::<i32>(5);
assert_eq!(s.capacity(), 5);

pub fn is_empty(&self) -> bool

Returns true if the channel is empty.

If the channel's capacity is zero, it is always empty.

Examples

let (s, r) = piper::chan(1);

assert!(s.is_empty());
s.send(0).await;
assert!(!s.is_empty());

pub fn is_full(&self) -> bool

Returns true if the channel is full.

If the channel's capacity is zero, it is always full.

Examples

let (s, r) = piper::chan(1);

assert!(!s.is_full());
s.send(0).await;
assert!(s.is_full());

pub fn len(&self) -> usize

Returns the number of messages in the channel.

Examples

let (s, r) = piper::chan(2);
assert_eq!(s.len(), 0);

s.send(1).await;
s.send(2).await;
assert_eq!(s.len(), 2);

Trait Implementations

impl<T> Clone for Sender<T>

fn clone(&self) -> Sender<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send> Send for Sender<T>

impl<T> Sink<T> for Sender<T>

type Error = Infallible

The type of value produced by the sink when an error occurs.

fn poll_ready(
    self: Pin<&mut Self>,
    _: &mut Context
) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, msg: T) -> 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>,
    cx: &mut Context
) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<T: Send> Sync for Sender<T>

impl<T> Unpin for Sender<T>