Trait RingBuffer

Source

pub unsafe trait RingBuffer<T>:
    Sized
    + IntoIterator<Item = T>
    + Extend<T>
    + Index<usize, Output = T>
    + IndexMut<usize> {
Show 27 methods    // 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 { ... }
}

Expand description

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§

Source

fn push(&mut self, value: T)

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

Source

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

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

Source

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

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

Source

fn clear(&mut self)

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

Source

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.

Source

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§

Source

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.

Source

fn is_empty(&self) -> bool

Returns true if the buffer is entirely empty.

Source

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.

Source

fn capacity(&self) -> usize

Returns the capacity of the buffer.

Source

fn buffer_size(&self) -> usize

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

Source

fn enqueue(&mut self, value: T)

alias for push, forming a more natural counterpart to dequeue

Source

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.

Source

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);

Source

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

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

Source

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

Sets every element in the ringbuffer to value

Source

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.

Source

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.

Source

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)

Source

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)

Source