Struct nolock::queues::spsc::bounded::BoundedReceiver

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

The Receiving-Half for the Queue

Implementations

impl<T> BoundedReceiver<T>

pub fn is_closed(&self) -> bool

Checks if the Queue has been closed by the Producer

Note

Even when this indicates that the Queue has been closed, there might still be Items in the Queue left that should first be dequeued by the Consumer before discarding the entire Queue

Example

let (rx, tx) = bounded::queue::<usize>(3);

// Drop the Producer and therefore also close the Queue
drop(tx);

assert_eq!(true, rx.is_closed());

pub fn try_dequeue(&mut self) -> Result<T, DequeueError>

Attempts to Dequeue a single Element from the Queue

Example

There was something to dequeu

// Create a new Queue with the Capacity for 16-Elements
let (mut rx, mut tx) = bounded::queue::<usize>(16);

// Enqueue the Element
tx.try_enqueue(13);

// Dequeue the Element again
assert_eq!(Ok(13), rx.try_dequeue());

The Queue is empty and therefore nothing could be dequeued

// Create a new Queue with the Capacity for 16-Elements
let (mut rx, mut tx) = bounded::queue::<usize>(16);

// Dequeue the Element again
assert_eq!(Err(DequeueError::WouldBlock), rx.try_dequeue());

pub fn dequeue(&mut self) -> Option<T>

A blocking dequeue operations. This is not lock-free anymore and simply spins while trying to dequeue until it works.

pub fn is_empty(&self) -> bool

Checks if the current queue is empty

Trait Implementations

impl<T> Debug for BoundedReceiver<T>

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

Formats the value using the given formatter.

impl<T> Drop for BoundedReceiver<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for BoundedReceiver<T>

impl<T> Sync for BoundedReceiver<T>