Trait ringbuffer::RingBuffer

pub unsafe trait RingBuffer<T>: Sized + IntoIterator<Item = T> + Extend<T> + Index<usize, Output = T> + IndexMut<usize> {
    // Required methods
    fn push(&mut self, value: T);
    fn dequeue(&mut self) -> Option<T>;
    fn fill_with<F: FnMut() -> T>(&mut self, f: F);
    fn clear(&mut self);
    fn get_signed(&self, index: isize) -> Option<&T>;
    fn get(&self, index: usize) -> Option<&T>;

    // Provided methods
    fn len(&self) -> usize { ... }
    fn is_empty(&self) -> bool { ... }
    fn is_full(&self) -> bool { ... }
    fn capacity(&self) -> usize { ... }
    fn buffer_size(&self) -> usize { ... }
    fn enqueue(&mut self, value: T) { ... }
    fn skip(&mut self) { ... }
    fn drain(&mut self) -> RingBufferDrainingIterator<'_, T, Self> { ... }
    fn fill_default(&mut self)
       where T: Default { ... }
    fn fill(&mut self, value: T)
       where T: Clone { ... }
    fn get_mut_signed(&mut self, index: isize) -> Option<&mut T> { ... }
    fn get_mut(&mut self, index: usize) -> Option<&mut T> { ... }
    fn peek(&self) -> Option<&T> { ... }
    fn front(&self) -> Option<&T> { ... }
    fn front_mut(&mut self) -> Option<&mut T> { ... }
    fn back(&self) -> Option<&T> { ... }
    fn back_mut(&mut self) -> Option<&mut T> { ... }
    fn iter_mut(&mut self) -> RingBufferMutIterator<'_, T, Self> { ... }
    fn iter(&self) -> RingBufferIterator<'_, T, Self> { ... }
    fn to_vec(&self) -> Vec<T>
       where T: Clone { ... }
    fn contains(&self, elem: &T) -> bool
       where T: PartialEq { ... }
}

RingBuffer is a trait defining the standard interface for all RingBuffer implementations (AllocRingBuffer, ConstGenericRingBuffer)

This trait is not object safe, so can’t be used dynamically. However it is possible to define a generic function over types implementing RingBuffer.

Safety

Implementing this implies that the ringbuffer upholds some safety guarantees, such as returning a different value from get_mut any for every different index passed in. See the exact requirements in the safety comment on the next function of the mutable Iterator implementation, since these safety guarantees are necessary for iter_mut to work

Required Methods

fn push(&mut self, value: T)

Pushes a value onto the buffer. Cycles around if capacity is reached.

fn dequeue(&mut self) -> Option<T>

dequeues the top item off the ringbuffer, and moves this item out.

fn fill_with<F: FnMut() -> T>(&mut self, f: F)

Sets every element in the ringbuffer to the value returned by f.

fn clear(&mut self)

Empties the buffer entirely. Sets the length to 0 but keeps the capacity allocated.

fn get_signed(&self, index: isize) -> Option<&T>

Gets a value relative to the current index. 0 is the next index to be written to with push. -1 and down are the last elements pushed and 0 and up are the items that were pushed the longest ago.

fn get(&self, index: usize) -> Option<&T>

Gets a value relative to the current index. 0 is the next index to be written to with push.

Provided Methods

fn len(&self) -> usize

Returns the length of the internal buffer. This length grows up to the capacity and then stops growing. This is because when the length is reached, new items are appended at the start.

fn is_empty(&self) -> bool

Returns true if the buffer is entirely empty.

fn is_full(&self) -> bool

Returns true when the length of the ringbuffer equals the capacity. This happens whenever more elements than capacity have been pushed to the buffer.

fn capacity(&self) -> usize

Returns the capacity of the buffer.

fn buffer_size(&self) -> usize

Returns the number of elements allocated for this ringbuffer (can be larger than capacity).

fn enqueue(&mut self, value: T)

alias for push, forming a more natural counterpart to dequeue

fn skip(&mut self)

dequeues the top item off the queue, but does not return it. Instead it is dropped. If the ringbuffer is empty, this function is a nop.

fn drain(&mut self) -> RingBufferDrainingIterator<'_, T, Self>

Returns an iterator over the elements in the ringbuffer, dequeueing elements as they are iterated over.

use ringbuffer::{AllocRingBuffer, RingBuffer};

let mut rb = AllocRingBuffer::new(16);
for i in 0..8 {
    rb.push(i);
}

assert_eq!(rb.len(), 8);

for i in rb.drain() {
    // prints the numbers 0 through 8
    println!("{}", i);
}

// No elements remain
assert_eq!(rb.len(), 0);

fn fill_default(&mut self)where T: Default,

Sets every element in the ringbuffer to it’s default value

fn fill(&mut self, value: T)where T: Clone,

Sets every element in the ringbuffer to value

fn get_mut_signed(&mut self, index: isize) -> Option<&mut T>

Gets a value relative to the current index mutably. 0 is the next index to be written to with push. -1 and down are the last elements pushed and 0 and up are the items that were pushed the longest ago.

fn get_mut(&mut self, index: usize) -> Option<&mut T>

Gets a value relative to the current index mutably. 0 is the next index to be written to with push.

fn peek(&self) -> Option<&T>

Returns the value at the current index. This is the value that will be overwritten by the next push and also the value pushed the longest ago. (alias of Self::front)

fn front(&self) -> Option<&T>

Returns the value at the front of the queue. This is the value that will be overwritten by the next push and also the value pushed the longest ago. (alias of peek)

fn front_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the value at the back of the queue. This is the value that will be overwritten by the next push. (alias of peek)

fn back(&self) -> Option<&T>

Returns the value at the back of the queue. This is the item that was pushed most recently.

fn back_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the value at the back of the queue. This is the item that was pushed most recently.

fn iter_mut(&mut self) -> RingBufferMutIterator<'_, T, Self>

Creates a mutable iterator over the buffer starting from the item pushed the longest ago, and ending at the element most recently pushed.

fn iter(&self) -> RingBufferIterator<'_, T, Self>

Creates an iterator over the buffer starting from the item pushed the longest ago, and ending at the element most recently pushed.

fn to_vec(&self) -> Vec<T>where T: Clone,

Converts the buffer to a vector. This Copies all elements in the ringbuffer.

fn contains(&self, elem: &T) -> boolwhere T: PartialEq,

Returns true if elem is in the ringbuffer.

Implementors

impl<T> RingBuffer<T> for AllocRingBuffer<T>

impl<T> RingBuffer<T> for GrowableAllocRingBuffer<T>

impl<T, const CAP: usize> RingBuffer<T> for ConstGenericRingBuffer<T, CAP>