Struct heapless::Deque

pub struct Deque<T, const N: usize> { /* fields omitted */ }

A fixed capacity double-ended queue.

Examples

use heapless::Deque;

// A deque with a fixed capacity of 8 elements allocated on the stack
let mut deque = Deque::<_, 8>::new();

// You can use it as a good old FIFO queue.
deque.push_back(1);
deque.push_back(2);
assert_eq!(deque.len(), 2);

assert_eq!(deque.pop_front(), Some(1));
assert_eq!(deque.pop_front(), Some(2));
assert_eq!(deque.len(), 0);

// Deque is double-ended, you can push and pop from the front and back.
deque.push_back(1);
deque.push_front(2);
deque.push_back(3);
deque.push_front(4);
assert_eq!(deque.pop_front(), Some(4));
assert_eq!(deque.pop_front(), Some(2));
assert_eq!(deque.pop_front(), Some(1));
assert_eq!(deque.pop_front(), Some(3));

// You can iterate it, yielding all the elements front-to-back.
for x in &deque {
    println!("{}", x);
}

Implementations

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

pub const fn new() -> Self

Constructs a new, empty deque with a fixed capacity of N

Examples

use heapless::Deque;

// allocate the deque on the stack
let mut x: Deque<u8, 16> = Deque::new();

// allocate the deque in a static variable
static mut X: Deque<u8, 16> = Deque::new();

pub const fn capacity(&self) -> usize

Returns the maximum number of elements the deque can hold.

pub const fn len(&self) -> usize

Returns the number of elements currently in the deque.

pub fn clear(&mut self)

Clears the deque, removing all values.

pub fn is_empty(&self) -> bool

Returns whether the deque is empty.

pub fn is_full(&self) -> bool

Returns whether the deque is full (i.e. if len() == capacity().

pub fn as_slices(&self) -> (&[T], &[T])

Returns a pair of slices which contain, in order, the contents of the Deque.

pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T])

Returns a pair of mutable slices which contain, in order, the contents of the Deque.

pub fn front(&self) -> Option<&T>

Provides a reference to the front element, or None if the Deque is empty.

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

Provides a mutable reference to the front element, or None if the Deque is empty.

pub fn back(&self) -> Option<&T>

Provides a reference to the back element, or None if the Deque is empty.

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

Provides a mutable reference to the back element, or None if the Deque is empty.

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

Removes the item from the front of the deque and returns it, or None if it’s empty

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

Removes the item from the back of the deque and returns it, or None if it’s empty

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

Appends an item to the front of the deque

Returns back the item if the deque is full

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

Appends an item to the back of the deque

Returns back the item if the deque is full

pub unsafe fn push_front_unchecked(&mut self, item: T)

Appends an item to the front of the deque

Safety

This assumes the deque is not full.

pub unsafe fn push_back_unchecked(&mut self, item: T)

Appends an item to the back of the deque

Safety

This assumes the deque is not full.

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

Returns an iterator over the deque.

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

Returns an iterator that allows modifying each value.

Trait Implementations

impl<T, const N: usize> Clone for Deque<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: Debug, const N: usize> Debug for Deque<T, N>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const N: usize> IntoIterator for Deque<T, N>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<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 Deque<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 Deque<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.