Struct RingBuffer 

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

Zero-copy ring buffer for high-throughput streaming

Safety

This structure uses MaybeUninit for zero-copy performance:

• Values are written with write() before incrementing producer_seq
• The assume_init_read() in try_consume() is safe because we check that producer_seq > current, ensuring data was written

Why this ring also backs the SPSC channel

SpscRing and channel::spsc’s halves are backed by this type. There is one Lamport protocol here — a masked slot array, a Relaxed load of the owner’s own cursor, an Acquire load of the peer’s, a Release store back, and the element written in between — reached through two access disciplines:

• This type is public, exposes the uncached entry points, and stays !Sync (see the Send impl below). Its &self methods mutate through UnsafeCell, so a shared &RingBuffer would let two safe threads race one end of the ring.
• channel::spsc::SpscChannel is crate-private and is Sync, because its Arc must be Send to back 'static halves. Its safety argument is the non-Clone halves plus crate-private reach (ADR-024), which a public type cannot invoke. It adds the cached-index layer, a closed flag, and the spin-then-yield policy.

The bound is not shared: granting Sync here would be unsound for downstream users, and a public type cannot invoke the channel’s argument. The code is shared instead. The cached primitives live on this type as pub(crate) methods, so the discipline stays on the wrapper that can enforce it while the storage, the cursors, and the publication algebra exist exactly once (ADR-016 item 3).

Implementations

impl<T> RingBuffer<T>

pub fn new(capacity: usize) -> Self

Create a new ring buffer with given capacity

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

Try to produce a value, handing it back when the ring is full.

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

Try to consume a value

pub fn capacity(&self) -> usize

Get the capacity of the ring buffer

pub fn is_empty(&self) -> bool

Check if the ring buffer is empty

pub fn is_full(&self) -> bool

Check if the ring buffer is full

pub fn len(&self) -> usize

Get the number of items currently in the buffer

Trait Implementations

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

impl<T: Send> Send for RingBuffer<T>