Struct Consumer 

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

Read half of the SPSC ring. Not Clone — only one consumer exists.

Implementations

impl<T> Consumer<T>

pub fn is_disconnected(&self) -> bool

Returns true if the producer has been dropped.

pub fn try_pop(&self) -> Result<T, TryRecvError>

Pop a value.

Errors

• TryRecvError::Empty — buffer is empty; try again later.
• TryRecvError::Disconnected — producer has been dropped and buffer is empty.

pub fn len(&self) -> usize

Approximate number of items currently in the buffer.

Why approximate

Reads both tail (owned by the producer) and head (owned by the consumer) with Ordering::Relaxed. The producer may have advanced tail between the two loads, so the returned value can be lower than the true count. The result is a best-effort snapshot, not a linearizable read.

Safe uses

• Capacity planning and monitoring dashboards.
• Backpressure hints (e.g., slow down if len() < threshold before sleeping).

Must NOT be used for

• Deciding whether try_pop will return Ok — use the Err return value of try_pop instead.
• Any correctness decision that requires an exact count.

Example

use spsc_ring::ring;
let (tx, rx) = ring::<u32>(16).unwrap();
tx.try_push(1).unwrap();
tx.try_push(2).unwrap();
// len() is a hint — do not assert == 2 across threads.
let _ = rx.len(); // safe: backpressure hint only

pub fn is_empty(&self) -> bool

Returns true if the buffer appears empty.

pub fn capacity(&self) -> usize

Buffer capacity.

pub fn pop(&self, strategy: &WaitStrategy) -> Result<T, RecvError>

Pop a value, blocking with strategy until one is available.

Errors

Returns RecvError if the producer has been dropped and the buffer is empty.

impl<T: Copy> Consumer<T>

pub fn pop_into_slice(&self, dst: &mut [T]) -> usize

Pop as many items into dst as are available. Returns count popped.

Stops early if the buffer is empty or the producer has been dropped. If count < dst.len(), call Consumer::is_disconnected to distinguish the two cases — an empty buffer may refill, a disconnect will not.

Trait Implementations

impl<T> Drop for Consumer<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.