Type Alias Deque 

pub type Deque<T, const N: usize> = DequeInner<T, OwnedVecStorage<T, N>>;

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);
}

Aliased Type

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

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.

This method is not available on a DequeView, use storage_capacity instead.

pub const fn len(&self) -> usize

Returns the number of elements currently in the deque.

This method is not available on a DequeView, use storage_len instead.

Trait Implementations

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

where T: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T, const NS: usize, const ND: usize> TryFrom<[T; NS]> for Deque<T, ND>

type Error = (CapacityError, [T; NS])

Converts a [T; NS] into a Deque<T, ND>.

use heapless::Deque;

let deq1 = Deque::<u8, 5>::try_from([1, 2, 3]).unwrap();
let mut deq2 = Deque::<u8, 5>::new();
deq2.push_back(1).unwrap();
deq2.push_back(2).unwrap();
deq2.push_back(3).unwrap();

assert_eq!(deq1, deq2);

fn try_from(value: [T; NS]) -> Result<Self, Self::Error>

Converts a [T; NS] array into a Deque<T, ND>.

Returns back the value if NS > ND.

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