Struct Producer 

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

Write half of the SPSC ring. Not Clone — only one producer exists.

Implementations

impl<T> Producer<T>

pub fn is_disconnected(&self) -> bool

Returns true if the consumer has been dropped.

pub fn try_push(&self, value: T) -> Result<(), TrySendError<T>>

Push a value. Returns Err if the buffer is full or the consumer has been dropped.

Errors

• TrySendError::Full — buffer is full; value is returned unchanged.
• TrySendError::Disconnected — consumer has been dropped; value is returned unchanged.

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 returned value can differ from the true count in either direction: a concurrent pop can lower it, and a stale Relaxed read of head can raise it. 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).

Must NOT be used for

• Deciding whether try_push will succeed — use the Err return value of try_push 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 _ = tx.len(); // safe: backpressure hint only

pub fn is_empty(&self) -> bool

Returns true if the buffer appears empty.

pub fn is_full(&self) -> bool

Returns true if the buffer appears full.

pub fn capacity(&self) -> usize

Buffer capacity.

pub fn push( &self, value: T, strategy: &WaitStrategy, ) -> Result<(), SendError<T>>

Push a value, blocking with strategy until a slot is free.

Errors

Returns SendError containing the value if the consumer has been dropped.

impl<T: Copy> Producer<T>

pub fn push_slice(&self, src: &[T]) -> usize

Push as many items from src as fit. Returns count pushed.

Stops early if the buffer is full or the consumer has been dropped. If count < src.len(), call Producer::is_disconnected to distinguish the two cases — a full buffer is retriable, a disconnect is permanent.

Trait Implementations

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