Struct heapless::ring_buffer::RingBuffer

pub struct RingBuffer<T, A> where
    A: Unsize<[T]>,  { /* fields omitted */ }

An statically allocated ring buffer backed by an array A

Methods

impl<T, A> RingBuffer<T, A> where
    A: Unsize<[T]>, 

pub fn split(&mut self) -> (Producer<T, A>, Consumer<T, A>)

Splits a statically allocated ring buffer into producer and consumer end points

impl<T, A> RingBuffer<T, A> where
    A: Unsize<[T]>, 

pub const fn new() -> Self

Creates an empty ring buffer with capacity equals to the length of the array A minus one.

pub fn capacity(&self) -> usize

Returns the maximum number of elements the ring buffer can hold

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

Returns the item in the front of the queue, or None if the queue is empty

pub fn enqueue(&mut self, item: T) -> Result<(), BufferFullError>

Adds an item to the end of the queue

Returns BufferFullError if the queue is full

pub fn len(&self) -> usize

Returns the number of elements in the queue

pub fn is_empty(&self) -> bool

Returns true if the ring buffer has a length of 0

Important traits for Iter<'a, T, A>

impl<'a, T, A> Iterator for Iter<'a, T, A> where
    A: Unsize<[T]> + 'a,
    T: 'a,  type Item = &'a T;

pub fn iter(&self) -> Iter<T, A>

Iterates from the front of the queue to the back

Important traits for IterMut<'a, T, A>

impl<'a, T, A> Iterator for IterMut<'a, T, A> where
    A: Unsize<[T]> + 'a,
    T: 'a,  type Item = &'a mut T;

pub fn iter_mut(&mut self) -> IterMut<T, A>

Returns an iterator that allows modifying each value.

Trait Implementations

impl<T, A> Drop for RingBuffer<T, A> where
    A: Unsize<[T]>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T, A> IntoIterator for &'a RingBuffer<T, A> where
    A: Unsize<[T]>, 

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, A> IntoIterator for &'a mut RingBuffer<T, A> where
    A: Unsize<[T]>, 

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.