Struct RingBuffer 

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

Fixed-size ring buffer (power-of-two size). Single-threaded.

Used inside the signal graph for delay effects and sample buffering. Size must be a power of two.

Example

use rill_core::buffer::RingBuffer;

let mut buffer = RingBuffer::<f32, 4>::new();
buffer.write(1.0);
buffer.write(2.0);
assert_eq!(buffer.read_delayed(0), 2.0);

Implementations

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

where T: Transcendental,

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

Create a new ring buffer.

Panics

Panics if N is not a power of two.

pub fn write(&mut self, sample: T)

Write a single sample, advancing the head cursor.

pub fn write_slice(&mut self, samples: &[T])

where T: Copy,

Write multiple samples in sequence.

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

Read the oldest sample, or None if empty.

pub fn read_delayed(&self, delay: usize) -> T

Read a sample at delay samples behind head (0 = most recent).

Panics

Panics if delay >= len().

pub fn read_interpolated(&self, delay_frac: f32) -> T

where T: From<f32> + Into<f32>,

Read with linear interpolation between samples at fractional delay.

pub fn read_sequence_interpolated(&self, start_delay: f32, output: &mut [T])

where T: From<f32> + Into<f32>,

Read a sequence of interpolated samples into the output buffer, starting at start_delay samples behind head.

pub fn len(&self) -> usize

Number of samples currently stored.

pub const fn capacity(&self) -> usize

Maximum capacity (const generic parameter).

pub fn is_empty(&self) -> bool

Whether the buffer has no samples.

pub fn is_full(&self) -> bool

Whether the buffer is completely full.

pub fn clear(&mut self)

Clear all samples and reset cursors.

pub fn reset(&mut self)

Reset cursors without zeroing the data.

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

where T: Transcendental,

pub fn iter(&self) -> RingBufferIter<'_, T, N>

Iterate over buffered samples from oldest to newest.

Trait Implementations

impl<T, const N: usize> Buffer<T> for RingBuffer<T, N>

where T: Transcendental,

fn capacity(&self) -> usize

Maximum number of elements the buffer can hold.

fn len(&self) -> usize

Current number of elements in the buffer.

fn is_empty(&self) -> bool

Whether the buffer is empty (len() == 0).

fn is_full(&self) -> bool

Whether the buffer is full (len() == capacity()).

fn as_slice(&self) -> &[T]

Read-only access to the buffer data.

fn as_mut_slice(&mut self) -> &mut [T]

Mutable access to the buffer data.

fn fill(&mut self, value: T)

Fill the entire buffer with a value.

fn copy_from(&mut self, src: &[T])

Copy data from a slice. Copies min(src.len(), self.len()) samples.

fn clear(&mut self)

Remove all items from the buffer.

fn stats(&self) -> BufferStats

Snapshot of performance statistics.

fn reset_stats(&mut self)

Reset performance counters (not the data).

impl<T, const N: usize> Debug for RingBuffer<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 RingBuffer<T, N>

where T: Transcendental,

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

Returns the “default value” for a type.