Struct otter_api_tests::shapelib::IndexSlice[−]

#[repr(transparent)]
pub struct IndexSlice<I, T> where
    T: ?Sized,
    I: Idx,  {
    pub raw: T,
    // some fields omitted
}

Expand description

A slice that only accepts indices of a specific type. Note that the intended usage is as IndexSlice<I, [T]>.

This is a thin wrapper around a [T], to the point where the backing 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 slice itself.

Some notes on the APIs

Most of the Slice APIs are present.
- Any that aren’t can be trivially accessed on the underlying raw field, which is public.
Apis that take or return usizes referring to the positions of items were replaced with ones that take Idx.
Apis that take R: RangeBounds<usize> take an IdxRangeBounds, which is basically a RangeBounds.
Apis that take SliceIndex<usize> take an IdxSliceIndex, which is basically a SliceIndex.
Most iterator functions where the_iter().enumerate() would refer to indices have been given _enumerated variants. E.g. IndexSlice::iter_enumerated, etc. This is because v.iter().enumerate() would be (usize, &T), but you want (I, &T).

The following extensions are added:

IndexSlice::indices: an Iterator over the indices of type I.
Various enumerated iterators mentioned earlier
IndexSlice::position, IndexSlice::rposition as self.iter().position() will return a Option<usize>

Fields

raw: T

Implementations

impl<I, T> IndexSlice<I, [T]> where
    I: Idx,

pub fn new<S>(s: &S) -> &IndexSlice<I, [T]> where
    S: AsRef<[T]> + ?Sized,

Construct a new IdxSlice by wrapping an existing slice.

pub fn new_mut<S>(s: &mut S) -> &mut IndexSlice<I, [T]> where
    S: AsMut<[T]> + ?Sized,

Construct a new mutable IdxSlice by wrapping an existing mutable slice.

pub fn from_slice(s: &[T]) -> &IndexSlice<I, [T]>

Construct a new IdxSlice by wrapping an existing slice.

pub fn from_slice_mut(s: &mut [T]) -> &mut IndexSlice<I, [T]>

Construct a new mutable IdxSlice by wrapping an existing mutable slice.

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

Copies self into a new IndexVec.

pub fn into_vec(self: Box<IndexSlice<I, [T]>, Global>) -> IndexVec<I, T>

Converts self into a vector without clones or allocation.

The resulting vector can be converted back into a box via IndexVec<I, T>’s into_boxed_slice method.

pub fn as_raw_slice_mut(&mut self) -> &mut [T]ⓘNotable traits for &'_ [u8]
impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

Returns the underlying slice.

pub fn as_raw_slice(&self) -> &[T]ⓘNotable traits for &'_ [u8]
impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

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.

pub fn last_idx(&self) -> I

Return the index of the last element, or panic.

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>ⓘNotable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>    type Item = &'a 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>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>    type Item = &'a mut 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)>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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

pub fn indices(&self) -> Map<Range<usize>, fn(usize) -> I>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

Get an interator over all our indices.

pub fn iter_mut_enumerated(
    &mut self
) -> Map<Enumerate<IterMut<'_, T>>, fn((usize, &mut T)) -> (I, &mut T)>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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>(&mut self, compare: F) where
    F: FnMut(&T, &T) -> Ordering,

Forwards to the slice’s sort_by implementation.

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

Forwards to the slice’s sort_by_key implementation.

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

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>(&mut self, compare: F) where
    F: FnMut(&T, &T) -> Ordering,

Forwards to the slice’s sort_unstable_by implementation.

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

Forwards to the slice’s sort_unstable_by_key implementation.

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

Forwards to the slice’s ends_with implementation.

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

Forwards to the slice’s starts_with implementation.

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

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.

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

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

pub fn copy_from_slice(&mut self, src: &IndexSlice<I, [T]>) where
    T: Copy,

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

pub fn clone_from_slice(&mut self, src: &IndexSlice<I, [T]>) where
    T: Clone,

Copies the elements from src into self.

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

Swaps all elements in self with those in other.

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

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

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

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>(&self, f: F) -> Option<I> where
    F: FnMut(&T) -> bool,

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) -> (&IndexSlice<I, [T]>, &IndexSlice<I, [T]>)

Divides our slice into two at an index.

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

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>(&mut self, src: R, dst: I) where
    T: Copy,
    R: IdxRangeBounds<I>,

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

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

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

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

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B;

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

pub fn split<F>(
    &self, 
    f: F
) -> Map<Split<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub fn split_mut<F>(
    &mut self, 
    f: F
) -> Map<SplitMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub fn rsplit<F>(
    &self, 
    f: F
) -> Map<RSplit<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub fn rsplit_mut<F>(
    &mut self, 
    f: F
) -> Map<RSplitMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub fn splitn<F>(
    &self, 
    n: usize, 
    f: F
) -> Map<SplitN<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub fn splitn_mut<F>(
    &mut self, 
    n: usize, 
    f: F
) -> Map<SplitNMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub fn rsplitn<F>(
    &self, 
    n: usize, 
    f: F
) -> Map<RSplitN<'_, T, F>, fn(&[T]) -> &IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub fn rsplitn_mut<F>(
    &mut self, 
    n: usize, 
    f: F
) -> Map<RSplitNMut<'_, T, F>, fn(&mut [T]) -> &mut IndexSlice<I, [T]>>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator,     type Item = B; where
    F: FnMut(&T) -> bool,

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

pub unsafe fn from_raw_parts<'a>(
    data: *const T, 
    len: usize
) -> &'a IndexSlice<I, [T]>

Create a IdxSlice from its pointer and length.

Safety

This is equivalent to core::slice::from_raw_parts and has the same safety caveats.

pub unsafe fn from_raw_parts_mut<'a>(
    data: *mut T, 
    len: usize
) -> &'a mut IndexSlice<I, [T]>

Create a mutable IdxSlice from its pointer and length.

Safety

This is equivalent to core::slice::from_raw_parts_mut and has the same safety caveats.

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, A> AsMut<[A]> for IndexSlice<I, [A]> where
    I: Idx,

pub fn as_mut(&mut self) -> &mut [A]ⓘNotable traits for &'_ [u8]
impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

Performs the conversion.

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

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

Performs the conversion.

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

pub fn as_ref(&self) -> &[A]ⓘNotable traits for &'_ [u8]
impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

Performs the conversion.

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

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

Performs the conversion.

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

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

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<I, T> Clone for IndexSlice<I, T> where
    T: Clone + ?Sized,
    I: Clone + Idx,

pub fn clone(&self) -> IndexSlice<I, T>

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

impl<I, T> Debug for IndexSlice<I, T> where
    T: Debug + ?Sized,
    I: Idx,

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

Formats the value using the given formatter. Read more

impl<'_, I, T> Default for &'_ mut IndexSlice<I, [T]> where
    I: Idx,

pub fn default() -> &'_ mut IndexSlice<I, [T]>

Returns the “default value” for a type. Read more

impl<'_, I, T> Default for &'_ IndexSlice<I, [T]> where
    I: Idx,

pub fn default() -> &'_ IndexSlice<I, [T]>

Returns the “default value” for a type. Read more

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

impl<I, T> Hash for IndexSlice<I, [T]> where
    T: Hash,
    I: Idx,

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher,

Feeds this value into the given Hasher. Read more

1.3.0[src]

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher,

Feeds a slice of this type into the given Hasher. Read more

impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
    R: IdxSliceIndex<I, T>,
    I: Idx,

type Output = <R as IdxSliceIndex<I, T>>::Output

The returned type after indexing.

pub fn index(&self, index: R) -> &<R as IdxSliceIndex<I, T>>::Output

Performs the indexing (container[index]) operation. Read more

impl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
    R: IdxSliceIndex<I, T>,
    I: Idx,

pub fn index_mut(&mut self, index: R) -> &mut <R as IdxSliceIndex<I, T>>::Output

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

impl<'a, I, T> IntoIterator for &'a IndexSlice<I, [T]> where
    I: Idx,

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?

pub fn into_iter(self) -> Iter<'a, T>ⓘNotable traits for Iter<'a, T>
impl<'a, T> Iterator for Iter<'a, T>    type Item = &'a T;

Creates an iterator from a value. Read more

impl<'a, I, T> IntoIterator for &'a mut IndexSlice<I, [T]> where
    I: Idx,

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?

pub fn into_iter(self) -> IterMut<'a, T>ⓘNotable traits for IterMut<'a, T>
impl<'a, T> Iterator for IterMut<'a, T>    type Item = &'a mut T;

Creates an iterator from a value. Read more

impl<I, T> Ord for IndexSlice<I, [T]> where
    T: Ord,
    I: Idx,

pub fn cmp(&self, other: &IndexSlice<I, [T]>) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0[src]

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

Compares and returns the maximum of two values. Read more

1.21.0[src]

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

Compares and returns the minimum of two values. Read more

1.50.0[src]

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

Restrict a value to a certain interval. Read more

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

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