Struct kernel::collections::ring_buffer::RingBuffer

pub struct RingBuffer<'a, T: 'a> { /* private fields */ }

Implementations

impl<'a, T: Copy> RingBuffer<'a, T>

pub fn new(ring: &'a mut [T]) -> RingBuffer<'a, T>

pub fn available_len(&self) -> usize

Returns the number of elements that can be enqueued until the ring buffer is full.

pub fn as_slices(&'a self) -> (Option<&'a [T]>, Option<&'a [T]>)

Returns up to 2 slices that together form the contents of the ring buffer.

Returns:

• (None, None) if the buffer is empty.
• (Some(slice), None) if the head is before the tail (therefore all the contents is contiguous).
• (Some(left), Some(right)) if the head is after the tail. In that case, the logical contents of the buffer is [left, right].concat() (although physically the “left” slice is stored after the “right” slice).

Trait Implementations

impl<T: Copy> Queue<T> for RingBuffer<'_, T>

fn has_elements(&self) -> bool

Returns true if there are any items in the queue, false otherwise.

fn is_full(&self) -> bool

Returns true if the queue is full, false otherwise.

fn len(&self) -> usize

Returns how many elements are in the queue.

fn enqueue(&mut self, val: T) -> bool

If the queue isn’t full, add a new element to the back of the queue. Returns whether the element was added.

fn push(&mut self, val: T) -> Option<T>

Add a new element to the back of the queue, poping one from the front if necessary.

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

Remove the element from the front of the queue.

fn empty(&mut self)

Remove all elements from the ring buffer.

fn retain<F>(&mut self, f: F)

where F: FnMut(&T) -> bool,

Retains only the elements that satisfy the predicate.