Struct Receiver

pub struct Receiver<T> { /* private fields */ }

Asynchronous FIFO receiver

Implementations

impl<T: Unpin> Receiver<T>

pub fn no_senders(&self) -> bool

Returns true if all senders have been dropped

Example

let (tx, mut rx) = async_fifo::new();
tx.send('z');

// one remaining sender
assert_eq!(rx.no_senders(), false);

// drop it
core::mem::drop(tx);

// all senders are gone
assert_eq!(rx.no_senders(), true);

// No sender, yes, but one item is still in there.
assert_eq!(rx.try_recv(), Some('z'));
assert_eq!(rx.try_recv(), None);

pub fn recv(&mut self) -> RecvOne<'_, T>

Receives one item, asynchronously.

Example

let (tx, mut rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c']);

// Receive one by one
assert_eq!(rx.recv().await, Ok('a'));
assert_eq!(rx.recv().await, Ok('b'));
assert_eq!(rx.recv().await, Ok('c'));

core::mem::drop(tx);
assert_eq!(rx.recv().await, Err(Closed));

pub fn recv_many<'a>(&'a mut self, vec: &'a mut Vec<T>) -> FillMany<'a, T>

Receives as many items as possible, into a vector, asynchronously.

The number of received items is returned.

Example

let (tx, mut rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c', 'd']);
 
// Pull as much as possible into a vec
let mut bucket = Vec::new();
assert_eq!(rx.recv_many(&mut bucket).await, Ok(4));
assert_eq!(bucket, ['a', 'b', 'c', 'd']);

core::mem::drop(tx);
assert_eq!(rx.recv_many(&mut bucket).await, Err(Closed));

pub fn recv_exact<'a>(&'a mut self, slice: &'a mut [T]) -> FillExact<'a, T>

Receives exactly slice.len() items into a slice, asynchronously.

Example

let (tx, mut rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c']);
 
// Pull a specific amount into a slice
let mut buffer = ['_'; 3];
assert_eq!(rx.recv_exact(&mut buffer).await, Ok(3));
assert_eq!(buffer, ['a', 'b', 'c']);

core::mem::drop(tx);
assert_eq!(rx.recv_exact(&mut buffer).await, Err(Closed));

pub fn recv_array<const N: usize>(&mut self) -> RecvArray<'_, N, T>

Receives exactly N items into an array, asynchronously.

Example

let (tx, mut rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c']);
 
// Pull a specific amount into an array
assert_eq!(rx.recv_array().await, Ok(['a', 'b', 'c']));

core::mem::drop(tx);
assert_eq!(rx.recv_array::<3>().await, Err(Closed));

impl<T: Unpin> Receiver<T>

pub fn into_recv<S: RecvStorage<T>>(&mut self) -> Recv<'_, S, T>

Receives some items into custom storage, asynchronously.

pub fn into_fill<S: FillStorage<T>>(&mut self, storage: S) -> Fill<'_, S, T>

Receives some items into custom storage, asynchronously.

impl<T: Unpin> Receiver<T>

These methods are only available if you enable the blocking feature.

pub fn recv_blocking(&mut self) -> Result<T, Closed>

Receives one item, blocking.

pub fn recv_array_blocking<const N: usize>(&mut self) -> Result<[T; N], Closed>

Receives exactly N items into an array, blocking.

pub fn recv_many_blocking(&mut self, vec: &mut Vec<T>) -> Result<usize, Closed>

Receives as many items as possible, into a vector, blocking.

pub fn recv_exact_blocking(&mut self, slice: &mut [T]) -> Result<usize, Closed>

Receives exactly slice.len() items into a slice, blocking.

Methods from Deref<Target = Consumer<T>>

pub fn no_producers(&self) -> bool

Returns true if all producers have been dropped

Example

let (tx, rx) = async_fifo::new();
tx.send('z');

// one remaining producer
assert_eq!(rx.no_producers(), false);

// drop it
core::mem::drop(tx);

// all producers are gone
assert_eq!(rx.no_producers(), true);

// No producer, yes, but one item is still in there.
assert_eq!(rx.try_recv(), Some('z'));
assert_eq!(rx.try_recv(), None);

pub fn try_recv(&self) -> Option<T>

Tries to receive one item.

Example

let (tx, rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c']);
 
// Receive one by one
assert_eq!(rx.try_recv(), Some('a'));
assert_eq!(rx.try_recv(), Some('b'));
assert_eq!(rx.try_recv(), Some('c'));
assert_eq!(rx.try_recv(), None);

pub fn try_recv_many(&self, vec: &mut Vec<T>) -> Option<usize>

Tries to receive as many items as possible, into a vector.

If at least one item is received, the number of received items is returned.

Example

let (tx, rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c', 'd']);
 
// Pull as much as possible into a vec
let mut bucket = Vec::new();
assert_eq!(rx.try_recv_many(&mut bucket), Some(4));
assert_eq!(bucket, ['a', 'b', 'c', 'd']);

assert_eq!(rx.try_recv(), None);

pub fn try_recv_exact(&self, slice: &mut [T]) -> Option<()>

Tries to receive exactly slice.len() items into a slice.

Example

let (tx, rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c']);
 
// Pull a specific amount into a slice
let mut buffer = ['_'; 3];
assert!(rx.try_recv_exact(&mut buffer).is_some());
assert_eq!(buffer, ['a', 'b', 'c']);
assert_eq!(rx.try_recv(), None);

pub fn try_recv_array<const N: usize>(&self) -> Option<[T; N]>

Tries to receive exactly N items into an array.

Example

let (tx, rx) = async_fifo::new();
tx.send_iter(['a', 'b', 'c']);
 
// Pull a specific amount into an array
assert_eq!(rx.try_recv_array(), Some(['a', 'b', 'c']));
assert_eq!(rx.try_recv(), None);

pub fn try_recv_into<S: Storage<T>>(&self, storage: S) -> Result<S::Output, S>

Tries to receive some items into custom storage.

Trait Implementations

impl<'a> AsyncRead for Receiver<u8>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8], ) -> Poll<IoResult<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>], ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<T: Clone> Clone for Receiver<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Deref for Receiver<T>

type Target = Consumer<T>

The resulting type after dereferencing.

fn deref(&self) -> &Consumer<T>

Dereferences the value.