pub struct VecDeque<T> { /* fields omitted */ }
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.
impl<T> VecDeque<T>[src]
pub fn new() -> VecDeque<T>[src]
Creates an empty VecDeque.
use std::collections::VecDeque; let vector: VecDeque<u32> = VecDeque::new();
pub fn with_capacity(capacity: usize) -> VecDeque<T>[src]
Creates an empty VecDeque with space for at least capacity elements.
use std::collections::VecDeque; let vector: VecDeque<u32> = VecDeque::with_capacity(10);
pub fn get(&self, index: usize) -> Option<&T>[src]
Provides a reference to the element at the given index.
Element at index 0 is the front of the queue.
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]
Provides a mutable reference to the element at the given index.
Element at index 0 is the front of the queue.
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 if either index is out of bounds.
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.
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 if the new capacity overflows usize.
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 if the new capacity overflows usize.
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(
&mut self,
additional: usize
) -> Result<(), TryReserveError>[src]
Tries to reserve 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.
If the capacity overflows usize, or the allocator reports a failure, then an error is returned.
#![feature(try_reserve)]
use std::collections::TryReserveError;
use std::collections::VecDeque;
fn process_data(data: &[u32]) -> Result<VecDeque<u32>, TryReserveError> {
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(Out-Of-Memory) in the middle of our complex work
output.extend(data.iter().map(|&val| {
val * 2 + 5 // very complicated
}));
Ok(output)
}pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>[src]
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.
If the capacity overflows usize, or the allocator reports a failure, then an error is returned.
#![feature(try_reserve)]
use std::collections::TryReserveError;
use std::collections::VecDeque;
fn process_data(data: &[u32]) -> Result<VecDeque<u32>, TryReserveError> {
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)[src]1.5.0
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.
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]
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.
#![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)[src]1.16.0
Shortens the VecDeque, keeping the first len elements and dropping the rest.
If len is greater than the VecDeque's current length, this has no effect.
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]);
pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>
type Item = &'a T;
[src]
Returns a front-to-back iterator.
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);
pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>
type Item = &'a mut T;
[src]
Returns a front-to-back iterator that returns mutable references.
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])[src]1.5.0
Returns a pair of slices which contain, in order, the contents of the VecDeque.
If make_contiguous was previously called, all elements of the VecDeque will be in the first slice and the second slice will be empty.
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])[src]1.5.0
Returns a pair of slices which contain, in order, the contents of the VecDeque.
If make_contiguous was previously called, all elements of the VecDeque will be in the first slice and the second slice will be empty.
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.
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.
use std::collections::VecDeque; let mut v = VecDeque::new(); assert!(v.is_empty()); v.push_front(1); assert!(!v.is_empty());
pub fn range<R>(&self, range: R) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>
type Item = &'a T;
where
R: RangeBounds<usize>, [src]
Creates an iterator that covers the specified range in the VecDeque.
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
#![feature(deque_range)] use std::collections::VecDeque; let v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); let range = v.range(2..).copied().collect::<VecDeque<_>>(); assert_eq!(range, [3]); // A full range covers all contents let all = v.range(..); assert_eq!(all.len(), 3);
pub fn range_mut<R>(&mut self, range: R) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>
type Item = &'a mut T;
where
R: RangeBounds<usize>, [src]
Creates an iterator that covers the specified mutable range in the VecDeque.
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
#![feature(deque_range)]
use std::collections::VecDeque;
let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
for v in v.range_mut(2..) {
*v *= 2;
}
assert_eq!(v, vec![1, 2, 6]);
// A full range covers all contents
for v in v.range_mut(..) {
*v *= 2;
}
assert_eq!(v, vec![2, 4, 12]);pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>ⓘNotable traits for Drain<'_, T>
impl<'_, T> Iterator for Drain<'_, T>
type Item = T;
where
R: RangeBounds<usize>, [src]1.6.0
Creates 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 (e.g., due to mem::forget).
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
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.
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
T: PartialEq<T>, [src]1.12.0
Returns true if the VecDeque contains an element equal to the given value.
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.
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.
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.
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.
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.
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 pop_back(&mut self) -> Option<T>[src]
Removes the last element from the VecDeque and returns it, or None if it is empty.
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 push_front(&mut self, value: T)[src]
Prepends an element to the VecDeque.
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.
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 swap_remove_front(&mut self, index: usize) -> Option<T>[src]1.5.0
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.
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 swap_remove_back(&mut self, index: usize) -> Option<T>[src]1.5.0
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.
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 insert(&mut self, index: usize, value: T)[src]1.5.0
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 if index is greater than VecDeque's length
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.
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]);
#[must_use = "use `.truncate()` if you don't need the other half"]pub fn split_off(&mut self, at: usize) -> VecDeque<T>[src]1.4.0
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 if at > len.
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>)[src]1.4.0
Moves all the elements of other into self, leaving other empty.
Panics if the new number of elements in self overflows a usize.
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
F: FnMut(&T) -> bool, [src]1.4.0
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, visiting each element exactly once in the original order, and preserves the order of the retained elements.
use std::collections::VecDeque; let mut buf = VecDeque::new(); buf.extend(1..5); buf.retain(|&x| x % 2 == 0); assert_eq!(buf, [2, 4]);
The exact order may be useful for tracking external state, like an index.
use std::collections::VecDeque; let mut buf = VecDeque::new(); buf.extend(1..6); let keep = [false, true, true, false, true]; let mut i = 0; buf.retain(|_| (keep[i], i += 1).0); assert_eq!(buf, [2, 3, 5]);
pub fn resize_with(&mut self, new_len: usize, generator: impl FnMut() -> T)[src]1.33.0
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.
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 make_contiguous(&mut self) -> &mut [T]ⓘNotable traits for &'_ [u8]
impl<'_> Read for &'_ [u8]
impl<'_> Write for &'_ mut [u8]
[src]
Rearranges the internal storage of this deque so it is one contiguous slice, which is then returned.
This method does not allocate and does not change the order of the inserted elements. As it returns a mutable slice, this can be used to sort or binary search a deque.
Once the internal storage is contiguous, the as_slices and as_mut_slices methods will return the entire contents of the VecDeque in a single slice.
Sorting the content of a deque.
#![feature(deque_make_contiguous)] use std::collections::VecDeque; let mut buf = VecDeque::with_capacity(15); buf.push_back(2); buf.push_back(1); buf.push_front(3); // sorting the deque buf.make_contiguous().sort(); assert_eq!(buf.as_slices(), (&[1, 2, 3] as &[_], &[] as &[_])); // sorting it in reverse order buf.make_contiguous().sort_by(|a, b| b.cmp(a)); assert_eq!(buf.as_slices(), (&[3, 2, 1] as &[_], &[] as &[_]));
Getting immutable access to the contiguous slice.
#![feature(deque_make_contiguous)]
use std::collections::VecDeque;
let mut buf = VecDeque::new();
buf.push_back(2);
buf.push_back(1);
buf.push_front(3);
buf.make_contiguous();
if let (slice, &[]) = buf.as_slices() {
// we can now be sure that `slice` contains all elements of the deque,
// while still having immutable access to `buf`.
assert_eq!(buf.len(), slice.len());
assert_eq!(slice, &[3, 2, 1] as &[_]);
}pub fn rotate_left(&mut self, mid: usize)[src]1.36.0
Rotates the double-ended queue mid places to the left.
Equivalently,
mid into the first position.mid items and pushes them to the end.len() - mid places to the right.If mid is greater than len(). Note that mid == len() does not panic and is a no-op rotation.
Takes *O*(min(mid, len() - mid)) time and no extra space.
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]1.36.0
Rotates the double-ended queue k places to the right.
Equivalently,
k.k items and pushes them to the front.len() - k places to the left.If k is greater than len(). Note that k == len() does not panic and is a no-op rotation.
Takes *O*(min(k, len() - k)) time and no extra space.
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]
pub fn resize(&mut self, new_len: usize, value: T)[src]1.16.0
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.
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]);
impl<T> Clone for VecDeque<T> where
T: Clone, [src]
impl<T> Debug for VecDeque<T> where
T: Debug, [src]
impl<T> Default for VecDeque<T>[src]
impl<T> Drop for VecDeque<T>[src]
impl<A> Eq for VecDeque<A> where
A: Eq, [src]
impl<'a, T> Extend<&'a T> for VecDeque<T> where
T: 'a + Copy, [src]1.2.0
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = &'a T>, [src]
fn extend_one(&mut self, &T)[src]
fn extend_reserve(&mut self, additional: usize)[src]
impl<A> Extend<A> for VecDeque<A>[src]
fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = A>, [src]
fn extend_one(&mut self, elem: A)[src]
fn extend_reserve(&mut self, additional: usize)[src]
impl<T> From<Vec<T>> for VecDeque<T>[src]1.10.0
fn from(other: Vec<T>) -> VecDeque<T>[src]
Turn a Vec<T> into a VecDeque<T>.
This avoids reallocating where possible, but the conditions for that are strict, and subject to change, and so shouldn't be relied upon unless the Vec<T> came from From<VecDeque<T>> and hasn't been reallocated.
impl<T> From<VecDeque<T>> for Vec<T>[src]1.10.0
fn from(other: VecDeque<T>) -> Vec<T>ⓘNotable traits for Vec<u8>
impl Write for Vec<u8>
[src]
Turn a VecDeque<T> into a Vec<T>.
This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn't happen to be at the beginning of the allocation.
use std::collections::VecDeque; // This one is *O*(1). let deque: VecDeque<_> = (1..5).collect(); let ptr = deque.as_slices().0.as_ptr(); let vec = Vec::from(deque); assert_eq!(vec, [1, 2, 3, 4]); assert_eq!(vec.as_ptr(), ptr); // This one needs data rearranging. let mut deque: VecDeque<_> = (1..5).collect(); deque.push_front(9); deque.push_front(8); let ptr = deque.as_slices().1.as_ptr(); let vec = Vec::from(deque); assert_eq!(vec, [8, 9, 1, 2, 3, 4]); assert_eq!(vec.as_ptr(), ptr);
impl<A> FromIterator<A> for VecDeque<A>[src]
fn from_iter<T>(iter: T) -> VecDeque<A> where
T: IntoIterator<Item = A>, [src]
impl<A> Hash for VecDeque<A> where
A: Hash, [src]
fn hash<H>(&self, state: &mut H) where
H: Hasher, [src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, [src]1.3.0
impl<A> Index<usize> for VecDeque<A>[src]
type Output = AThe returned type after indexing.
fn index(&self, index: usize) -> &AⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<A> IndexMut<usize> for VecDeque<A>[src]
fn index_mut(&mut self, index: usize) -> &mut AⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> IntoIterator for VecDeque<T>[src]
type Item = TThe type of the elements being iterated over.
type IntoIter = IntoIter<T>Which kind of iterator are we turning this into?
fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<T>
impl<T> Iterator for IntoIter<T>
type Item = T;
[src]
Consumes the VecDeque into a front-to-back iterator yielding elements by value.
impl<'a, T> IntoIterator for &'a VecDeque<T>[src]
type Item = &'a TThe 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) -> Iter<'a, T>ⓘNotable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>
type Item = &'a T;
[src]
impl<'a, T> IntoIterator for &'a mut VecDeque<T>[src]
type Item = &'a mut TThe type of the elements being iterated over.
type IntoIter = IterMut<'a, T>Which kind of iterator are we turning this into?
fn into_iter(self) -> IterMut<'a, T>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>
type Item = &'a mut T;
[src]
impl<A> Ord for VecDeque<A> where
A: Ord, [src]
fn cmp(&self, other: &VecDeque<A>) -> Ordering[src]
fn max(self, other: Self) -> Self[src]1.21.0
fn min(self, other: Self) -> Self[src]1.21.0
fn clamp(self, min: Self, max: Self) -> Self[src]
impl<'_, A, B, const N: usize> PartialEq<&'_ [B; N]> for VecDeque<A> where
A: PartialEq<B>, [src]1.17.0
impl<'_, A, B> PartialEq<&'_ [B]> for VecDeque<A> where
A: PartialEq<B>, [src]1.17.0
impl<'_, A, B, const N: usize> PartialEq<&'_ mut [B; N]> for VecDeque<A> where
A: PartialEq<B>, [src]1.17.0
impl<'_, A, B> PartialEq<&'_ mut [B]> for VecDeque<A> where
A: PartialEq<B>, [src]1.17.0
impl<A, B, const N: usize> PartialEq<[B; N]> for VecDeque<A> where
A: PartialEq<B>, [src]1.17.0
impl<A, B> PartialEq<Vec<B>> for VecDeque<A> where
A: PartialEq<B>, [src]1.17.0
impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
A: PartialEq<A>, [src]
impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
A: PartialOrd<A>, [src]
impl<T> RefUnwindSafe for VecDeque<T> where
T: RefUnwindSafe, impl<T> Send for VecDeque<T> where
T: Send, impl<T> Sync for VecDeque<T> where
T: Sync, impl<T> Unpin for VecDeque<T> where
T: Unpin, impl<T> UnwindSafe for VecDeque<T> where
T: UnwindSafe, impl<T> Any for T where
T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
T: ?Sized, [src]
fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
impl<I> IntoIterator for I where
I: Iterator, [src]
type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
type IntoIter = IWhich kind of iterator are we turning this into?
fn into_iter(self) -> I[src]
impl<T> ToOwned for T where
T: Clone, [src]
type Owned = TThe resulting type after obtaining ownership.
fn to_owned(&self) -> T[src]
fn clone_into(&self, target: &mut T)[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
type Error = InfallibleThe type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/collections/struct.VecDeque.html