Struct RingBuffer

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

A lock-free ring buffer for metric storage

This implementation uses atomic operations to avoid locks in the hot path, ensuring minimal impact on trading system performance.

Implementations

impl<T: Clone> RingBuffer<T>

pub fn new(capacity: usize) -> Self

Create a new ring buffer with the specified capacity

Arguments

• capacity - Buffer capacity, must be a power of 2 (2, 4, 8, 16, 32, 64, 128, …)

Returns

A new RingBuffer with effective capacity of capacity - 1 items.

Panics

Panics if capacity is not a power of 2 or is zero.

Example

let buffer = RingBuffer::new(1024);  // Can hold 1023 items

pub fn push(&self, item: T) -> bool

Push an item into the ring buffer

Returns true if the item was successfully pushed, false if the buffer was full. When full, the overflow counter is incremented and data is lost.

Arguments

• item - The item to push into the buffer

Returns

true if successful, false if buffer was full (overflow)

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

Pop an item from the ring buffer

Returns

Some(item) if an item was available, None if the buffer was empty

pub fn drain(&self, max_items: usize) -> Vec<T>

Drain up to max_items from the buffer

More efficient than repeatedly calling pop() for batch operations.

Arguments

• max_items - Maximum number of items to drain

Returns

Vector of drained items (may be fewer than max_items)

pub fn len(&self) -> usize

Returns the current number of items in the buffer

pub fn is_empty(&self) -> bool

Returns true if the buffer contains no items

pub fn overflow_count(&self) -> usize

Returns the total number of overflow events

pub fn reset_overflow_count(&self)

Resets the overflow counter to zero

Trait Implementations

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

impl<T: Clone + Send> Sync for RingBuffer<T>