Struct Queue 

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

FIFO queue with optional bound; cloning shares the queue.

Implementations

impl<T> Queue<T>

pub fn new(cap: Option<usize>) -> Queue<T>

cap = None → unbounded; Some(n) → bounded at n.

pub fn unbounded() -> Queue<T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn has_space(&self) -> bool

Is there room right now? (Zero time; the answer can go stale as soon as another task runs.)

pub fn try_put(&self, item: T) -> Result<(), T>

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

pub fn put(&self, item: T) -> Put<T>

pub fn get(&self) -> Get<T>

pub fn wait_for_space(&self) -> Space<T>

Wait until the queue has room, without handing over an item.

For callers that must do something with the item at the instant it is accepted — a TLM FIFO’s analysis tap, which broadcasts each item as it goes in. put takes ownership, so by the time it returns there is nothing left to show anyone; this splits the wait from the handover:

q.wait_for_space().await;
tap(&item);            // no await between these two lines, so no
let _ = q.try_put(item); // other task can take the space first

impl<T: Clone> Queue<T>

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

The front item without removing it (TLM peek).

A copy, so the item stays in the queue for whoever gets it next. That is why peek needs T: Clone and get does not: get hands over ownership, peek cannot.

pub fn peek(&self) -> Peek<T>

Block until there is something to peek at, then copy it.

Trait Implementations

impl<T> Clone for Queue<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.