1.0.0[−][src]Struct boolean_enums::lstd::collections::VecDeque
A double-ended queue implemented with a growable ring buffer.
The "default" usage of this type as a queue is to use push_back
to add to
the queue, and pop_front
to remove from the queue. extend
and append
push onto the back in this manner, and iterating over VecDeque
goes front
to back.
Methods
impl<T> VecDeque<T>
[src]
impl<T> VecDeque<T>
pub fn new() -> VecDeque<T> | [src] |
Creates an empty VecDeque
.
Examples
use std::collections::VecDeque; let vector: VecDeque<u32> = VecDeque::new();
pub fn with_capacity(n: usize) -> VecDeque<T> | [src] |
Creates an empty VecDeque
with space for at least n
elements.
Examples
use std::collections::VecDeque; let vector: VecDeque<u32> = VecDeque::with_capacity(10);
pub fn get(&self, index: usize) -> Option<&T> | [src] |
Retrieves an element in the VecDeque
by index.
Element at index 0 is the front of the queue.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::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> | [src] |
Retrieves an element in the VecDeque
mutably by index.
Element at index 0 is the front of the queue.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::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) | [src] |
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 std::collections::VecDeque; let mut buf = VecDeque::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]);
pub fn capacity(&self) -> usize | [src] |
Returns the number of elements the VecDeque
can hold without
reallocating.
Examples
use std::collections::VecDeque; let buf: VecDeque<i32> = VecDeque::with_capacity(10); assert!(buf.capacity() >= 10);
pub fn reserve_exact(&mut self, additional: usize) | [src] |
Reserves the minimum capacity for exactly additional
more elements to be inserted in the
given VecDeque
. Does nothing if the capacity is already sufficient.
Note that the allocator may give the collection more space than it requests. Therefore
capacity can not be relied upon to be precisely minimal. Prefer reserve
if future
insertions are expected.
Panics
Panics if the new capacity overflows usize
.
Examples
use std::collections::VecDeque; let mut buf: VecDeque<i32> = vec![1].into_iter().collect(); buf.reserve_exact(10); assert!(buf.capacity() >= 11);
pub fn reserve(&mut self, additional: usize) | [src] |
Reserves capacity for at least additional
more elements to be inserted in the given
VecDeque
. The collection may reserve more space to avoid frequent reallocations.
Panics
Panics if the new capacity overflows usize
.
Examples
use std::collections::VecDeque; let mut buf: VecDeque<i32> = vec![1].into_iter().collect(); buf.reserve(10); assert!(buf.capacity() >= 11);
pub fn try_reserve_exact( | [src] |
🔬 This is a nightly-only experimental API. (try_reserve
)
new API
Tries to reserves the minimum capacity for exactly additional
more elements to
be inserted in the given VecDeque<T>
. After calling reserve_exact
,
capacity will be greater than or equal to self.len() + additional
.
Does nothing if the capacity is already sufficient.
Note that the allocator may give the collection more space than it
requests. Therefore capacity can not be relied upon to be precisely
minimal. Prefer reserve
if future insertions are expected.
Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
Examples
#![feature(try_reserve)] use std::collections::CollectionAllocErr; use std::collections::VecDeque; fn process_data(data: &[u32]) -> Result<VecDeque<u32>, CollectionAllocErr> { let mut output = VecDeque::new(); // Pre-reserve the memory, exiting if we can't output.try_reserve_exact(data.len())?; // Now we know this can't OOM in the middle of our complex work output.extend(data.iter().map(|&val| { val * 2 + 5 // very complicated })); Ok(output) }
pub fn try_reserve( | [src] |
🔬 This is a nightly-only experimental API. (try_reserve
)
new API
Tries to reserve capacity for at least additional
more elements to be inserted
in the given VecDeque<T>
. The collection may reserve more space to avoid
frequent reallocations. After calling reserve
, capacity will be
greater than or equal to self.len() + additional
. Does nothing if
capacity is already sufficient.
Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
Examples
#![feature(try_reserve)] use std::collections::CollectionAllocErr; use std::collections::VecDeque; fn process_data(data: &[u32]) -> Result<VecDeque<u32>, CollectionAllocErr> { let mut output = VecDeque::new(); // Pre-reserve the memory, exiting if we can't output.try_reserve(data.len())?; // Now we know this can't OOM in the middle of our complex work output.extend(data.iter().map(|&val| { val * 2 + 5 // very complicated })); Ok(output) }
pub fn shrink_to_fit(&mut self) | 1.5.0 [src] |
Shrinks the capacity of the VecDeque
as much as possible.
It will drop down as close as possible to the length but the allocator may still inform the
VecDeque
that there is space for a few more elements.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::with_capacity(15); buf.extend(0..4); assert_eq!(buf.capacity(), 15); buf.shrink_to_fit(); assert!(buf.capacity() >= 4);
pub fn shrink_to(&mut self, min_capacity: usize) | [src] |
🔬 This is a nightly-only experimental API. (shrink_to
)
new API
Shrinks the capacity of the VecDeque
with a lower bound.
The capacity will remain at least as large as both the length and the supplied value.
Panics if the current capacity is smaller than the supplied minimum capacity.
Examples
#![feature(shrink_to)] use std::collections::VecDeque; let mut buf = VecDeque::with_capacity(15); buf.extend(0..4); assert_eq!(buf.capacity(), 15); buf.shrink_to(6); assert!(buf.capacity() >= 6); buf.shrink_to(0); assert!(buf.capacity() >= 4);
pub fn truncate(&mut self, len: usize) | 1.16.0 [src] |
Shortens the VecDeque
, dropping excess elements from the back.
If len
is greater than the VecDeque
's current length, this has no
effect.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::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]);
ⓘImportant traits for Iter<'a, T>
pub fn iter(&self) -> Iter<T> | [src] |
Returns a front-to-back iterator.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::new(); buf.push_back(5); buf.push_back(3); buf.push_back(4); let b: &[_] = &[&5, &3, &4]; let c: Vec<&i32> = buf.iter().collect(); assert_eq!(&c[..], b);
ⓘImportant traits for IterMut<'a, T>
pub fn iter_mut(&mut self) -> IterMut<T> | [src] |
Returns a front-to-back iterator that returns mutable references.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::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 i32>>()[..], b);
pub fn as_slices(&self) -> (&[T], &[T]) | 1.5.0 [src] |
Returns a pair of slices which contain, in order, the contents of the
VecDeque
.
Examples
use std::collections::VecDeque; let mut vector = VecDeque::new(); vector.push_back(0); vector.push_back(1); vector.push_back(2); assert_eq!(vector.as_slices(), (&[0, 1, 2][..], &[][..])); vector.push_front(10); vector.push_front(9); assert_eq!(vector.as_slices(), (&[9, 10][..], &[0, 1, 2][..]));
pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) | 1.5.0 [src] |
Returns a pair of slices which contain, in order, the contents of the
VecDeque
.
Examples
use std::collections::VecDeque; let mut vector = VecDeque::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 len(&self) -> usize | [src] |
Returns the number of elements in the VecDeque
.
Examples
use std::collections::VecDeque; let mut v = VecDeque::new(); assert_eq!(v.len(), 0); v.push_back(1); assert_eq!(v.len(), 1);
pub fn is_empty(&self) -> bool | [src] |
Returns true
if the VecDeque
is empty.
Examples
use std::collections::VecDeque; let mut v = VecDeque::new(); assert!(v.is_empty()); v.push_front(1); assert!(!v.is_empty());
ⓘImportant traits for Drain<'a, T>
pub fn drain<R>(&mut self, range: R) -> Drain<T> where | 1.6.0 [src] |
Create a draining iterator that removes the specified range in the
VecDeque
and yields the removed items.
Note 1: The element range is removed even if the iterator is not consumed until the end.
Note 2: It is unspecified how many elements are removed from the deque,
if the Drain
value is not dropped, but the borrow it holds expires
(eg. due to mem::forget).
Panics
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
Examples
use std::collections::VecDeque; let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); let drained = v.drain(2..).collect::<VecDeque<_>>(); assert_eq!(drained, [3]); assert_eq!(v, [1, 2]); // A full range clears all contents v.drain(..); assert!(v.is_empty());
pub fn clear(&mut self) | [src] |
Clears the VecDeque
, removing all values.
Examples
use std::collections::VecDeque; let mut v = VecDeque::new(); v.push_back(1); v.clear(); assert!(v.is_empty());
pub fn contains(&self, x: &T) -> bool where | 1.12.0 [src] |
Returns true
if the VecDeque
contains an element equal to the
given value.
Examples
use std::collections::VecDeque; let mut vector: VecDeque<u32> = VecDeque::new(); vector.push_back(0); vector.push_back(1); assert_eq!(vector.contains(&1), true); assert_eq!(vector.contains(&10), false);
pub fn front(&self) -> Option<&T> | [src] |
Provides a reference to the front element, or None
if the VecDeque
is
empty.
Examples
use std::collections::VecDeque; let mut d = VecDeque::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> | [src] |
Provides a mutable reference to the front element, or None
if the
VecDeque
is empty.
Examples
use std::collections::VecDeque; let mut d = VecDeque::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));
pub fn back(&self) -> Option<&T> | [src] |
Provides a reference to the back element, or None
if the VecDeque
is
empty.
Examples
use std::collections::VecDeque; let mut d = VecDeque::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> | [src] |
Provides a mutable reference to the back element, or None
if the
VecDeque
is empty.
Examples
use std::collections::VecDeque; let mut d = VecDeque::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 pop_front(&mut self) -> Option<T> | [src] |
Removes the first element and returns it, or None
if the VecDeque
is
empty.
Examples
use std::collections::VecDeque; let mut d = VecDeque::new(); d.push_back(1); d.push_back(2); assert_eq!(d.pop_front(), Some(1)); assert_eq!(d.pop_front(), Some(2)); assert_eq!(d.pop_front(), None);
pub fn push_front(&mut self, value: T) | [src] |
Prepends an element to the VecDeque
.
Examples
use std::collections::VecDeque; let mut d = VecDeque::new(); d.push_front(1); d.push_front(2); assert_eq!(d.front(), Some(&2));
pub fn push_back(&mut self, value: T) | [src] |
Appends an element to the back of the VecDeque
.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::new(); buf.push_back(1); buf.push_back(3); assert_eq!(3, *buf.back().unwrap());
pub fn pop_back(&mut self) -> Option<T> | [src] |
Removes the last element from the VecDeque
and returns it, or None
if
it is empty.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::new(); assert_eq!(buf.pop_back(), None); buf.push_back(1); buf.push_back(3); assert_eq!(buf.pop_back(), Some(3));
pub fn swap_remove_back(&mut self, index: usize) -> Option<T> | 1.5.0 [src] |
Removes an element from anywhere in the VecDeque
and returns 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 std::collections::VecDeque; let mut buf = VecDeque::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(1)); assert_eq!(buf, [3, 2]);
pub fn swap_remove_front(&mut self, index: usize) -> Option<T> | 1.5.0 [src] |
Removes an element from anywhere in the VecDeque
and returns 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 std::collections::VecDeque; let mut buf = VecDeque::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(3)); assert_eq!(buf, [2, 1]);
pub fn insert(&mut self, index: usize, value: T) | 1.5.0 [src] |
Inserts an element at index
within the VecDeque
, shifting all elements with indices
greater than or equal to index
towards the back.
Element at index 0 is the front of the queue.
Panics
Panics if index
is greater than VecDeque
's length
Examples
use std::collections::VecDeque; let mut vec_deque = VecDeque::new(); vec_deque.push_back('a'); vec_deque.push_back('b'); vec_deque.push_back('c'); assert_eq!(vec_deque, &['a', 'b', 'c']); vec_deque.insert(1, 'd'); assert_eq!(vec_deque, &['a', 'd', 'b', 'c']);
pub fn remove(&mut self, index: usize) -> Option<T> | [src] |
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 std::collections::VecDeque; let mut buf = VecDeque::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(2)); assert_eq!(buf, [1, 3]);
pub fn split_off(&mut self, at: usize) -> VecDeque<T> | 1.4.0 [src] |
Splits the VecDeque
into two at the given index.
Returns a newly allocated VecDeque
. self
contains elements [0, at)
,
and the returned VecDeque
contains elements [at, len)
.
Note that the capacity of self
does not change.
Element at index 0 is the front of the queue.
Panics
Panics if at > len
.
Examples
use std::collections::VecDeque; let mut buf: VecDeque<_> = vec![1,2,3].into_iter().collect(); let buf2 = buf.split_off(1); assert_eq!(buf, [1]); assert_eq!(buf2, [2, 3]);
pub fn append(&mut self, other: &mut VecDeque<T>) | 1.4.0 [src] |
Moves all the elements of other
into Self
, leaving other
empty.
Panics
Panics if the new number of elements in self overflows a usize
.
Examples
use std::collections::VecDeque; let mut buf: VecDeque<_> = vec![1, 2].into_iter().collect(); let mut buf2: VecDeque<_> = vec![3, 4].into_iter().collect(); buf.append(&mut buf2); assert_eq!(buf, [1, 2, 3, 4]); assert_eq!(buf2, []);
pub fn retain<F>(&mut self, f: F) where | 1.4.0 [src] |
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 std::collections::VecDeque; let mut buf = VecDeque::new(); buf.extend(1..5); buf.retain(|&x| x%2 == 0); assert_eq!(buf, [2, 4]);
pub fn resize_with<impl FnMut() -> T>( | 1.33.0 [src] |
Modifies the VecDeque
in-place so that len()
is equal to new_len
,
either by removing excess elements from the back or by appending
elements generated by calling generator
to the back.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::new(); buf.push_back(5); buf.push_back(10); buf.push_back(15); assert_eq!(buf, [5, 10, 15]); buf.resize_with(5, Default::default); assert_eq!(buf, [5, 10, 15, 0, 0]); buf.resize_with(2, || unreachable!()); assert_eq!(buf, [5, 10]); let mut state = 100; buf.resize_with(5, || { state += 1; state }); assert_eq!(buf, [5, 10, 101, 102, 103]);
pub fn rotate_left(&mut self, mid: usize) | [src] |
vecdeque_rotate
)Rotates the double-ended queue mid
places to the left.
Equivalently,
- Rotates item
mid
into the first position. - Pops the first
mid
items and pushes them to the end. - Rotates
len() - mid
places to the right.
Panics
If mid
is greater than len()
. Note that mid == len()
does not panic and is a no-op rotation.
Complexity
Takes O(min(mid, len() - mid))
time and no extra space.
Examples
#![feature(vecdeque_rotate)] use std::collections::VecDeque; let mut buf: VecDeque<_> = (0..10).collect(); buf.rotate_left(3); assert_eq!(buf, [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]); for i in 1..10 { assert_eq!(i * 3 % 10, buf[0]); buf.rotate_left(3); } assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
pub fn rotate_right(&mut self, k: usize) | [src] |
vecdeque_rotate
)Rotates the double-ended queue k
places to the right.
Equivalently,
- Rotates the first item into position
k
. - Pops the last
k
items and pushes them to the front. - Rotates
len() - k
places to the left.
Panics
If k
is greater than len()
. Note that k == len()
does not panic and is a no-op rotation.
Complexity
Takes O(min(k, len() - k))
time and no extra space.
Examples
#![feature(vecdeque_rotate)] use std::collections::VecDeque; let mut buf: VecDeque<_> = (0..10).collect(); buf.rotate_right(3); assert_eq!(buf, [7, 8, 9, 0, 1, 2, 3, 4, 5, 6]); for i in 1..10 { assert_eq!(0, buf[i * 3 % 10]); buf.rotate_right(3); } assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
impl<T> VecDeque<T> where
T: Clone,
[src]
impl<T> VecDeque<T> where
T: Clone,
pub fn resize(&mut self, new_len: usize, value: T) | 1.16.0 [src] |
Modifies the VecDeque
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.
Examples
use std::collections::VecDeque; let mut buf = VecDeque::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<'a, T> Extend<&'a T> for VecDeque<T> where
T: 'a + Copy,
1.2.0[src]
impl<'a, T> Extend<&'a T> for VecDeque<T> where
T: 'a + Copy,
fn extend<I>(&mut self, iter: I) where | [src] |
impl<A> Extend<A> for VecDeque<A>
[src]
impl<A> Extend<A> for VecDeque<A>
fn extend<T>(&mut self, iter: T) where | [src] |
impl<A> Eq for VecDeque<A> where
A: Eq,
[src]
impl<A> Eq for VecDeque<A> where
A: Eq,
impl<T> Clone for VecDeque<T> where
T: Clone,
[src]
impl<T> Clone for VecDeque<T> where
T: Clone,
fn clone(&self) -> VecDeque<T> | [src] |
fn clone_from(&mut self, source: &Self) | [src] |
Performs copy-assignment from source
. Read more
impl<A> Hash for VecDeque<A> where
A: Hash,
[src]
impl<A> Hash for VecDeque<A> where
A: Hash,
fn hash<H>(&self, state: &mut H) where | [src] |
fn hash_slice<H>(data: &[Self], state: &mut H) where | 1.3.0 [src] |
Feeds a slice of this type into the given [Hasher
]. Read more
impl<'a, 'b, A, B> PartialEq<[B; 1]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 1]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 1]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 11]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 11]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 11]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 14]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 14]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 14]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 1]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 1]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 1]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 4]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 4]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 4]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 5]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 5]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 5]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 24]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 24]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 24]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 0]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 0]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 0]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 19]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 19]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 19]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 16]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 16]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 16]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 14]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 14]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 14]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
A: PartialEq<A>,
[src]
impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
A: PartialEq<A>,
fn eq(&self, other: &VecDeque<A>) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<Vec<B>> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<Vec<B>> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &Vec<B>) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 18]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 18]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 18]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 32]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 32]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 32]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 31]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 31]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 31]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 13]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 13]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 13]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 12]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 12]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 12]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 9]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 9]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 9]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 7]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 7]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 7]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 22]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 22]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 22]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 17]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 17]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 17]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 20]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 20]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 20]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 28]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 28]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 28]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 5]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 5]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 5]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 18]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 18]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 18]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 19]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 19]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 19]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 0]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 0]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 0]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 10]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 10]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 10]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 26]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 26]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 26]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 27]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 27]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 27]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 26]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 26]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 26]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 6]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 6]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 6]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 24]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 24]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 24]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 12]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 12]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 12]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 12]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 12]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 12]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 31]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 31]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 31]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 17]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 17]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 17]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 23]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 23]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 23]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 31]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 31]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 31]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 15]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 15]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 15]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 18]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 18]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 18]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 21]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 21]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 21]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 27]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 27]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 27]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 29]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 29]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 29]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 0]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 0]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 0]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 4]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 4]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 4]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 9]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 9]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 9]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 21]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 21]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 21]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 5]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 5]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 5]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 3]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 3]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 3]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 25]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 25]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 25]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 13]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 13]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 13]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 10]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 10]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 10]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 23]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 23]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 23]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 20]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 20]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 20]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 14]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 14]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 14]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 17]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 17]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 17]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 7]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 7]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 7]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 28]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 28]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 28]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 8]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 8]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 8]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 8]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 8]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 8]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 8]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 8]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 8]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 21]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 21]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 21]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 7]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 7]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 7]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 15]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 15]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 15]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 6]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 6]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 6]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 29]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 29]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 29]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 16]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 16]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 16]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 22]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 22]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 22]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 24]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 24]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 24]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 11]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 11]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 11]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 2]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 2]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 2]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 1]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 1]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 1]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 2]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 2]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 2]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 6]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 6]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 6]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 13]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 13]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 13]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 30]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 30]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 30]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 10]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 10]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 10]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 23]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 23]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 23]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 26]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 26]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 26]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 22]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 22]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 22]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 3]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 3]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 3]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 4]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 4]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 4]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 27]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 27]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 27]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 25]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 25]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 25]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 9]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 9]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 9]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 29]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 29]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 29]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 3]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 3]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 3]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 19]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 19]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 19]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 32]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 32]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 32]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 30]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 30]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 30]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 11]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 11]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 11]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 20]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 20]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 20]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 28]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 28]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 28]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 30]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 30]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 30]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 2]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 2]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 2]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 16]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b mut [B; 16]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b mut [B; 16]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<[B; 32]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<[B; 32]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &[B; 32]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 25]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 25]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 25]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<'a, 'b, A, B> PartialEq<&'b [B; 15]> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
impl<'a, 'b, A, B> PartialEq<&'b [B; 15]> for VecDeque<A> where
A: PartialEq<B>,
fn eq(&self, other: &&'b [B; 15]) -> bool | [src] |
| [src] |
This method tests for !=
.
impl<A> Index<usize> for VecDeque<A>
[src]
impl<A> Index<usize> for VecDeque<A>
type Output = A
The returned type after indexing.
ⓘImportant traits for &'a mut W
fn index(&self, index: usize) -> &A | [src] |
impl<'a, T> IntoIterator for &'a VecDeque<T>
[src]
impl<'a, T> IntoIterator for &'a VecDeque<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?
ⓘImportant traits for Iter<'a, T>
fn into_iter(self) -> Iter<'a, T> | [src] |
impl<T> IntoIterator for VecDeque<T>
[src]
impl<T> IntoIterator for VecDeque<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?
ⓘImportant traits for IntoIter<T>
fn into_iter(self) -> IntoIter<T> | [src] |
Consumes the VecDeque
into a front-to-back iterator yielding elements by
value.
impl<'a, T> IntoIterator for &'a mut VecDeque<T>
[src]
impl<'a, T> IntoIterator for &'a mut VecDeque<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?
ⓘImportant traits for IterMut<'a, T>
fn into_iter(self) -> IterMut<'a, T> | [src] |
impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
A: PartialOrd<A>,
[src]
impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
A: PartialOrd<A>,
fn partial_cmp(&self, other: &VecDeque<A>) -> Option<Ordering> | [src] |
| [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| [src] |
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<A> FromIterator<A> for VecDeque<A>
[src]
impl<A> FromIterator<A> for VecDeque<A>
fn from_iter<T>(iter: T) -> VecDeque<A> where | [src] |
impl<T> Debug for VecDeque<T> where
T: Debug,
[src]
impl<T> Debug for VecDeque<T> where
T: Debug,
impl<A> Ord for VecDeque<A> where
A: Ord,
[src]
impl<A> Ord for VecDeque<A> where
A: Ord,
fn cmp(&self, other: &VecDeque<A>) -> Ordering | [src] |
fn max(self, other: Self) -> Self | 1.21.0 [src] |
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self | 1.21.0 [src] |
Compares and returns the minimum of two values. Read more
impl<A> IndexMut<usize> for VecDeque<A>
[src]
impl<A> IndexMut<usize> for VecDeque<A>
impl<T> Default for VecDeque<T>
[src]
impl<T> Default for VecDeque<T>
impl<T> Drop for VecDeque<T>
[src]
impl<T> Drop for VecDeque<T>
impl<T> From<Vec<T>> for VecDeque<T>
1.10.0[src]
impl<T> From<Vec<T>> for VecDeque<T>
impl<T> From<VecDeque<T>> for Vec<T>
1.10.0[src]
impl<T> From<VecDeque<T>> for Vec<T>
Auto Trait Implementations
Blanket Implementations
impl<T, U> Into for T where
U: From<T>,
[src]
impl<T, U> Into for T where
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
impl<T> From for T
[src]
impl<T> From for T
impl<I> IntoIterator for I where
I: Iterator,
[src]
impl<I> IntoIterator for I where
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I | [src] |
impl<T, U> TryFrom for T where
T: From<U>,
[src]
impl<T, U> TryFrom for T where
T: From<U>,
type Error = !
try_from
)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error> | [src] |
impl<T> Borrow for T where
T: ?Sized,
[src]
impl<T> Borrow for T where
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
impl<T> Any for T where
T: 'static + ?Sized,
fn get_type_id(&self) -> TypeId | [src] |
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
try_from
)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> | [src] |
impl<T> BorrowMut for T where
T: ?Sized,
[src]
impl<T> BorrowMut for T where
T: ?Sized,
ⓘImportant traits for &'a mut W
fn borrow_mut(&mut self) -> &mut T | [src] |