Struct PipeBuffer 

pub struct PipeBuffer<T, const N: usize>
where
    T: Transcendental,
{ /* private fields */ }

Single-producer, single-consumer buffer for node connections

This buffer provides wait-free operations and minimal overhead. It is ideal for point-to-point connections between audio nodes.

Type Parameters

• T: Audio sample type (f32 or f64) implementing Transcendental
• N: Buffer size (number of samples per block)

Implementations

impl<T, const N: usize> PipeBuffer<T, N>

where T: Transcendental,

pub fn new() -> PipeBuffer<T, N>

Create a new pipe buffer

The buffer starts empty with no data available.

pub fn write(&self, data: &[T; N])

Write a block of data to the buffer

This operation is wait-free and will overwrite any existing data. The buffer holds at most one block at a time - new writes always overwrite the previous block, regardless of whether it was read.

Arguments

• data - Array of samples to write (must be exactly N samples)

pub fn read(&self) -> Option<[T; N]>

Read a block without consuming (multiple consumers can read the same data)

Unlike try_read, this does not mark the buffer as empty. Multiple callers can read the same data before the next write.

pub fn try_read(&self) -> Option<[T; N]>

Try to read a block of data from the buffer

Returns Some(data) if data is available, None otherwise. This operation is wait-free and non-blocking. This call consumes the data — subsequent readers will get None until the next write.

pub fn read_blocking(&self) -> [T; N]

Read data, blocking until available (for non-real-time use)

This is a convenience method for non-real-time contexts like testing or offline processing. It spins until data is available.

pub fn has_data(&self) -> bool

Check if buffer has valid data available

pub fn write_seq(&self) -> usize

Get write sequence number (for debugging)

pub fn read_seq(&self) -> usize

Get read sequence number (for debugging)

pub fn is_caught_up(&self) -> bool

Check if reader is caught up with writer

pub fn overwrites(&self) -> usize

Get the number of overwritten blocks (for debugging)

pub fn reset(&self)

Reset the buffer to empty state

Clears the valid flag and resets statistics. Does not actually zero the memory (not needed for correctness).

Trait Implementations

impl<T, const N: usize> Clone for PipeBuffer<T, N>

where T: Transcendental + Copy,

fn clone(&self) -> PipeBuffer<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize> Debug for PipeBuffer<T, N>

where T: Transcendental + Debug,

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for PipeBuffer<T, N>

where T: Transcendental,

fn default() -> PipeBuffer<T, N>

Returns the “default value” for a type.

impl<T, const N: usize> SignalBuffer<T> for PipeBuffer<T, N>

where T: Transcendental,

fn capacity(&self) -> usize

Get the total capacity of the buffer in samples

fn len(&self) -> usize

Get the current number of items in the buffer

fn is_empty(&self) -> bool

Check if the buffer is empty

fn is_full(&self) -> bool

Check if the buffer is full

fn clear(&mut self)

Clear all items from the buffer

fn stats(&self) -> BufferStats

Get a snapshot of current buffer statistics

fn reset_stats(&mut self)

Reset all statistics to zero