Struct FixedVecDeque

pub struct FixedVecDeque<T>
where
    T: Array,
{ /* private fields */ }

A double-ended queue implemented with a fixed buffer.

Implementations

impl<T> FixedVecDeque<T>

where T: Array, T::Item: Default,

pub fn new() -> Self

Construct a new fixed ring buffer, pre-allocating all elements through Default.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut deq = FixedVecDeque::<[u32; 16]>::new();
assert_eq!(deq, []);
*deq.push_back() = 1;
assert_eq!(deq, [1]);

impl<T> FixedVecDeque<T>

where T: Array,

pub fn is_empty(&self) -> bool

Returns true if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 1]>::new();
assert!(v.is_empty());
*v.push_front() = 1;
assert!(!v.is_empty());

pub fn is_full(&self) -> bool

Returns true if the FixedVecDeque is full.

Writing to a queue that is full will overwrite existing elements.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 1]>::new();
assert!(!v.is_full());
*v.push_front() = 1;
assert!(v.is_full());

pub fn len(&self) -> usize

Returns the number of elements in the FixedVecDeque.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(v.len(), 0);
*v.push_back() = 1;
assert_eq!(v.len(), 1);
*v.push_back() = 1;
assert_eq!(v.len(), 2);

pub fn capacity(&self) -> usize

Returns the number of elements the FixedVecDeque can hold.

Examples

use fixed_vec_deque::FixedVecDeque;

let buf = FixedVecDeque::<[u32; 16]>::new();
assert_eq!(buf.capacity(), 16);

pub fn truncate(&mut self, len: usize)

Shortens the FixedVecDeque, causing excess elements to be unused.

If len is greater than the FixedVecDeque’s current length, this has no effect.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
*buf.push_back() = 5;
*buf.push_back() = 10;
*buf.push_back() = 15;
assert_eq!(buf, [5, 10, 15]);
buf.truncate(1);
assert_eq!(buf, [5]);

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

Provides a reference to the front element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(d.front(), None);

*d.push_back() = 1;
*d.push_back() = 2;
assert_eq!(d.front(), Some(&1));

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

Provides a mutable reference to the front element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();

assert_eq!(d.front_mut(), None);

*d.push_back() = 1;
*d.push_back() = 2;

match d.front_mut() {
    Some(x) => *x = 9,
    None => (),
}

assert_eq!(d.front(), Some(&9));
assert_eq!(d.back(), Some(&2));

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

Provides a reference to the back element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();

assert_eq!(d.back(), None);

*d.push_back() = 1;
*d.push_back() = 2;
assert_eq!(d.back(), Some(&2));

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

Provides a mutable reference to the back element, or None if the FixedVecDeque is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();

assert_eq!(d.back(), None);

*d.push_back() = 1;
*d.push_back() = 2;

match d.back_mut() {
    Some(x) => *x = 9,
    None => (),
}
assert_eq!(d.back(), Some(&9));

pub fn push_front(&mut self) -> &mut T::Item

Prepends an element to the FixedVecDeque.

Panics

Calling this function will panic if the circular buffer is zero-sized.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 3]>::new();

assert_eq!(d.front(), None);
assert_eq!(d.back(), None);

*d.push_front() = 1;
assert_eq!(d.front(), Some(&1));
assert_eq!(d.back(), Some(&1));

*d.push_front() = 2;
assert_eq!(d.front(), Some(&2));
assert_eq!(d.back(), Some(&1));

*d.push_front() = 3;
assert_eq!(d.front(), Some(&3));
assert_eq!(d.back(), Some(&1));

*d.push_front() = 4;
assert_eq!(d.front(), Some(&4));
assert_eq!(d.back(), Some(&2));

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

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

Examples

use fixed_vec_deque::FixedVecDeque;

let mut d = FixedVecDeque::<[u32; 2]>::new();
*d.push_back() = 1;
*d.push_back() = 2;

assert_eq!(d.pop_front(), Some(&mut 1));
assert_eq!(d.pop_front(), Some(&mut 2));
assert_eq!(d.pop_front(), None);

pub fn push_back(&mut self) -> &mut T::Item

Appends an element to the back of the FixedVecDeque by returning a mutable reference that can be modified to it.

Note: this might potentially remove elements from the head, unless they have been read.

Panics

Calling this function will panic if the circular buffer is zero-sized.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(buf.back(), None);
assert_eq!(buf.front(), None);

*buf.push_back() = 1;

assert_eq!(buf.front(), Some(&1));
assert_eq!(buf.back(), Some(&1));

*buf.push_back() = 2;

assert_eq!(buf.front(), Some(&1));
assert_eq!(buf.back(), Some(&2));

*buf.push_back() = 3;

assert_eq!(buf.front(), Some(&2));
assert_eq!(buf.back(), Some(&3));

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 1]>::new();
assert_eq!(buf.back(), None);
assert_eq!(buf.front(), None);

*buf.push_back() = 1;

assert_eq!(buf.front(), Some(&1));
assert_eq!(buf.back(), Some(&1));

*buf.push_back() = 2;

assert_eq!(buf.front(), Some(&2));
assert_eq!(buf.back(), Some(&2));

buf.pop_back();

assert!(buf.is_empty());
assert_eq!(buf.back(), None);
assert_eq!(buf.front(), None);

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

Removes the last element from the FixedVecDeque and returns a reference to it, or None if it is empty.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 2]>::new();
assert_eq!(buf.pop_back(), None);
*buf.push_back() = 1;
*buf.push_back() = 3;
assert_eq!(buf.pop_back(), Some(&mut 3));

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

Removes an element from anywhere in the FixedVecDeque and returns a mutable reference to it, replacing it with the last element.

This does not preserve ordering, but is O(1).

Returns None if index is out of bounds.

Element at index 0 is the front of the queue.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
assert_eq!(buf.swap_remove_back(0), None);
*buf.push_back() = 1;
*buf.push_back() = 2;
*buf.push_back() = 3;
assert_eq!(buf, [1, 2, 3]);

assert_eq!(buf.swap_remove_back(0), Some(&mut 1));
assert_eq!(buf, [3, 2]);

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

Removes an element from anywhere in the FixedVecDeque and returns a reference to it, replacing it with the first element.

This does not preserve ordering, but is O(1).

Returns None if index is out of bounds.

Element at index 0 is the front of the queue.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
assert_eq!(buf.swap_remove_front(0), None);
*buf.push_back() = 1;
*buf.push_back() = 2;
*buf.push_back() = 3;
assert_eq!(buf, [1, 2, 3]);

assert_eq!(buf.swap_remove_front(2), Some(&mut 3));
assert_eq!(buf, [2, 1]);

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

where T::Item: Debug,

Removes and returns the element at index from the VecDeque. Whichever end is closer to the removal point will be moved to make room, and all the affected elements will be moved to new positions. Returns None if index is out of bounds.

Element at index 0 is the front of the queue.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
*buf.push_back() = 1;
*buf.push_back() = 2;
*buf.push_back() = 3;
assert_eq!(buf, [1, 2, 3]);

assert_eq!(buf.remove(1), Some(&mut 2));
assert_eq!(buf, [1, 3]);

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&T::Item) -> bool,

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place and preserves the order of the retained elements.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[usize; 8]>::new();
buf.extend(1..5);
buf.retain(|&x| x % 2 == 0);
assert_eq!(buf, [2, 4]);

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

Returns a front-to-back iterator.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
*buf.push_back() = 5;
*buf.push_back() = 3;
*buf.push_back() = 4;

let b: &[_] = &[&5, &3, &4];
let c: Vec<&u32> = buf.iter().collect();
assert_eq!(&c[..], b);

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

Returns a front-to-back iterator that returns mutable references.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
*buf.push_back() = 5;
*buf.push_back() = 3;
*buf.push_back() = 4;
for num in buf.iter_mut() {
    *num = *num - 2;
}
let b: &[_] = &[&mut 3, &mut 1, &mut 2];
assert_eq!(&buf.iter_mut().collect::<Vec<&mut u32>>()[..], b);

pub fn clear(&mut self)

Clears the FixedVecDeque.

The stored values will not be deleted.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut v = FixedVecDeque::<[u32; 1]>::new();
*v.push_back() = 1;
v.clear();
assert!(v.is_empty());

pub fn contains(&self, x: &T::Item) -> bool

where T::Item: PartialEq<T::Item>,

Returns true if the FixedVecDeque contains an element equal to the given value.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut vector = FixedVecDeque::<[u32; 4]>::new();

*vector.push_back() = 0;
*vector.push_back() = 1;

assert_eq!(vector.contains(&1), true);
assert_eq!(vector.contains(&10), false);

pub fn as_mut_slices(&mut self) -> (&mut [T::Item], &mut [T::Item])

Returns a pair of slices which contain, in order, the contents of the FixedVecDeque.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut vector = FixedVecDeque::<[u32; 6]>::new();

*vector.push_back() = 0;
*vector.push_back() = 1;

*vector.push_front() = 10;
*vector.push_front() = 9;

vector.as_mut_slices().0[0] = 42;
vector.as_mut_slices().1[0] = 24;

assert_eq!(vector.as_slices(), (&[42, 10][..], &[24, 1][..]));

pub fn as_slices(&self) -> (&[T::Item], &[T::Item])

Returns a pair of slices which contain, in order, the contents of the FixedVecDeque.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut vector = FixedVecDeque::<[u32; 5]>::new();

*vector.push_back() = 1;
*vector.push_back() = 2;
*vector.push_back() = 3;

assert_eq!(vector.as_slices(), (&[1, 2, 3][..], &[][..]));

*vector.push_front() = 4;
*vector.push_front() = 5;

assert_eq!(vector.as_slices(), (&[5, 4][..], &[1, 2, 3][..]));

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

Retrieves an element in the FixedVecDeque by index.

Element at index 0 is the front of the queue.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 5]>::new();
*buf.push_back() = 3;
*buf.push_back() = 4;
*buf.push_back() = 5;
assert_eq!(buf.get(1), Some(&4));

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

Retrieves an element in the FixedVecDeque mutably by index.

Element at index 0 is the front of the queue.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 5]>::new();
*buf.push_back() = 3;
*buf.push_back() = 4;
*buf.push_back() = 5;
if let Some(elem) = buf.get_mut(1) {
    *elem = 7;
}

assert_eq!(buf[1], 7);

pub fn swap(&mut self, i: usize, j: usize)

Swaps elements at indices i and j.

i and j may be equal.

Element at index 0 is the front of the queue.

Panics

Panics if either index is out of bounds.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 4]>::new();
*buf.push_back() = 3;
*buf.push_back() = 4;
*buf.push_back() = 5;
assert_eq!(buf, [3, 4, 5]);
buf.swap(0, 2);
assert_eq!(buf, [5, 4, 3]);

impl<T> FixedVecDeque<T>

where T: Array, T::Item: Clone,

pub fn resize(&mut self, new_len: usize, value: T::Item)

Modifies the FixedVecDeque in-place so that len() is equal to new_len, either by removing excess elements from the back or by appending clones of value to the back.

Panics

Panics if new_len is longer than the capacity of this buffer.

Examples

use fixed_vec_deque::FixedVecDeque;

let mut buf = FixedVecDeque::<[u32; 8]>::new();
*buf.push_back() = 5;
*buf.push_back() = 10;
*buf.push_back() = 15;
assert_eq!(buf, [5, 10, 15]);

buf.resize(2, 0);
assert_eq!(buf, [5, 10]);

buf.resize(5, 20);
assert_eq!(buf, [5, 10, 20, 20, 20]);

Trait Implementations

impl<T> Clone for FixedVecDeque<T>

where T: Array, T::Item: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for FixedVecDeque<T>

where T: Array, T::Item: Debug,

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

Formats the value using the given formatter.

impl<T> Default for FixedVecDeque<T>

where T: Array, T::Item: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<A> Extend<<A as Array>::Item> for FixedVecDeque<A>

where A: Array,

fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: 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<A> FromIterator<<A as Array>::Item> for FixedVecDeque<A>

where A: Array, A::Item: Default,

fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> FixedVecDeque<A>

Creates a value from an iterator.

impl<A> Hash for FixedVecDeque<A>

where A: Array, A::Item: Hash,

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> Index<usize> for FixedVecDeque<T>

where T: Array,

type Output = <T as Array>::Item

The returned type after indexing.

fn index(&self, index: usize) -> &T::Item

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for FixedVecDeque<T>

where T: Array,

fn index_mut(&mut self, index: usize) -> &mut T::Item

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

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

where T: Array + 'a,

type Item = &'a <T as Array>::Item

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> Ord for FixedVecDeque<A>

where A: Array, A::Item: Ord,

fn cmp(&self, other: &FixedVecDeque<A>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a, 'b, A, B> PartialEq<&'b [B]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 0]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 0]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 1]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 1]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 10]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 10]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 11]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 11]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 12]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 12]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 13]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 13]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 14]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 14]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 15]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 15]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 16]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 16]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 17]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 17]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 18]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 18]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 19]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 19]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 2]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 2]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 20]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 20]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 21]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 21]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 22]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 22]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 23]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 23]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 24]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 24]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 25]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 25]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 26]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 26]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 27]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 27]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 28]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 28]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 29]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 29]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 3]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 3]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 30]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 30]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 31]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 31]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 32]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 32]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 4]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 4]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 5]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 5]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 6]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 6]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 7]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 7]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 8]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 8]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b [B; 9]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b [B; 9]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 0]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 0]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 1]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 1]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 10]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 10]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 11]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 11]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 12]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 12]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 13]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 13]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 14]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 14]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 15]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 15]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 16]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 16]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 17]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 17]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 18]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 18]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 19]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 19]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 2]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 2]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 20]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 20]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 21]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 21]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 22]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 22]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 23]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 23]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 24]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 24]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 25]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 25]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 26]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 26]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 27]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 27]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 28]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 28]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 29]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 29]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 3]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 3]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 30]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 30]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 31]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 31]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 32]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 32]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 4]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 4]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 5]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 5]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 6]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 6]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 7]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 7]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 8]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 8]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<&'b mut [B; 9]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &&'b mut [B; 9]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 0]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 0]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 1]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 1]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 10]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 10]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 11]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 11]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 12]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 12]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 13]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 13]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 14]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 14]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 15]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 15]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 16]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 16]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 17]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 17]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 18]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 18]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 19]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 19]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 2]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 2]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 20]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 20]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 21]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 21]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 22]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 22]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 23]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 23]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 24]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 24]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 25]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 25]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 26]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 26]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 27]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 27]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 28]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 28]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 29]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 29]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 3]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 3]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 30]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 30]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 31]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 31]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 32]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 32]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 4]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 4]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 5]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 5]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 6]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 6]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 7]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 7]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 8]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 8]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<[B; 9]> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &[B; 9]) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<A, B> PartialEq<FixedVecDeque<B>> for FixedVecDeque<A>

where A: Array, B: Array, A::Item: PartialEq<B::Item>,

fn eq(&self, other: &FixedVecDeque<B>) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<'a, 'b, A, B> PartialEq<Vec<B>> for FixedVecDeque<A>

where A: Array, A::Item: Sized + PartialEq<B>,

fn eq(&self, other: &Vec<B>) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<A> PartialOrd for FixedVecDeque<A>

where A: Array, A::Item: PartialOrd,

fn partial_cmp(&self, other: &FixedVecDeque<A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A> Eq for FixedVecDeque<A>

where A: Array, A::Item: Eq,