Struct oxc_index::IndexVec

pub struct IndexVec<I: Idx, T> {
    pub raw: Vec<T>,
    /* private fields */
}

A Vec that only accepts indices of a specific type.

This is a thin wrapper around Vec, to the point where the backing vec is a public property (called raw). This is in part because I know this API is not a complete mirror of Vec’s (patches welcome). In the worst case, you can always do what you need to the Vec itself.

Note that this implements Deref/DerefMut to IndexSlice, and so all the methods on IndexSlice are available as well. See it’s documentation for some further information.

The following extensions to the Vec APIs are added (in addition to the ones mentioned in IndexSlice’s documentation):

• IndexVec::next_idx, IndexSlice::last_idx give the next and most recent index returned by push.
• IndexVec::push returns the index the item was inserted at.

Fields

raw: Vec<T>

Our wrapped Vec.

Implementations

impl<I: Idx, T> IndexVec<I, T>

pub fn new() -> Self

Construct a new IndexVec.

pub fn from_vec(vec: Vec<T>) -> Self

Construct a IndexVec from a Vec<T>.

Panics if it’s length is too large for our index type.

pub fn with_capacity(capacity: usize) -> Self

Construct an IndexVec that can hold at least capacity items before reallocating. See Vec::with_capacity.

pub fn into_iter_enumerated( self, ) -> Map<Enumerate<IntoIter<T>>, fn(_: (usize, T)) -> (I, T)>

Similar to self.into_iter().enumerate() but with indices of I and not usize.

pub fn splice<R, It>( &mut self, range: R, replace_with: It, ) -> Splice<'_, <It as IntoIterator>::IntoIter>

where It: IntoIterator<Item = T>, R: IdxRangeBounds<I>,

Creates a splicing iterator that replaces the specified range in the vector with the given replace_with iterator and yields the removed items. See Vec::splice

pub fn drain_enumerated<R: IdxRangeBounds<I>>( &mut self, range: R, ) -> Map<Enumerate<Drain<'_, T>>, fn(_: (usize, T)) -> (I, T)>

Similar to self.drain(r).enumerate() but with indices of I and not usize.

pub fn next_idx(&self) -> I

Gives the next index that will be assigned when push is called.

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

Get a the storage as a &[T]

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

Get a the storage as a &mut [T]

pub fn as_vec(&self) -> &Vec<T>

Equivalent to accessing our raw field, but as a function.

pub fn as_mut_vec(&mut self) -> &mut Vec<T>

Equivalent to accessing our raw field mutably, but as a function, if that’s what you’d prefer.

pub fn push(&mut self, d: T) -> I

Push a new item onto the vector, and return it’s index.

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

Pops the last item off, returning it. See Vec::pop.

pub fn into_boxed_slice(self) -> Box<IndexSlice<I, [T]>>

Converts the vector into an owned IndexSlice, dropping excess capacity.

pub fn drain<R: IdxRangeBounds<I>>(&mut self, range: R) -> Drain<'_, T>

Return an iterator that removes the items from the requested range. See Vec::drain.

See also IndexVec::drain_enumerated, which gives you indices (of the correct type) as you iterate.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the vector as much as possible.

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the vector with a lower bound.

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

Shortens the vector, keeping the first len elements and dropping the rest. See Vec::truncate

pub fn clear(&mut self)

Clear our vector. See Vec::clear.

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

Reserve capacity for c more elements. See Vec::reserve

pub fn get<J: IdxSliceIndex<I, T>>(&self, index: J) -> Option<&J::Output>

Get a ref to the item at the provided index, or None for out of bounds.

pub fn get_mut<J: IdxSliceIndex<I, T>>( &mut self, index: J, ) -> Option<&mut J::Output>

Get a mut ref to the item at the provided index, or None for out of bounds

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

where T: Clone,

Resize ourselves in-place to new_len. See Vec::resize.

pub fn resize_with<F: FnMut() -> T>(&mut self, new_len: usize, f: F)

Resize ourselves in-place to new_len. See Vec::resize_with.

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

Moves all the elements of other into Self, leaving other empty. See Vec::append.

pub fn split_off(&mut self, idx: I) -> Self

Splits the collection into two at the given index. See Vec::split_off.

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

Remove the item at index. See Vec::remove.

pub fn swap_remove(&mut self, index: I) -> T

Remove the item at index without maintaining order. See Vec::swap_remove.

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

Insert an item at index. See Vec::insert.

pub fn extend_from_slice(&mut self, other: &IndexSlice<I, [T]>)

where T: Clone,

Append all items in the slice to the end of our vector.

See Vec::extend_from_slice.

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

Forwards to the Vec::retain implementation.

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

Forwards to the Vec::dedup_by_key implementation.

pub fn dedup(&mut self)

where T: PartialEq,

Forwards to the Vec::dedup implementation.

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

Forwards to the Vec::dedup_by implementation.

pub fn as_slice(&self) -> &IndexSlice<I, [T]>

Get a IndexSlice over this vector. See as_raw_slice for converting to a &[T] (or access self.raw).

pub fn as_mut_slice(&mut self) -> &mut IndexSlice<I, [T]>

Get a mutable IndexSlice over this vector. See as_raw_slice_mut for converting to a &mut [T] (or access self.raw).

Methods from Deref<Target = IndexSlice<I, [A]>>

pub fn to_vec(&self) -> IndexVec<I, T>

where T: Clone,

Copies self into a new IndexVec.

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

Returns the underlying slice.

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

Returns the underlying slice.

pub fn as_mut_ptr(&mut self) -> *mut T

Returns an unsafe mutable pointer to the slice’s buffer.

pub fn as_ptr(&self) -> *const T

Returns an unsafe pointer to the slice’s buffer.

Panics

pub fn last_idx(&self) -> I

Return the index of the last element, or panic.

Panics

pub fn len(&self) -> usize

Returns the length of our slice.

pub fn len_idx(&self) -> I

Returns the length of our slice as an I.

pub fn is_empty(&self) -> bool

Returns true if we’re empty.

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

Get a iterator over reverences to our values.

See also IndexSlice::iter_enumerated, which gives you indices (of the correct type) as you iterate.

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

Get a iterator over mut reverences to our values.

See also IndexSlice::iter_mut_enumerated, which gives you indices (of the correct type) as you iterate.

pub fn iter_enumerated( &self, ) -> Map<Enumerate<Iter<'_, T>>, fn(_: (usize, &T)) -> (I, &T)>

Similar to self.iter().enumerate() but with indices of I and not usize.

pub fn indices(&self) -> Map<Range<usize>, fn(_: usize) -> I>

Get an iterator over all our indices.

pub fn iter_mut_enumerated( &mut self, ) -> Map<Enumerate<IterMut<'_, T>>, fn(_: (usize, &mut T)) -> (I, &mut T)>

Similar to self.iter_mut().enumerate() but with indices of I and not usize.

pub fn sort(&mut self)

where T: Ord,

Forwards to the slice’s sort implementation.

pub fn sort_by<F: FnMut(&T, &T) -> Ordering>(&mut self, compare: F)

Forwards to the slice’s sort_by implementation.

pub fn sort_by_key<F: FnMut(&T) -> K, K: Ord>(&mut self, f: F)

Forwards to the slice’s sort_by_key implementation.

pub fn sort_by_cached_key<F: FnMut(&T) -> K, K: Ord>(&mut self, f: F)

Forwards to the slice’s sort_by_cached_key implementation.

pub fn sort_unstable(&mut self)

where T: Ord,

Forwards to the slice’s sort_unstable implementation.

pub fn sort_unstable_by<F: FnMut(&T, &T) -> Ordering>(&mut self, compare: F)

Forwards to the slice’s sort_unstable_by implementation.

pub fn sort_unstable_by_key<F: FnMut(&T) -> K, K: Ord>(&mut self, f: F)

Forwards to the slice’s sort_unstable_by_key implementation.

pub fn ends_with<S: AsRef<[T]> + ?Sized>(&self, needle: &S) -> bool

where T: PartialEq,

Forwards to the slice’s ends_with implementation.

pub fn starts_with<S: AsRef<[T]> + ?Sized>(&self, needle: &S) -> bool

where T: PartialEq,

Forwards to the slice’s starts_with implementation.

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

where T: PartialEq,

Forwards to the slice’s contains implementation.

pub fn reverse(&mut self)

Forwards to the slice’s reverse implementation.

pub fn binary_search(&self, value: &T) -> Result<I, I>

where T: Ord,

Call slice::binary_search converting the indices it gives us back as needed.

Errors

pub fn binary_search_by<'a, F: FnMut(&'a T) -> Ordering>( &'a self, f: F, ) -> Result<I, I>

Binary searches this sorted vec with a comparator function, converting the indices it gives us back to our Idx type.

Errors

pub fn copy_from_slice(&mut self, src: &Self)

where T: Copy,

Copies all elements from src into self, using a memcpy.

pub fn clone_from_slice(&mut self, src: &Self)

where T: Clone,

Copies the elements from src into self.

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

Swaps all elements in self with those in other.

pub fn binary_search_by_key<'a, B: Ord, F: FnMut(&'a T) -> B>( &'a self, b: &B, f: F, ) -> Result<I, I>

Binary searches this sorted vec with a key extraction function, converting the indices it gives us back to our Idx type.

Errors

pub fn position<F: FnMut(&T) -> bool>(&self, f: F) -> Option<I>

Searches for an element in an iterator, returning its index. This is equivalent to Iterator::position, but returns I and not usize.

pub fn rposition<F: FnMut(&T) -> bool>(&self, f: F) -> Option<I>

Searches for an element in an iterator from the right, returning its index. This is equivalent to Iterator::position, but returns I and not usize.

pub fn swap(&mut self, a: I, b: I)

Swaps two elements in our vector.

pub fn split_at(&self, a: I) -> (&Self, &Self)

Divides our slice into two at an index.

pub fn split_at_mut(&mut self, a: I) -> (&mut Self, &mut Self)

Divides our slice into two at an index.

pub fn rotate_left(&mut self, mid: I)

Rotates our data in-place such that the first mid elements of the slice move to the end while the last self.len() - mid elements move to the front

pub fn rotate_right(&mut self, k: I)

Rotates our data in-place such that the first self.len() - k elements of the slice move to the end while the last k elements move to the front

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

Return the the last element, if we are not empty.

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

Return the the last element, if we are not empty.

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

Return the the first element, if we are not empty.

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

Return the the first element, if we are not empty.

pub fn copy_within<R: IdxRangeBounds<I>>(&mut self, src: R, dst: I)

where T: Copy,

Copies elements from one part of the slice to another part of itself, using a memmove.

pub fn get<J: IdxSliceIndex<I, T>>(&self, index: J) -> Option<&J::Output>

Get a ref to the item at the provided index, or None for out of bounds.

pub fn get_mut<J: IdxSliceIndex<I, T>>( &mut self, index: J, ) -> Option<&mut J::Output>

Get a mut ref to the item at the provided index, or None for out of bounds

pub fn windows( &self, size: usize, ) -> Map<Windows<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s windows iterator with one that yields IndexSlices with the correct index type.

pub fn chunks( &self, size: usize, ) -> Map<Chunks<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s chunks iterator with one that yields IndexSlices with the correct index type.

pub fn chunks_mut( &mut self, size: usize, ) -> Map<ChunksMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s chunks_mut iterator with one that yields IndexSlices with the correct index type.

pub fn chunks_exact( &self, chunk_size: usize, ) -> Map<ChunksExact<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s chunks_exact iterator with one that yields IndexSlices with the correct index type.

pub fn chunks_exact_mut( &mut self, chunk_size: usize, ) -> Map<ChunksExactMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s chunks_exact_mut iterator with one that yields IndexSlices with the correct index type.

pub fn rchunks( &self, size: usize, ) -> Map<RChunks<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s rchunks iterator with one that yields IndexSlices with the correct index type.

pub fn rchunks_mut( &mut self, size: usize, ) -> Map<RChunksMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s rchunks_mut iterator with one that yields IndexSlices with the correct index type.

pub fn rchunks_exact( &self, chunk_size: usize, ) -> Map<RChunksExact<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s rchunks_exact iterator with one that yields IndexSlices with the correct index type.

pub fn rchunks_exact_mut( &mut self, chunk_size: usize, ) -> Map<RChunksExactMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s rchunks_exact_mut iterator with one that yields IndexSlices with the correct index type.

pub fn split<F: FnMut(&T) -> bool>( &self, f: F, ) -> Map<Split<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s split iterator with one that yields IndexSlices with the correct index type.

pub fn split_mut<F: FnMut(&T) -> bool>( &mut self, f: F, ) -> Map<SplitMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s split_mut iterator with one that yields IndexSlices with the correct index type.

pub fn rsplit<F: FnMut(&T) -> bool>( &self, f: F, ) -> Map<RSplit<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s rsplit iterator with one that yields IndexSlices with the correct index type.

pub fn rsplit_mut<F: FnMut(&T) -> bool>( &mut self, f: F, ) -> Map<RSplitMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s rsplit_mut iterator with one that yields IndexSlices with the correct index type.

pub fn splitn<F: FnMut(&T) -> bool>( &self, n: usize, f: F, ) -> Map<SplitN<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s splitn iterator with one that yields IndexSlices with the correct index type.

pub fn splitn_mut<F: FnMut(&T) -> bool>( &mut self, n: usize, f: F, ) -> Map<SplitNMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s splitn_mut iterator with one that yields IndexSlices with the correct index type.

pub fn rsplitn<F: FnMut(&T) -> bool>( &self, n: usize, f: F, ) -> Map<RSplitN<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>>

Wraps the underlying slice’s rsplitn iterator with one that yields IndexSlices with the correct index type.

pub fn rsplitn_mut<F: FnMut(&T) -> bool>( &mut self, n: usize, f: F, ) -> Map<RSplitNMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>>

Wraps the underlying slice’s rsplitn_mut iterator with one that yields IndexSlices with the correct index type.

pub fn split_first(&self) -> Option<(&T, &IndexSlice<I, [T]>)>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut IndexSlice<I, [T]>)>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

pub fn split_last(&self) -> Option<(&T, &IndexSlice<I, [T]>)>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut IndexSlice<I, [T]>)>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

Trait Implementations

impl<I: Idx, A> AsMut<[A]> for IndexVec<I, A>

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<I: Idx, A> AsMut<IndexSlice<I, [A]>> for IndexVec<I, A>

fn as_mut(&mut self) -> &mut IndexSlice<I, [A]>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<I: Idx, A> AsRef<[A]> for IndexVec<I, A>

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<I: Idx, A> AsRef<IndexSlice<I, [A]>> for IndexVec<I, A>

fn as_ref(&self) -> &IndexSlice<I, [A]>

Converts this type into a shared reference of the (usually inferred) input type.

impl<I: Idx, T> Borrow<IndexSlice<I, [T]>> for IndexVec<I, T>

fn borrow(&self) -> &IndexSlice<I, [T]>

Immutably borrows from an owned value.

impl<I: Idx, T> BorrowMut<IndexSlice<I, [T]>> for IndexVec<I, T>

fn borrow_mut(&mut self) -> &mut IndexSlice<I, [T]>

Mutably borrows from an owned value.

impl<I: Idx, T: Clone> Clone for IndexVec<I, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Idx, T: Debug> Debug for IndexVec<I, T>

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

Formats the value using the given formatter.

impl<I: Idx, T> Default for IndexVec<I, T>

fn default() -> Self

Returns the “default value” for a type.

impl<I: Idx, A> Deref for IndexVec<I, A>

type Target = IndexSlice<I, [A]>

The resulting type after dereferencing.

fn deref(&self) -> &IndexSlice<I, [A]>

Dereferences the value.

impl<I: Idx, A> DerefMut for IndexVec<I, A>

fn deref_mut(&mut self) -> &mut IndexSlice<I, [A]>

Mutably dereferences the value.

impl<'a, I: Idx, T: 'a + Copy> Extend<&'a T> for IndexVec<I, T>

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<I: Idx, T> Extend<T> for IndexVec<I, T>

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, I: Idx, T: Clone> From<&'a IndexSlice<I, [T]>> for IndexVec<I, T>

fn from(src: &'a IndexSlice<I, [T]>) -> Self

Converts to this type from the input type.

impl<'a, I: Idx, T: Clone> From<&'a mut IndexSlice<I, [T]>> for IndexVec<I, T>

fn from(src: &'a mut IndexSlice<I, [T]>) -> Self

Converts to this type from the input type.

impl<I: Idx, T> From<Box<IndexSlice<I, [T]>>> for IndexVec<I, T>

fn from(src: Box<IndexSlice<I, [T]>>) -> Self

Converts to this type from the input type.

impl<'a, I: Idx, T> From<Cow<'a, IndexSlice<I, [T]>>> for IndexVec<I, T>

where IndexSlice<I, [T]>: ToOwned<Owned = IndexVec<I, T>>,

fn from(s: Cow<'a, IndexSlice<I, [T]>>) -> IndexVec<I, T>

Converts to this type from the input type.

impl<I: Idx, T> From<IndexVec<I, T>> for Box<IndexSlice<I, [T]>>

fn from(src: IndexVec<I, T>) -> Self

Converts to this type from the input type.

impl<I: Idx, T> From<Vec<T>> for IndexVec<I, T>

fn from(v: Vec<T>) -> Self

Converts to this type from the input type.

impl<I: Idx, T> FromIterator<T> for IndexVec<I, T>

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

where J: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<I: Hash + Idx, T: Hash> Hash for IndexVec<I, 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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, I: Idx, T> IntoIterator for &'a IndexVec<I, T>

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a T

The type of the elements being iterated over.

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

Creates an iterator from a value.

impl<'a, I: Idx, T> IntoIterator for &'a mut IndexVec<I, T>

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a mut T

The type of the elements being iterated over.

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

Creates an iterator from a value.

impl<I: Idx, T> IntoIterator for IndexVec<I, T>

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

type Item = T

The type of the elements being iterated over.

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<I: Ord + Idx, T: Ord> Ord for IndexVec<I, T>

fn cmp(&self, other: &IndexVec<I, T>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 0]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 1]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 10]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 11]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 12]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 13]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 14]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 15]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 16]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 17]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 18]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 19]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 2]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 20]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 21]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 22]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 23]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 24]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 25]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 26]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 27]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 28]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 29]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 3]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 30]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 31]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 32]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 4]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 5]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 6]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 7]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 8]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b [B; 9]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx, J: Idx> PartialEq<&'b IndexSlice<J, [B]>> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

fn ne(&self, other: &&'b IndexSlice<J, [B]>) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<&'b mut [B]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx, J: Idx> PartialEq<&'b mut IndexSlice<J, [B]>> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

fn ne(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 0]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 1]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 10]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 11]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 12]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 13]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 14]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 15]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 16]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 17]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 18]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 19]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 2]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 20]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 21]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 22]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 23]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 24]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 25]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 26]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 27]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 28]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 29]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 3]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 30]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 31]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 32]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 4]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 5]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 6]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 7]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 8]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<[B; 9]> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx, J: Idx> PartialEq<IndexVec<J, B>> for &'a IndexSlice<I, [A]>

where A: PartialEq<B>,

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

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

fn ne(&self, other: &IndexVec<J, B>) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx, J: Idx> PartialEq<IndexVec<J, B>> for &'a mut IndexSlice<I, [A]>

where A: PartialEq<B>,

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

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

fn ne(&self, other: &IndexVec<J, B>) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, A, B, I: Idx> PartialEq<Vec<B>> for IndexVec<I, A>

where A: PartialEq<B>,

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

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: PartialEq + Idx, T: PartialEq> PartialEq for IndexVec<I, T>

fn eq(&self, other: &IndexVec<I, T>) -> bool

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: PartialOrd + Idx, T: PartialOrd> PartialOrd for IndexVec<I, T>

fn partial_cmp(&self, other: &IndexVec<I, T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<I: Eq + Idx, T: Eq> Eq for IndexVec<I, T>

impl<I: Idx, T> Send for IndexVec<I, T>

where T: Send,

impl<I: Idx, T> StructuralPartialEq for IndexVec<I, T>