Struct ArrayDeque

pub struct ArrayDeque<T> { /* private fields */ }

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

ArrayDeque<T> allocates a buffer on the heap with the given capacity. All insertions and removals at either end run in O(1) time. Once full, further push_back calls overwrite the oldest front element, and push_front calls overwrite the oldest back element (FIFO overwrite behavior).

Examples

use array_deque::ArrayDeque;

let mut dq = ArrayDeque::new(3);
dq.push_back("a");
dq.push_back("b");
dq.push_front("c");
assert_eq!(dq.len(), 3);
assert_eq!(dq[0], "c");

// Overflow: overwrites the back ("b")
dq.push_front("x");
assert_eq!(dq.pop_back(), Some("a"));

Implementations

impl<T> ArrayDeque<T>

pub fn new(cap: usize) -> Self

Creates a new ArrayDeque with the specified capacity.

Arguments

• cap - The fixed capacity of the deque. Must be greater than zero.

Panics

Panics if cap is zero or if memory allocation fails.

Examples

use array_deque::ArrayDeque;

let deque: ArrayDeque<i32> = ArrayDeque::new(10);
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::ArrayDeque;

let mut deque = ArrayDeque::new(3);
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::ArrayDeque;

let mut deque = ArrayDeque::new(3);
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::ArrayDeque;

let mut deque = ArrayDeque::new(3);
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::ArrayDeque;

let mut deque = ArrayDeque::new(3);
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::ArrayDeque;

let mut dq = ArrayDeque::new(3);
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::ArrayDeque;

let mut dq = ArrayDeque::new(3);
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 (front to back).

Examples

use array_deque::ArrayDeque;

let mut dq = ArrayDeque::new(3);
dq.push_back(1);
dq.push_back(2);
let v: Vec<_> = dq.iter().cloned().collect();
assert_eq!(v, vec![1,2]);

pub fn capacity(&self) -> usize

Returns the maximum capacity of the deque.

Examples

use array_deque::ArrayDeque;

let dq: ArrayDeque<i32> = ArrayDeque::new(5);
assert_eq!(dq.capacity(), 5);

pub fn len(&self) -> usize

Returns the number of elements currently in the deque.

Examples

use array_deque::ArrayDeque;

let mut dq = ArrayDeque::new(3);
assert_eq!(dq.len(), 0);
dq.push_back(1);
assert_eq!(dq.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the deque contains no elements.

Examples

use array_deque::ArrayDeque;

let mut dq = ArrayDeque::new(3);
assert!(dq.is_empty());
dq.push_back(1);
assert!(!dq.is_empty());

pub fn is_full(&self) -> bool

Returns true if the deque has reached its maximum capacity.

Examples

use array_deque::ArrayDeque;

let mut dq = ArrayDeque::new(2);
dq.push_back(1);
dq.push_back(2);
assert!(dq.is_full());

pub fn clear(&mut self)

Removes all elements from the deque, properly dropping them, and resets it to an empty state.

Examples

use array_deque::ArrayDeque;

let mut dq = ArrayDeque::new(3);
dq.push_back(1);
dq.clear();
assert!(dq.is_empty());
assert_eq!(dq.len(), 0);

Trait Implementations

impl<T: Clone> Clone for ArrayDeque<T>

fn clone(&self) -> Self

Creates a deep copy of the deque with identical capacity and contents.

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(3);
deque.push_back(1);
deque.push_back(2);
let cloned = deque.clone();
assert_eq!(deque.len(), cloned.len());
assert_eq!(deque[0], cloned[0]);

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ArrayDeque<T>

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

Formats the deque as a debug list (front to back).

impl<'de, T: Deserialize<'de>> Deserialize<'de> for ArrayDeque<T>

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

where D: Deserializer<'de>,

Deserializes a sequence into a deque (capacity == item count).

impl<T> Drop for ArrayDeque<T>

fn drop(&mut self)

Drops all elements and deallocates the heap buffer.

impl<T> Extend<T> for ArrayDeque<T>

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

Extends the deque by pushing each item of the iterator to the back.

Examples

use array_deque::ArrayDeque;

let mut dq = ArrayDeque::new(5);
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: Clone> From<&[T]> for ArrayDeque<T>

fn from(slice: &[T]) -> Self

Clones all elements from a slice into a new deque.

impl<T: Clone, const N: usize> From<&[T; N]> for ArrayDeque<T>

fn from(array: &[T; N]) -> Self

Clones each element from the array reference.

impl<T: Clone> From<&Vec<T>> for ArrayDeque<T>

fn from(vec: &Vec<T>) -> Self

Clones each element from the vector.

impl<T, const N: usize> From<[T; N]> for ArrayDeque<T>

fn from(array: [T; N]) -> Self

Takes ownership of each element in the array.

impl<T> From<Vec<T>> for ArrayDeque<T>

fn from(vec: Vec<T>) -> Self

Takes ownership of each element in the vector.

impl<T> FromIterator<T> for ArrayDeque<T>

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

Creates a deque from an iterator by collecting all items. Capacity == number of items (min 1).

Examples

use array_deque::ArrayDeque;

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

impl<T> Index<usize> for ArrayDeque<T>

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

Indexed access into the deque (0 is front).

Panics

Panics if index >= len().

type Output = T

The returned type after indexing.

impl<T> IndexMut<usize> for ArrayDeque<T>

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

Mutable indexed access into the deque (0 is front).

Panics

Panics if index >= len().

impl<'a, T> IntoIterator for &'a ArrayDeque<T>

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 = ArrayDequeIter<'a, T>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for ArrayDeque<T>

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 = ArrayDequeIntoIter<T>

Which kind of iterator are we turning this into?

impl<T: PartialEq> PartialEq for ArrayDeque<T>

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

Two deques are equal if they have the same length and each element compares equal in 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> Serialize for ArrayDeque<T>

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

where S: Serializer,

Serializes the deque as a sequence (front to back).

impl<T: Eq> Eq for ArrayDeque<T>