Struct StackArrayDeque

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

A fixed-capacity, stack-allocated double-ended queue backed by a circular buffer.

StackArrayDeque<T, N> stores up to N elements inline on the stack with no heap allocation. All insertions and removals at either end run in O(1) time. Once full, further push_back calls will overwrite the oldest front element, and push_front calls will overwrite the oldest back element (FIFO overwrite behavior).

Examples

use array_deque::StackArrayDeque;

let mut dq: StackArrayDeque<i32, 3> = StackArrayDeque::new();
dq.push_back(10);
dq.push_back(20);
dq.push_front(5);
assert_eq!(dq.len(), 3);
assert_eq!(dq[0], 5);
assert_eq!(dq[2], 20);

// Overflow: overwrites the front (5)
dq.push_back(30);
assert_eq!(dq.pop_front(), Some(10));

Implementations

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

pub const fn new() -> Self

Creates a new empty StackArrayDeque.

Examples

use array_deque::StackArrayDeque;

let deque: StackArrayDeque<i32, 10> = StackArrayDeque::new();
assert_eq!(deque.capacity(), 10);
assert!(deque.is_empty());

pub fn push_back(&mut self, value: T)

Appends an element to the back of the deque.

If the deque is at capacity, this will overwrite the front element and advance the front pointer.

Arguments

• value - The element to append

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
deque.push_back(1);
deque.push_back(2);
assert_eq!(deque.len(), 2);

pub fn push_front(&mut self, value: T)

Prepends an element to the front of the deque.

If the deque is at capacity, this will overwrite the back element.

Arguments

• value - The element to prepend

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
deque.push_front(1);
deque.push_front(2);
assert_eq!(deque[0], 2);
assert_eq!(deque[1], 1);

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

Removes and returns the last element from the deque.

Returns

Some(T) if the deque is not empty, None otherwise.

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
deque.push_back(1);
deque.push_back(2);
assert_eq!(deque.pop_back(), Some(2));
assert_eq!(deque.pop_back(), Some(1));
assert_eq!(deque.pop_back(), None);

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

Removes and returns the first element from the deque.

Returns

Some(T) if the deque is not empty, None otherwise.

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
deque.push_back(1);
deque.push_back(2);
assert_eq!(deque.pop_front(), Some(1));
assert_eq!(deque.pop_front(), Some(2));
assert_eq!(deque.pop_front(), None);

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

Returns a reference to the front element without removing it.

Examples

use array_deque::StackArrayDeque;

let mut dq: StackArrayDeque<i32, 3> = StackArrayDeque::new();
assert_eq!(dq.front(), None);
dq.push_back(42);
assert_eq!(dq.front(), Some(&42));

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

Returns a reference to the back element without removing it.

Examples

use array_deque::StackArrayDeque;

let mut dq: StackArrayDeque<i32, 3> = StackArrayDeque::new();
dq.push_back(1);
dq.push_back(2);
assert_eq!(dq.back(), Some(&2));

pub fn iter(&self) -> impl Iterator<Item = &T>

Returns an iterator over the elements of the deque.

The iterator yields elements from front to back.

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
deque.push_back(1);
deque.push_back(2);
deque.push_back(3);

let mut iter = deque.iter();
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&3));
assert_eq!(iter.next(), None);

pub const fn capacity(&self) -> usize

Returns the maximum capacity of the deque.

Examples

use array_deque::StackArrayDeque;

let deque: StackArrayDeque<i32, 10> = StackArrayDeque::new();
assert_eq!(deque.capacity(), 10);

pub const fn len(&self) -> usize

Returns the number of elements currently in the deque.

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
assert_eq!(deque.len(), 0);
deque.push_back(1);
assert_eq!(deque.len(), 1);

pub const fn is_empty(&self) -> bool

Returns true if the deque contains no elements.

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
assert!(deque.is_empty());
deque.push_back(1);
assert!(!deque.is_empty());

pub const fn is_full(&self) -> bool

Returns true if the deque has reached its maximum capacity.

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 2> = StackArrayDeque::new();
assert!(!deque.is_full());
deque.push_back(1);
deque.push_back(2);
assert!(deque.is_full());

pub fn clear(&mut self)

Removes all elements from the deque.

This operation properly drops all contained elements and resets the deque to an empty state.

Examples

use array_deque::StackArrayDeque;

let mut deque: StackArrayDeque<i32, 3> = StackArrayDeque::new();
deque.push_back(1);
deque.push_back(2);
deque.clear();
assert!(deque.is_empty());
assert_eq!(deque.len(), 0);

Trait Implementations

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

fn clone(&self) -> Self

Creates a deep copy of the deque with the same capacity and elements.

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

Performs copy-assignment from source.

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

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

Formats the deque as a debug list showing all elements from front to back.

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

fn default() -> Self

Creates an empty deque.

impl<'de, T: Deserialize<'de>, const N: usize> Deserialize<'de> for StackArrayDeque<T, N>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserializes a sequence into a StackArrayDeque, erroring if it exceeds capacity.

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

fn drop(&mut self)

Properly drops all contained elements.

impl<T, const N: usize> Extend<T> for StackArrayDeque<T, N>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends the deque with items from an iterator, pushing to the back.

Examples

use array_deque::StackArrayDeque;

let mut dq: StackArrayDeque<i32, 5> = StackArrayDeque::new();
dq.extend([1,2,3]);
assert_eq!(dq.len(), 3);

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, const N: usize> FromIterator<T> for StackArrayDeque<T, N>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a deque by collecting an iterator into its back, up to capacity.

Examples

use array_deque::StackArrayDeque;

let dq: StackArrayDeque<_, 4> = (0..3).collect();
assert_eq!(dq.len(), 3);

impl<T, const N: usize> Index<usize> for StackArrayDeque<T, N>

fn index(&self, i: usize) -> &Self::Output

Provides indexed access to elements in the deque.

Index 0 corresponds to the front element, index 1 to the second element, etc.

Panics

Panics if the index is out of bounds (>= len()).

type Output = T

The returned type after indexing.

impl<T, const N: usize> IndexMut<usize> for StackArrayDeque<T, N>

fn index_mut(&mut self, i: usize) -> &mut Self::Output

Provides mutable indexed access to elements in the deque.

Panics

Panics if the index is out of bounds (>= len()).

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

fn into_iter(self) -> Self::IntoIter

Borrows the deque and returns an iterator over &T.

type Item = &'a T

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

fn into_iter(self) -> Self::IntoIter

Consumes the deque and returns an iterator over its elements.

type Item = T

The type of the elements being iterated over.

type IntoIter = StackArrayDequeIntoIter<T, N>

Which kind of iterator are we turning this into?

impl<T: PartialEq, const N: usize> PartialEq for StackArrayDeque<T, N>

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

Compares two deques for equality based on their elements and order.

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: Serialize, const N: usize> Serialize for StackArrayDeque<T, N>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serializes the deque as a sequence of its elements from front to back.

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