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 remove_first_matching<F>(&mut self, f: F) -> Option<T>

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

Removes the first element for which the provided closure returns true.

This walks the ring buffer and, upon finding a matching element, removes it. It then shifts all subsequent elements forward (filling the hole created by removing the element).

If an element was removed, this function returns it as Some(elem).

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.