Struct Deque

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

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 pop_front_unchecked(&mut self) -> T

Removes an item from the front of the deque and returns it, without checking that the deque is not empty

Safety

It’s undefined behavior to call this on an empty deque

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

Removes an item from the back of the deque and returns it, without checking that the deque is not empty

Safety

It’s undefined behavior to call this on an empty deque

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<'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.

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.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.