Struct Deque 

pub struct Deque<T, I: Offset> { /* private fields */ }

Double-ended queue with stable indices

Implementations

impl<T, I: Offset> Deque<T, I>

pub fn new() -> Self

pub fn with_capacity(cap: usize) -> Self

Like VecDeque::with_capacity

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

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

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

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

pub fn get(&self, i: I) -> Option<&T>

Returns the element with index i, if it is still in the deque.

pub fn get_mut(&mut self, i: I) -> Option<&mut T>

pub fn push_front(&mut self, e: T) -> I

Panics on index overflow.

pub fn push_back(&mut self, e: T) -> I

Panics on index overflow.

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

Panics on index overflow.

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

Panics on index overflow.

pub fn swap_remove_front(&mut self, i: I) -> Option<T>

Removes the element with index i, by replacing it with the eleement from the front. Invalidates the index of the front element element (now i refers to that) but leaves other indices valid. Panics on index overflow.

pub fn swap_remove_back(&mut self, i: I) -> Option<T>

Removes the element with index i, by replacing it with the eleement from the back. Invalidates the index of the back element (now i refers to that), but leaves other indices valid. Panics on index overflow.

pub fn front_index(&self) -> I

The index of the first item the deque. If the queue is empty, this is the same as end_index.

pub fn end_index(&self) -> I

The index just after the end of the qeue. I.e., the index that would be assigned to a new element added with push_back. Panics on index overflow.

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

Returns a (front-to-back) iterator.

pub fn iter_mut(&mut self) -> IterMut<'_, T, I>

Returns a (front-to-back) iterator which returns mutable references.

pub fn counter(&self) -> &I

I is how many more times pop_front has been called than push_back.

pub fn counter_mut(&mut self) -> &mut I

Modifying this invalidates all indices.

pub fn inner(&self) -> &VecDeque<T>

Allos access to the VecDeque inside this Deque

pub fn inner_mut(&mut self) -> &mut VecDeque<T>

Mutable access to the VecDeque inside this Dequeu. Adding/removing elements at the front of of the VecDeque invalidates all indices.

pub fn into_parts(self) -> (I, VecDeque<T>)

pub fn from_parts(advanced: I, v: VecDeque<T>) -> Self

pub fn as_parts(&self) -> (&I, &VecDeque<T>)

pub fn as_mut_parts(&mut self) -> (&mut I, &mut VecDeque<T>)

Modifying the parts inconsistently will invalidate indices.

Trait Implementations

impl<T: Clone, I: Clone + Offset> Clone for Deque<T, I>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, I: Debug + Offset> Debug for Deque<T, I>

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

Formats the value using the given formatter.

impl<T, I: Offset> Default for Deque<T, I>

fn default() -> Self

Returns the “default value” for a type.

impl<T, I: Offset> Extend<T> for Deque<T, I>

fn extend<X>(&mut self, iter: X)

where X: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

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, I: Offset> FromIterator<T> for Deque<T, I>

fn from_iter<X>(iter: X) -> Self

where X: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<T: Hash, I: Hash + Offset> Hash for Deque<T, I>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, I: Offset> Index<I> for Deque<T, I>

type Output = T

The returned type after indexing.

fn index(&self, i: I) -> &T

Performs the indexing (container[index]) operation.

impl<T, I: Offset> IndexMut<I> for Deque<T, I>

fn index_mut(&mut self, i: I) -> &mut T

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

impl<'v, T, I: Offset> IntoIterator for &'v Deque<T, I>

type Item = (I, &'v T)

The type of the elements being iterated over.

type IntoIter = Iter<'v, T, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'v, T, I>

Creates an iterator from a value.

impl<'v, T, I: Offset> IntoIterator for &'v mut Deque<T, I>

type Item = (I, &'v mut T)

The type of the elements being iterated over.

type IntoIter = IterMut<'v, T, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'v, T, I>

Creates an iterator from a value.

impl<T, I: Offset> IntoIterator for Deque<T, I>

type Item = (I, T)

The type of the elements being iterated over.

type IntoIter = IntoIter<T, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T, I>

Creates an iterator from a value.

impl<T: PartialEq, I: PartialEq + Offset> PartialEq for Deque<T, I>

fn eq(&self, other: &Deque<T, I>) -> 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, I: Eq + Offset> Eq for Deque<T, I>

impl<T, I: Offset> StructuralPartialEq for Deque<T, I>