Struct slice_deque::SliceDeque

pub struct SliceDeque<T> { /* fields omitted */ }

A double-ended queue that derefs into a slice.

It is implemented with a growable virtual ring buffer.

Methods

impl<T> SliceDeque<T>

pub fn new() -> Self

Creates a new empty deque.

Examples

let deq = SliceDeque::new();

pub unsafe fn from_raw_parts(
    ptr: *mut T,
    capacity: usize,
    elems: &mut [T]
) -> Self

Creates a SliceDeque from its raw components.

The ptr must be a pointer to the beginning of the memory buffer from another SliceDeque, capacity the capacity of this SliceDeque, and elems the elements of this SliceDeque.

pub fn with_capacity(n: usize) -> Self

Create an empty deque with capacity to hold n elements.

Examples

let deq = SliceDeque::with_capacity(10);

pub fn capacity(&self) -> usize

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

Examples

let deq = SliceDeque::with_capacity(10);
assert!(deq.capacity() >= 10);

pub fn len(&self) -> usize

Number of elements in the ring buffer.

Examples

let mut deq = SliceDeque::with_capacity(10);
assert!(deq.len() == 0);
deq.push_back(3);
assert!(deq.len() == 1);

pub fn is_full(&self) -> bool

Is the ring buffer full ?

Examples

let mut deq = SliceDeque::with_capacity(10);
assert!(!deq.is_full());

pub fn as_slice(&self) -> &[T]

Extracts a slice containing the entire deque.

pub fn as_mut_slice(&mut self) -> &mut [T]

Extracts a mutable slice containing the entire deque.

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

Returns a pair of slices, where the first slice contains the contents of the deque and the second one is empty.

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

Returns a pair of slices, where the first slice contains the contents of the deque and the second one is empty.

pub unsafe fn tail_head_slice(&mut self) -> &mut [T]

Returns the slice of uninitialized memory between the tail and the begin.

Examples

let mut d = sdeq![1, 2, 3];
let cap = d.capacity();
let len = d.len();
unsafe {
    {
        // This slice contains the uninitialized elements in
        // the deque:
        let mut s = d.tail_head_slice();
        assert_eq!(s.len(), cap - len);
        // We can write to them and for example bump the tail of
        // the deque:
        s[0] = 4;
        s[1] = 5;
    }
    d.move_tail(2);
}
assert_eq!(d, sdeq![1, 2, 3, 4, 5]);

pub fn try_reserve(&mut self, additional: usize) -> Result<(), AllocError>

Attempts to reserve capacity for inserting at least additional elements without reallocating. Does nothing if the capacity is already sufficient.

The collection always reserves memory in multiples of the page size.

Panics

Panics if the new capacity overflows usize.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for inserting at least additional elements without reallocating. Does nothing if the capacity is already sufficient.

The collection always reserves memory in multiples of the page size.

Panics

Panics if the new capacity overflows usize or on OOM.

pub fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for exactly additional more elements to be inserted in the given SliceDeq<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.

Panics

Panics if the new capacity overflows usize.

Examples

let mut deq = sdeq![1];
deq.reserve_exact(10);
assert!(deq.capacity() >= 11);

pub unsafe fn move_head_unchecked(&mut self, x: isize)

Moves the deque head by x.

Panics

If the head wraps over the tail the behavior is undefined, that is, if x is out-of-range [-(capacity() - len()), len()].

If -C debug-assertions=1 violating this pre-condition panic!s.

Unsafe

It does not drop nor initialize elements, it just moves where the tail of the deque points to within the allocated buffer.

pub unsafe fn move_head(&mut self, x: isize)

Moves the deque head by x.

Panics

If the head wraps over the tail, that is, if x is out-of-range [-(capacity() - len()), len()].

Unsafe

It does not drop nor initialize elements, it just moves where the tail of the deque points to within the allocated buffer.

pub unsafe fn move_tail_unchecked(&mut self, x: isize)

Moves the deque tail by x.

Panics

If the tail wraps over the head the behavior is undefined, that is, if x is out-of-range [-len(), capacity() - len()].

If -C debug-assertions=1 violating this pre-condition panic!s.

Unsafe

It does not drop nor initialize elements, it just moves where the tail of the deque points to within the allocated buffer.

pub unsafe fn move_tail(&mut self, x: isize)

Moves the deque tail by x.

Panics

If the tail wraps over the head, that is, if x is out-of-range [-len(), capacity() - len()].

Unsafe

It does not drop nor initialize elements, it just moves where the tail of the deque points to within the allocated buffer.

pub unsafe fn steal_from_slice(s: &[T]) -> Self

Steal the elements from the slice s. You should mem::forget the slice afterwards.

pub fn append(&mut self, other: &mut Self)

Moves all the elements of other into Self, leaving other empty.

Panics

Panics if the number of elements in the deque overflows a isize.

Examples

let mut deq = sdeq![1, 2, 3];
let mut deq2 = sdeq![4, 5, 6];
deq.append(&mut deq2);
assert_eq!(deq, [1, 2, 3, 4, 5, 6]);
assert_eq!(deq2, []);

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

Provides a reference to the first element, or None if the deque is empty.

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.front(), None);

deq.push_back(1);
deq.push_back(2);
assert_eq!(deq.front(), Some(&1));
deq.push_front(3);
assert_eq!(deq.front(), Some(&3));

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

Provides a mutable reference to the first element, or None if the deque is empty.

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.front(), None);

deq.push_back(1);
deq.push_back(2);
assert_eq!(deq.front(), Some(&1));
(*deq.front_mut().unwrap()) = 3;
assert_eq!(deq.front(), Some(&3));

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

Provides a reference to the last element, or None if the deque is empty.

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.back(), None);

deq.push_back(1);
deq.push_back(2);
assert_eq!(deq.back(), Some(&2));
deq.push_front(3);
assert_eq!(deq.back(), Some(&2));

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

Provides a mutable reference to the last element, or None if the deque is empty.

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.front(), None);

deq.push_back(1);
deq.push_back(2);
assert_eq!(deq.back(), Some(&2));
(*deq.back_mut().unwrap()) = 3;
assert_eq!(deq.back(), Some(&3));

pub fn try_push_front(&mut self, value: T) -> Result<(), (T, AllocError)>

Attempts to prepend value to the deque.

Examples

let mut deq = SliceDeque::new();
deq.try_push_front(1).unwrap();
deq.try_push_front(2).unwrap();
assert_eq!(deq.front(), Some(&2));

pub fn push_front(&mut self, value: T)

Prepends value to the deque.

Panics

On OOM.

Examples

let mut deq = SliceDeque::new();
deq.push_front(1);
deq.push_front(2);
assert_eq!(deq.front(), Some(&2));

pub fn try_push_back(&mut self, value: T) -> Result<(), (T, AllocError)>

Attempts to appends value to the deque.

Examples

let mut deq = SliceDeque::new();
deq.try_push_back(1).unwrap();
deq.try_push_back(3).unwrap();
assert_eq!(deq.back(), Some(&3));

pub fn push_back(&mut self, value: T)

Appends value to the deque.

Panics

On OOM.

Examples

let mut deq = SliceDeque::new();
deq.push_back(1);
deq.push_back(3);
assert_eq!(deq.back(), Some(&3));

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

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

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.pop_front(), None);

deq.push_back(1);
deq.push_back(2);

assert_eq!(deq.pop_front(), Some(1));
assert_eq!(deq.pop_front(), Some(2));
assert_eq!(deq.pop_front(), None);

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

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

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.pop_back(), None);

deq.push_back(1);
deq.push_back(3);

assert_eq!(deq.pop_back(), Some(3));
assert_eq!(deq.pop_back(), Some(1));
assert_eq!(deq.pop_back(), None);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the deque as much as possible.

It will drop down as close as possible to the length, but because SliceDeque allocates memory in multiples of the page size the deque might still have capacity for inserting new elements without reallocating.

Examples

let mut deq = SliceDeque::with_capacity(15);
deq.extend(0..4);
assert!(deq.capacity() >= 15);
deq.shrink_to_fit();
assert!(deq.capacity() >= 4);

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

Shortens the deque by removing excess elements from the back.

If len is greater than the SliceDeque's current length, this has no effect.

Examples

let mut deq = sdeq![5, 10, 15];
assert_eq!(deq, [5, 10, 15]);
deq.truncate_back(1);
assert_eq!(deq, [5]);

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

Shortens the deque by removing excess elements from the back.

If len is greater than the SliceDeque's current length, this has no effect. See truncate_back for examples.

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

Shortens the deque by removing excess elements from the front.

If len is greater than the SliceDeque's current length, this has no effect.

Examples

let mut deq = sdeq![5, 10, 15];
assert_eq!(deq, [5, 10, 15]);
deq.truncate_front(1);
assert_eq!(deq, [15]);

Important traits for Drain<'a, T>

impl<'a, T> Iterator for Drain<'a, T> type Item = T;

pub fn drain<R>(&mut self, range: R) -> Drain<T> where
    R: RangeBounds<usize>, 

Creates a draining iterator that removes the specified range in the deque and yields the removed items.

Note 1: The element range is removed even if the iterator is only partially consumed or not consumed at all.

Note 2: It is unspecified how many elements are removed from the deque if the Drain value is leaked.

Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the deque.

Examples

let mut deq = sdeq![1, 2, 3];
let u: Vec<_> = deq.drain(1..).collect();
assert_eq!(deq, &[1]);
assert_eq!(u, &[2, 3]);

// A full range clears the deque
deq.drain(..);
assert_eq!(deq, &[]);

pub fn clear(&mut self)

Removes all values from the deque.

Examples

let mut deq = sdeq![1];
assert!(!deq.is_empty());
deq.clear();
assert!(deq.is_empty());

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

Removes the element at index and return it in O(1) by swapping the last element into its place.

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.swap_remove_back(0), None);
deq.extend(1..4);
assert_eq!(deq, [1, 2, 3]);

assert_eq!(deq.swap_remove_back(0), Some(1));
assert_eq!(deq, [3, 2]);

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

Removes the element at index and returns it in O(1) by swapping the first element into its place.

Examples

let mut deq = SliceDeque::new();
assert_eq!(deq.swap_remove_front(0), None);
deq.extend(1..4);
assert_eq!(deq, [1, 2, 3]);

assert_eq!(deq.swap_remove_front(2), Some(3));
assert_eq!(deq, [2, 1]);

pub fn insert(&mut self, index: usize, element: T)

Inserts an element at index within the deque, 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 deque's length

Examples

let mut deq = sdeq!['a', 'b', 'c'];
assert_eq!(deq, &['a', 'b', 'c']);

deq.insert(1, 'd');
assert_eq!(deq, &['a', 'd', 'b', 'c']);

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

Removes and returns the element at position index within the deque.

Panics

Panics if index is out of bounds.

Examples

let mut deq = sdeq![1, 2, 3, 4, 5];
assert_eq!(deq.remove(1), 2);
assert_eq!(deq, [1, 3, 4, 5]);

pub fn split_off(&mut self, at: usize) -> Self

Splits the collection into two at the given index.

Returns a newly allocated Self. self contains elements [0, at), and the returned Self contains elements [at, len).

Note that the capacity of self does not change.

Panics

Panics if at > len.

Examples

let mut deq = sdeq![1, 2, 3];
let deq2 = deq.split_off(1);
assert_eq!(deq, [1]);
assert_eq!(deq2, [2, 3]);

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(&T) -> bool, 

Retains only the elements specified by the predicate.

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

Examples

let mut deq = sdeq![1, 2, 3, 4];
deq.retain(|&x| x % 2 == 0);
assert_eq!(deq, [2, 4]);

pub fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut T) -> K,
    K: PartialEq, 

Removes all but the first of consecutive elements in the deque that resolve to the same key.

If the deque is sorted, this removes all duplicates.

Examples

let mut deq = sdeq![10, 20, 21, 30, 20];

deq.dedup_by_key(|i| *i / 10);
assert_eq!(deq, [10, 20, 30, 20]);

pub fn dedup_by<F>(&mut self, same_bucket: F) where
    F: FnMut(&mut T, &mut T) -> bool, 

Removes all but the first of consecutive elements in the deque satisfying a given equality relation.

The same_bucket function is passed references to two elements from the deque, and returns true if the elements compare equal, or false if they do not. The elements are passed in opposite order from their order in the deque, so if same_bucket(a, b) returns true, a is removed.

If the deque is sorted, this removes all duplicates.

Examples

let mut deq = sdeq!["foo", "bar", "Bar", "baz", "bar"];

deq.dedup_by(|a, b| a.eq_ignore_ascii_case(b));

assert_eq!(deq, ["foo", "bar", "baz", "bar"]);

Important traits for Splice<'a, I>

impl<'a, I: Iterator> Iterator for Splice<'a, I> type Item = I::Item;

pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<I::IntoIter> where
    R: RangeBounds<usize>,
    I: IntoIterator<Item = T>, 

Creates a splicing iterator that replaces the specified range in the deque with the given replace_with iterator and yields the removed items. replace_with does not need to be the same length as range.

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 Splice value is leaked.

Note 3: The input iterator replace_with is only consumed when the Splice value is dropped.

Note 4: This is optimal if:

• The tail (elements in the deque after range) is empty,
• or replace_with yields fewer elements than range’s length
• or the lower bound of its size_hint() is exact.

Otherwise, a temporary deque is allocated and the tail is moved twice.

Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the deque.

Examples

let mut deq = sdeq![1, 2, 3];
let new = [7, 8];
let u: SliceDeque<_> = deq.splice(..2, new.iter().cloned()).collect();
assert_eq!(deq, &[7, 8, 3]);
assert_eq!(u, &[1, 2]);

Important traits for DrainFilter<'a, T, F>

impl<'a, T, F> Iterator for DrainFilter<'a, T, F> where
    F: FnMut(&mut T) -> bool,  type Item = T;

pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F> where
    F: FnMut(&mut T) -> bool, 

Creates an iterator which uses a closure to determine if an element should be removed.

If the closure returns true, then the element is removed and yielded. If the closure returns false, it will try again, and call the closure on the next element, seeing if it passes the test.

Using this method is equivalent to the following code:

let mut deq = SliceDeque::new();
deq.extend(1..7);
let mut i = 0;
while i != deq.len() {
    if some_predicate(&mut deq[i]) {
        let val = deq.remove(i);
    // your code here
    } else {
        i += 1;
    }
}

But drain_filter is easier to use. drain_filter is also more efficient, because it can backshift the elements of the deque in bulk.

Note that drain_filter also lets you mutate every element in the filter closure, regardless of whether you choose to keep or remove it.

Examples

Splitting a deque into evens and odds, reusing the original allocation:

let mut numbers = sdeq![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];

let evens = numbers
    .drain_filter(|x| *x % 2 == 0)
    .collect::<SliceDeque<_>>();
let odds = numbers;

assert_eq!(sdeq![2, 4, 6, 8, 14], evens);
assert_eq!(odds, sdeq![1, 3, 5, 9, 11, 13, 15]);

impl<T> SliceDeque<T> where
    T: Clone, 

pub fn extend_from_slice(&mut self, other: &[T])

Clones and appends all elements in a slice to the SliceDeque.

Iterates over the slice other, clones each element, and then appends it to this SliceDeque. The other slice is traversed in-order.

Note that this function is same as extend except that it is specialized to work with slices instead. If and when Rust gets specialization this function will likely be deprecated (but still available).

Examples

let mut deq = SliceDeque::new();
deq.push_back(1);
deq.extend_from_slice(&[2, 3, 4]);
assert_eq!(deq, [1, 2, 3, 4]);

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

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

Examples

let mut deq = sdeq![5, 10, 15];
assert_eq!(deq, [5, 10, 15]);

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

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

impl<T: Default> SliceDeque<T>

pub fn resize_default(&mut self, new_len: usize)

Resizes the SliceDeque in-place so that len is equal to new_len.

If new_len is greater than len, the SliceDeque is extended by the difference, with each additional slot filled with Default::default(). If new_len is less than len, the SliceDeque is simply truncated.

This method uses Default to create new values on every push. If you'd rather Clone a given value, use resize.

Examples

let mut deq = sdeq![1, 2, 3];
deq.resize_default(5);
assert_eq!(deq, [1, 2, 3, 0, 0]);

deq.resize_default(2);
assert_eq!(deq, [1, 2]);

impl<T: PartialEq> SliceDeque<T>

pub fn dedup(&mut self)

Removes consecutive repeated elements in the deque.

If the deque is sorted, this removes all duplicates.

Examples

let mut deq = sdeq![1, 2, 2, 3, 2];

deq.dedup();
assert_eq!(deq, [1, 2, 3, 2]);

deq.sort();
assert_eq!(deq, [1, 2, 2, 3]);

deq.dedup();
assert_eq!(deq, [1, 2, 3]);

pub fn remove_item(&mut self, item: &T) -> Option<T>

Removes the first instance of item from the deque if the item exists.

Examples

let mut deq = sdeq![1, 2, 3, 1];

deq.remove_item(&1);
assert_eq!(deq, &[2, 3, 1]);
deq.remove_item(&1);
assert_eq!(deq, &[2, 3]);

Trait Implementations

impl<T> Send for SliceDeque<T> where
    T: Send, 

impl<T> Sync for SliceDeque<T> where
    T: Sync, 

impl<T> Drop for SliceDeque<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> AsRef<[T]> for SliceDeque<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> AsMut<[T]> for SliceDeque<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<'a, T: Clone> From<&'a [T]> for SliceDeque<T>

fn from(s: &'a [T]) -> Self

Performs the conversion.

impl<'a, T: Clone> From<&'a mut [T]> for SliceDeque<T>

fn from(s: &'a mut [T]) -> Self

Performs the conversion.

impl<T> Extend<T> for SliceDeque<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<'a, T: 'a + Copy> Extend<&'a T> for SliceDeque<T>

Extend implementation that copies elements out of references before pushing them onto the SliceDeque.

This implementation is specialized for slice iterators, where it uses copy_from_slice to append the entire slice at once.

fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<T> IntoIterator for SliceDeque<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>

impl<T> Iterator for IntoIter<T> type Item = T;

fn into_iter(self) -> IntoIter<T>

Creates a consuming iterator, that is, one that moves each value out of the deque (from start to end). The deque cannot be used after calling this.

Examples

let mut deq = sdeq!["a".to_string(), "b".to_string()];
let expected = ["a".to_string(), "b".to_string()];
for (i, s) in deq.into_iter().enumerate() {
    // s has type String, not &String
    println!("{}", s);
    assert_eq!(s, expected[i]);
}

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<T: Clone> Clone for SliceDeque<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Default for SliceDeque<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T: Eq> Eq for SliceDeque<T>

impl<'a, 'b, A: Sized, B> PartialEq<SliceDeque<B>> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b mut [B]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<Vec<B>> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 0]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 0]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 1]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 1]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 2]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 2]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 3]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 3]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 4]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 4]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 5]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 5]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 6]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 6]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 7]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 7]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 8]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 8]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 9]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 9]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 10]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 10]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 11]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 11]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 12]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 12]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 13]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 13]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 14]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 14]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 15]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 15]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 16]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 16]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 17]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 17]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 18]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 18]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 19]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 19]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 20]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 20]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 21]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 21]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 22]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 22]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 23]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 23]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 24]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 24]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 25]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 25]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 26]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 26]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 27]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 27]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 28]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 28]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 29]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 29]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 30]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 30]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 31]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 31]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<[B; 32]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A: Sized, B> PartialEq<&'b [B; 32]> for SliceDeque<A> where
    A: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialOrd> PartialOrd<SliceDeque<T>> for SliceDeque<T>

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

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

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

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

impl<'a, T: PartialOrd> PartialOrd<&'a [T]> for SliceDeque<T>

fn partial_cmp(&self, other: &&'a [T]) -> Option<Ordering>

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

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

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

impl<T: Debug> Debug for SliceDeque<T>

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

Formats the value using the given formatter.

impl<T> Deref for SliceDeque<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for SliceDeque<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Hash> Hash for SliceDeque<T>

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, 

Feeds a slice of this type into the given [Hasher].

impl<T> FromIterator<T> for SliceDeque<T>

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

Creates a value from an iterator.