Struct fixed_deque::Deque

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

A fixed size VecDeque to match Python Deque https://docs.python.org/3/library/collections.html#collections.deque

Implementations

impl<T> Deque<T>

pub fn new(maxlen: usize) -> Self

Creates a new Deque with a given maximum length.

Examples

use fixed_deque::Deque;

let mut deque: Deque<i32> = Deque::new(3);
deque.push_back(1);
deque.push_back(2);
deque.push_back(3);
deque.push_back(4);
assert_eq!(deque.len(), 3);
assert_eq!(deque.get(0), Some(&2));

pub fn new_from(value: T, maxlen: usize) -> Self

Creates a new Deque from a given single value and maximum length.

Examples

use fixed_deque::Deque;

let deque: Deque<i32> = Deque::new_from(1, 3);
assert_eq!(deque.len(), 1);
assert_eq!(deque.get(0), Some(&1));

pub fn new_from_vec(vec: Vec<T>, maxlen: usize) -> Self

Creates a new Deque from an existing Vec with a given maximum length.

Examples

use fixed_deque::Deque;

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

pub const fn new_from_vec_deque(deque: VecDeque<T>, maxlen: usize) -> Self

Creates a new Deque from an existing VecDeque with a given maximum length.

Examples

use std::collections::VecDeque;
use fixed_deque::Deque;

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

pub fn push_back(&mut self, value: T) -> Option<T>

Add an element to the back of the Deque. If the Deque exceeds its maximum length, the front element is removed.

Examples

use fixed_deque::Deque;

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

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

Removes the first element and returns it, or None if the deque is empty.

Examples

use fixed_deque::Deque;

let mut deque = Deque::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 pop_back(&mut self) -> Option<T>

Removes the last element from the deque and returns it, or None if it is empty.

pub fn len(&self) -> usize

Returns the number of elements in the Deque.

pub fn is_empty(&self) -> bool

Returns whether the Deque is empty.

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

Returns the last element of the Deque.

Examples

use fixed_deque::Deque;

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

pub fn get(&self, index: usize) -> Option<&T>

Returns an immutable reference to the element at the given index.

Examples

use fixed_deque::Deque;
let mut deque: Deque<i32> = Deque::new(3);
deque.push_back(1);
deque.push_back(2);
assert_eq!(deque.get(1), Some(&2));

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element at the given index.

Examples

use fixed_deque::Deque;

let mut deque: Deque<i32> = Deque::new(3);
deque.push_back(1);
deque.push_back(2);
if let Some(value) = deque.get_mut(1) {
    *value = 42;
}
assert_eq!(deque.get(1), Some(&42));

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

Returns an iterator over all elements except the last one.

Examples

use fixed_deque::Deque;

let mut deque: Deque<i32> = Deque::new(3);
deque.push_back(1);
deque.push_back(2);
deque.push_back(3);
let mut iter = deque.iter_except_last();
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), None);

pub fn iter(&self) -> Iter<'_, T>

Returns a front-to-back iterator.

Examples

use fixed_deque::Deque;

let mut deque = Deque::new(3);
deque.push_back(5);
deque.push_back(3);
deque.push_back(4);
let b: &[_] = &[&5, &3, &4];
let c: Vec<&i32> = deque.iter().collect();
assert_eq!(&c[..], b);

pub fn capacity(&self) -> usize

Returns the number of elements the deque can hold without reallocating.

Examples

use fixed_deque::Deque;

let deque: Deque<i32> = Deque::new(10);
assert!(deque.capacity() >= 10);

Trait Implementations

impl<T: Clone> Clone for Deque<T>

fn clone(&self) -> Deque<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Deque<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Deque<T>

fn default() -> Deque<T>

Returns the “default value” for a type.

impl<T> FromIterator<T> for Deque<T>

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

Creates a value from an iterator.

impl<T> Index<usize> for Deque<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Deque<T>

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

Performs the mutable indexing (container[index]) operation.

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Deque<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Deque<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for Deque<T>

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: Eq> Eq for Deque<T>