Struct ArrayDeque

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

A fixed-capacity double-ended queue implemented as a circular buffer.

ArrayDeque provides efficient insertion and removal at both ends with O(1) time complexity. When the deque reaches its capacity, new elements will overwrite the oldest elements (FIFO behavior for overwrites).

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(3);
deque.push_back(1);
deque.push_back(2);
deque.push_front(0);

assert_eq!(deque.len(), 3);
assert_eq!(deque[0], 0);
assert_eq!(deque[1], 1);
assert_eq!(deque[2], 2);

Capacity and Overflow Behavior

When the deque is full and a new element is added:

• push_back will overwrite the front element
• push_front will overwrite the back element

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(2);
deque.push_back(1);
deque.push_back(2);
deque.push_back(3); // Overwrites 1

assert_eq!(deque.pop_front(), Some(2));
assert_eq!(deque.pop_front(), Some(3));

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 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::ArrayDeque;

let mut deque = ArrayDeque::new(3);
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 fn capacity(&self) -> usize

Returns the maximum capacity of the deque.

Examples

use array_deque::ArrayDeque;

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

pub fn len(&self) -> usize

Returns the number of elements currently in the deque.

Examples

use array_deque::ArrayDeque;

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

pub fn is_empty(&self) -> bool

Returns true if the deque contains no elements.

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(3);
assert!(deque.is_empty());
deque.push_back(1);
assert!(!deque.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 deque = ArrayDeque::new(2);
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::ArrayDeque;

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

Trait Implementations

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

fn clone(&self) -> Self

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

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 showing all elements from 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.

The capacity is set to the number of elements in the sequence.

impl<T> Drop for ArrayDeque<T>

fn drop(&mut self)

Properly deallocates the deque’s memory and drops all contained elements.

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

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

Extends the deque with the contents of an iterator.

Elements are added to the back of the deque. If the deque becomes full during extension, older elements will be overwritten.

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(5);
deque.extend(vec![1, 2, 3]);
assert_eq!(deque.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> From<&[T]> for ArrayDeque<T>

where T: Clone,

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

Creates a deque from a slice by cloning all elements.

Examples

use array_deque::ArrayDeque;

let slice = &[1, 2, 3];
let deque: ArrayDeque<i32> = ArrayDeque::from(slice);
assert_eq!(deque.len(), 3);

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

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

Creates a deque from an array reference by cloning all elements.

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

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

Creates a deque from a vector reference by cloning all elements.

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

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

Creates a deque from an array by taking ownership of all elements.

Examples

use array_deque::ArrayDeque;

let array = [1, 2, 3];
let deque: ArrayDeque<i32> = ArrayDeque::from(array);
assert_eq!(deque.len(), 3);

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

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

Creates a deque from a vector by taking ownership of all elements.

Examples

use array_deque::ArrayDeque;

let vec = vec![1, 2, 3];
let deque: ArrayDeque<i32> = ArrayDeque::from(vec);
assert_eq!(deque.len(), 3);

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

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

Creates a deque from an iterator.

The capacity is set to the number of elements in the iterator (with a minimum of 1).

Examples

use array_deque::ArrayDeque;

let deque: ArrayDeque<i32> = (1..4).collect();
assert_eq!(deque.len(), 3);
assert_eq!(deque[0], 1);

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

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()).

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(3);
deque.push_back(10);
deque.push_back(20);
assert_eq!(deque[0], 10);
assert_eq!(deque[1], 20);

type Output = T

The returned type after indexing.

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

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()).

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(3);
deque.push_back(10);
deque[0] = 42;
assert_eq!(deque[0], 42);

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

fn into_iter(self) -> Self::IntoIter

Creates an iterator over references to the deque’s elements.

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(3);
deque.push_back(1);
deque.push_back(2);

for item in &deque {
    println!("{}", item);
}

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

Creates a consuming iterator that moves all elements out of the deque.

The deque cannot be used after calling this method.

Examples

use array_deque::ArrayDeque;

let mut deque = ArrayDeque::new(3);
deque.push_back(1);
deque.push_back(2);

let vec: Vec<i32> = deque.into_iter().collect();
assert_eq!(vec, vec![1, 2]);

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

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

Two deques are equal if they have the same length and all elements compare equal in the same 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 of its elements.

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