Struct heapless::spsc::Queue

pub struct Queue<T, const N: usize> { /* private fields */ }

A statically allocated single producer single consumer queue with a capacity of N - 1 elements

IMPORTANT: To get better performance use a value for N that is a power of 2 (e.g. 16, 32, etc.).

Implementations

impl<T, const N: usize> Queue<T, N>

pub const fn new() -> Self

Creates an empty queue with a fixed capacity of N - 1

pub const fn capacity(&self) -> usize

Returns the maximum number of elements the queue can hold

pub fn len(&self) -> usize

Returns the number of elements in the queue

pub fn is_empty(&self) -> bool

Returns true if the queue is empty

pub fn is_full(&self) -> bool

Returns true if the queue is full

pub fn iter(&self) -> Iter<'_, T, N>

Iterates from the front of the queue to the back

pub fn iter_mut(&mut self) -> IterMut<'_, T, N>

Returns an iterator that allows modifying each value

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

Adds an item to the end of the queue

Returns back the item if the queue is full

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 peek(&self) -> Option<&T>

Returns a reference to the item in the front of the queue without dequeuing, or None if the queue is empty.

Examples

use heapless::spsc::Queue;

let mut queue: Queue<u8, 235> = Queue::new();
let (mut producer, mut consumer) = queue.split();
assert_eq!(None, consumer.peek());
producer.enqueue(1);
assert_eq!(Some(&1), consumer.peek());
assert_eq!(Some(1), consumer.dequeue());
assert_eq!(None, consumer.peek());

pub unsafe fn enqueue_unchecked(&mut self, val: T)

Adds an item to the end of the queue, without checking if it’s full

Unsafety

If the queue is full this operation will leak a value (T’s destructor won’t run on the value that got overwritten by item), and will allow the dequeue operation to create a copy of item, which could result in T’s destructor running on item twice.

pub unsafe fn dequeue_unchecked(&mut self) -> T

Returns the item in the front of the queue, without checking if there is something in the queue

Unsafety

If the queue is empty this operation will return uninitialized memory.

pub fn split(&mut self) -> (Producer<'_, T, N>, Consumer<'_, T, N>)

Splits a queue into producer and consumer endpoints

Trait Implementations

impl<T, const N: usize> Clone for Queue<T, N>

where T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, const N: usize> Debug for Queue<T, N>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const N: usize> Default for Queue<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Drop for Queue<T, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const N: usize> Hash for Queue<T, N>

where T: Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given [Hasher].

impl<'a, T, const N: usize> IntoIterator for &'a Queue<T, N>

type Item = &'a T

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Queue<T, N>

type Item = &'a mut T

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const N: usize, const N2: usize> PartialEq<Queue<T, N2>> for Queue<T, N>

where T: PartialEq,

fn eq(&self, other: &Queue<T, N2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, const N: usize> Eq for Queue<T, N>

where T: Eq,