Struct ChangelogBuffer 

pub struct ChangelogBuffer { /* private fields */ }

Ring 0 changelog buffer (pre-allocated, reused per epoch).

This buffer stores changelog references without allocating on the hot path (after initial warmup). When the buffer is full, it signals backpressure.

Example

use laminar_core::operator::changelog::{ChangelogBuffer, ChangelogRef};

let mut buffer = ChangelogBuffer::with_capacity(1024);

// Push references (no allocation after warmup)
for i in 0..100 {
    buffer.push(ChangelogRef::insert(i, 0));
}

// Drain for Ring 1 processing
for changelog_ref in buffer.drain() {
    // Process in Ring 1
}

Implementations

impl ChangelogBuffer

pub fn with_capacity(capacity: usize) -> Self

Creates a new buffer with the given capacity.

pub fn push(&mut self, changelog_ref: ChangelogRef) -> bool

Pushes a changelog reference (no allocation if under capacity).

Returns true if the reference was added, false if buffer is full (backpressure signal).

pub fn push_retraction( &mut self, batch_offset: u32, old_row_index: u32, new_row_index: u32, ) -> bool

Pushes a retraction pair (update-before, update-after).

Returns true if both references were added, false if buffer is full.

pub fn drain(&mut self) -> impl Iterator<Item = ChangelogRef> + '_

Drains references for Ring 1 processing.

After draining, the buffer is empty but retains its capacity.

pub fn len(&self) -> usize

Returns current count of references.

pub fn is_empty(&self) -> bool

Returns true if the buffer is empty.

pub fn is_full(&self) -> bool

Returns true if the buffer is full.

pub fn capacity(&self) -> usize

Returns the buffer capacity.

pub fn available(&self) -> usize

Returns available space in the buffer.

pub fn clear(&mut self)

Clears the buffer without deallocating.

pub fn as_slice(&self) -> &[ChangelogRef]

Returns a slice of the current references.

Trait Implementations

impl Default for ChangelogBuffer

fn default() -> Self

Returns the “default value” for a type.