Struct otter_api_tests::IndexSlice
[−]#[repr(transparent)]pub struct IndexSlice<I, T> where
I: Idx,
T: ?Sized, {
pub raw: T,
/* private fields */
}
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.
- Any that aren’t can be trivially accessed on the underlying
-
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 anIdxRangeBounds<I>
, which is basically aRangeBounds<I>
. -
Apis that take
SliceIndex<usize>
take anIdxSliceIndex<I>
, which is basically aSliceIndex<I>
. -
Most iterator functions where
the_iter().enumerate()
would refer to indices have been given_enumerated
variants. E.g.IndexSlice::iter_enumerated
, etc. This is becausev.iter().enumerate()
would be(usize, &T)
, but you want(I, &T)
.
The following extensions are added:
IndexSlice::indices
: an Iterator over the indices of typeI
.- Various
enumerated
iterators mentioned earlier IndexSlice::position
,IndexSlice::rposition
asself.iter().position()
will return aOption<usize>
Fields
raw: T
Implementations
impl<I, T> IndexSlice<I, [T]> where
I: Idx,
impl<I, T> IndexSlice<I, [T]> where
I: Idx,
pub fn new<S>(s: &S) -> &IndexSlice<I, [T]> where
S: AsRef<[T]> + ?Sized,
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,
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]>
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]>
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 into_vec(self: Box<IndexSlice<I, [T]>, Global>) -> IndexVec<I, T>
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 &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
pub fn as_raw_slice_mut(&mut self) -> &mut [T]ⓘNotable traits for &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
Returns the underlying slice.
pub fn as_raw_slice(&self) -> &[T]ⓘNotable traits for &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
pub fn as_raw_slice(&self) -> &[T]ⓘNotable traits for &mut [u8]impl<'_> Write for &mut [u8]impl<'_> Read for &[u8]
Returns the underlying slice.
pub fn as_mut_ptr(&mut self) -> *mut T
pub fn as_mut_ptr(&mut self) -> *mut T
Returns an unsafe mutable pointer to the slice’s buffer.
pub fn last_idx(&self) -> I
pub fn last_idx(&self) -> I
Return the index of the last element, or panic.
pub fn len_idx(&self) -> I
pub fn len_idx(&self) -> I
Returns the length of our slice as an I
.
pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, T>impl<'a, T> Iterator for Iter<'a, T> type Item = &'a T;
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;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Similar to self.iter_mut().enumerate()
but with indices of I
and not
usize
.
pub fn sort_by<F>(&mut self, compare: F) where
F: for<'_, '_> FnMut(&T, &T) -> Ordering,
pub fn sort_by<F>(&mut self, compare: F) where
F: for<'_, '_> FnMut(&T, &T) -> Ordering,
Forwards to the slice’s sort_by
implementation.
pub fn sort_by_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
pub fn sort_by_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
Forwards to the slice’s sort_by_key
implementation.
pub fn sort_by_cached_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
pub fn sort_by_cached_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
Forwards to the slice’s sort_by_cached_key
implementation.
pub fn sort_unstable(&mut self) where
T: Ord,
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: for<'_, '_> FnMut(&T, &T) -> Ordering,
pub fn sort_unstable_by<F>(&mut self, compare: F) where
F: for<'_, '_> 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
F: for<'_> FnMut(&T) -> K,
K: Ord,
pub fn sort_unstable_by_key<F, K>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> K,
K: Ord,
Forwards to the slice’s sort_unstable_by_key
implementation.
pub fn ends_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
pub fn ends_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
Forwards to the slice’s ends_with
implementation.
pub fn starts_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
pub fn starts_with<S>(&self, needle: &S) -> bool where
S: AsRef<[T]> + ?Sized,
T: PartialEq<T>,
Forwards to the slice’s starts_with
implementation.
pub fn contains(&self, x: &T) -> bool where
T: PartialEq<T>,
pub fn contains(&self, x: &T) -> bool where
T: PartialEq<T>,
Forwards to the slice’s contains
implementation.
pub fn reverse(&mut self)
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,
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,
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,
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,
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]>)
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,
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: for<'_> FnMut(&T) -> bool,
pub fn position<F>(&self, f: F) -> Option<I> where
F: for<'_> 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: for<'_> FnMut(&T) -> bool,
pub fn rposition<F>(&self, f: F) -> Option<I> where
F: for<'_> 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)
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]>)
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]>)
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)
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)
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 copy_within<R>(&mut self, src: R, dst: I) where
R: IdxRangeBounds<I>,
T: Copy,
pub fn copy_within<R>(&mut self, src: R, dst: I) where
R: IdxRangeBounds<I>,
T: Copy,
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>,
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>,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s windows
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks_mut
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks_exact
iterator with one that
yields IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s chunks_exact_mut
iterator with one that
yields IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks_mut
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks_exact
iterator with one that
yields IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rchunks_exact_mut
iterator with one that
yields IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s split
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s split_mut
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplit
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplit_mut
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s splitn
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s splitn_mut
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplitn
iterator with one that yields
IndexSlice
s 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: for<'_> FnMut(&T) -> bool,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Wraps the underlying slice’s rsplitn_mut
iterator with one that yields
IndexSlice
s with the correct index type.
pub unsafe fn from_raw_parts<'a>(
data: *const T,
len: usize
) -> &'a IndexSlice<I, [T]>
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]>
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]>)>
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]>)>
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]>)>
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]>)>
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,
impl<I, A> AsMut<[A]> for IndexSlice<I, [A]> where
I: Idx,
impl<I, A> AsMut<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
impl<I, A> AsMut<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
fn as_mut(&mut self) -> &mut IndexSlice<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, A> AsRef<[A]> for IndexSlice<I, [A]> where
I: Idx,
impl<I, A> AsRef<[A]> for IndexSlice<I, [A]> where
I: Idx,
impl<I, A> AsRef<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
impl<I, A> AsRef<IndexSlice<I, [A]>> for IndexVec<I, A> where
I: Idx,
fn as_ref(&self) -> &IndexSlice<I, [A]>
fn as_ref(&self) -> &IndexSlice<I, [A]>
Converts this type into a shared reference of the (usually inferred) input type.
impl<I, T> Borrow<IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
impl<I, T> Borrow<IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
fn borrow(&self) -> &IndexSlice<I, [T]>
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,
impl<I, T> BorrowMut<IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
fn borrow_mut(&mut self) -> &mut IndexSlice<I, [T]>
fn borrow_mut(&mut self) -> &mut IndexSlice<I, [T]>
Mutably borrows from an owned value. Read more
impl<I, T> Clone for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Clone,
impl<I, T> Clone for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Clone,
fn clone(&self) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn clone(&self) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<I, T> Clone for IndexSlice<I, T> where
I: Clone + Idx,
T: Clone + ?Sized,
impl<I, T> Clone for IndexSlice<I, T> where
I: Clone + Idx,
T: Clone + ?Sized,
fn clone(&self) -> IndexSlice<I, T>
fn clone(&self) -> IndexSlice<I, T>
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<I, T> Debug for IndexSlice<I, T> where
I: Idx,
T: Debug + ?Sized,
impl<I, T> Debug for IndexSlice<I, T> where
I: Idx,
T: Debug + ?Sized,
impl<'_, I, T> Default for &IndexSlice<I, [T]> where
I: Idx,
impl<'_, I, T> Default for &IndexSlice<I, [T]> where
I: Idx,
fn default() -> &IndexSlice<I, [T]>
fn default() -> &IndexSlice<I, [T]>
Returns the “default value” for a type. Read more
impl<I, A> Default for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> Default for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
fn default() -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn default() -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Returns the “default value” for a type. Read more
impl<'_, I, T> Default for &mut IndexSlice<I, [T]> where
I: Idx,
impl<'_, I, T> Default for &mut IndexSlice<I, [T]> where
I: Idx,
fn default() -> &mut IndexSlice<I, [T]>
fn default() -> &mut IndexSlice<I, [T]>
Returns the “default value” for a type. Read more
impl<'de, I, T> Deserialize<'de> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Deserialize<'de>,
impl<'de, I, T> Deserialize<'de> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
T: Deserialize<'de>,
fn deserialize<D>(
deserializer: D
) -> Result<Box<IndexSlice<I, [T]>, Global>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D
) -> Result<Box<IndexSlice<I, [T]>, Global>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
impl<'a, I, T> From<&'a [T]> for &'a IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> From<&'a [T]> for &'a IndexSlice<I, [T]> where
I: Idx,
fn from(a: &'a [T]) -> &'a IndexSlice<I, [T]>
fn from(a: &'a [T]) -> &'a IndexSlice<I, [T]>
Converts to this type from the input type.
impl<'a, I, T> From<&'a IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
impl<'a, I, T> From<&'a IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
fn from(src: &'a IndexSlice<I, [T]>) -> IndexVec<I, T>
fn from(src: &'a IndexSlice<I, [T]>) -> IndexVec<I, T>
Converts to this type from the input type.
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
fn from(a: &'a mut [T]) -> &'a mut IndexSlice<I, [T]>
fn from(a: &'a mut [T]) -> &'a mut IndexSlice<I, [T]>
Converts to this type from the input type.
impl<'a, I, T> From<&'a mut IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
impl<'a, I, T> From<&'a mut IndexSlice<I, [T]>> for IndexVec<I, T> where
I: Idx,
T: Clone,
fn from(src: &'a mut IndexSlice<I, [T]>) -> IndexVec<I, T>
fn from(src: &'a mut IndexSlice<I, [T]>) -> IndexVec<I, T>
Converts to this type from the input type.
impl<I, T> From<Box<[T], Global>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
impl<I, T> From<Box<[T], Global>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
fn from(b: Box<[T], Global>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(b: Box<[T], Global>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts to this type from the input type.
impl<I, T> From<IndexVec<I, T>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
impl<I, T> From<IndexVec<I, T>> for Box<IndexSlice<I, [T]>, Global> where
I: Idx,
fn from(src: IndexVec<I, T>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn from(src: IndexVec<I, T>) -> Box<IndexSlice<I, [T]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts to this type from the input type.
impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
fn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
where
T: IntoIterator<Item = A>,
fn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
where
T: IntoIterator<Item = A>,
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Creates a value from an iterator. Read more
impl<I, T> Hash for IndexSlice<I, [T]> where
I: Idx,
T: Hash,
impl<I, T> Hash for IndexSlice<I, [T]> where
I: Idx,
T: Hash,
impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
type Output = <R as IdxSliceIndex<I, T>>::Output
type Output = <R as IdxSliceIndex<I, T>>::Output
The returned type after indexing.
fn index(&self, index: R) -> &<R as IdxSliceIndex<I, T>>::Output
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
I: Idx,
R: IdxSliceIndex<I, T>,
impl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
I: Idx,
R: IdxSliceIndex<I, T>,
fn index_mut(&mut self, index: R) -> &mut <R as IdxSliceIndex<I, T>>::Output
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 mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a IndexSlice<I, [T]> where
I: Idx,
impl<I, A> IntoIterator for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
impl<I, A> IntoIterator for Box<IndexSlice<I, [A]>, Global> where
I: Idx,
type Item = A
type Item = A
The type of the elements being iterated over.
fn into_iter(
self
) -> <Box<IndexSlice<I, [A]>, Global> as IntoIterator>::IntoIterⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn into_iter(
self
) -> <Box<IndexSlice<I, [A]>, Global> as IntoIterator>::IntoIterⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Creates an iterator from a value. Read more
impl<I, T> Ord for IndexSlice<I, [T]> where
I: Idx,
T: Ord,
impl<I, T> Ord for IndexSlice<I, [T]> where
I: Idx,
T: Ord,
impl<'a, 'b, A, B, I, J> PartialEq<&'a IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'a IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
fn eq(&self, other: &&'a IndexSlice<J, [B]>) -> bool
fn eq(&self, other: &&'a IndexSlice<J, [B]>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
fn ne(&self, other: &&'a IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'a IndexSlice<J, [B]>) -> bool
This method tests for !=
.
impl<'a, 'b, A, B, I, J> PartialEq<&'a mut IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'a mut IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
fn eq(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool
fn eq(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
fn ne(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool
This method tests for !=
.
impl<'a, 'b, A, B, I, J> PartialEq<&'b IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'b IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
fn eq(&self, other: &&'b IndexSlice<J, [B]>) -> bool
fn eq(&self, other: &&'b IndexSlice<J, [B]>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
fn ne(&self, other: &&'b IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'b IndexSlice<J, [B]>) -> bool
This method tests for !=
.
impl<'a, 'b, A, B, I, J> PartialEq<&'b mut IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<&'b mut IndexSlice<J, [B]>> for IndexVec<I, A> where
I: Idx,
J: Idx,
A: PartialEq<B>,
fn eq(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool
fn eq(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
fn ne(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool
This method tests for !=
.
impl<I, A, B> PartialEq<IndexSlice<I, [B]>> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<I, A, B> PartialEq<IndexSlice<I, [B]>> for IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
fn eq(&self, other: &IndexSlice<I, [B]>) -> bool
fn eq(&self, other: &IndexSlice<I, [B]>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
fn ne(&self, other: &IndexSlice<I, [B]>) -> bool
fn ne(&self, other: &IndexSlice<I, [B]>) -> bool
This method tests for !=
.
impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I, J> PartialEq<IndexVec<J, B>> for &'a IndexSlice<I, [A]> where
I: Idx,
J: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a mut IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for &'a IndexSlice<I, [A]> where
I: Idx,
A: PartialEq<B>,
impl<I, T> PartialOrd<IndexSlice<I, [T]>> for IndexSlice<I, [T]> where
I: Idx,
T: PartialOrd<T>,
impl<I, T> PartialOrd<IndexSlice<I, [T]>> for IndexSlice<I, [T]> where
I: Idx,
T: PartialOrd<T>,
fn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>
fn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<I, T> Serialize for Box<IndexSlice<I, T>, Global> where
I: Idx,
T: Serialize,
impl<I, T> Serialize for Box<IndexSlice<I, T>, Global> where
I: Idx,
T: Serialize,
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<I, T> ToOwned for IndexSlice<I, [T]> where
I: Idx,
T: Clone,
impl<I, T> ToOwned for IndexSlice<I, [T]> where
I: Idx,
T: Clone,
fn to_owned(&self) -> <IndexSlice<I, [T]> as ToOwned>::Owned
fn to_owned(&self) -> <IndexSlice<I, [T]> as ToOwned>::Owned
Creates owned data from borrowed data, usually by cloning. Read more
1.63.0 · sourcefn clone_into(&self, target: &mut Self::Owned)
fn clone_into(&self, target: &mut Self::Owned)
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<I, T> Copy for IndexSlice<I, T> where
I: Copy + Idx,
T: Copy + ?Sized,
impl<I, A> Eq for IndexSlice<I, [A]> where
I: Idx,
A: Eq,
impl<I, T> Send for IndexSlice<I, [T]> where
I: Idx,
T: Send,
Auto Trait Implementations
impl<I, T: ?Sized> RefUnwindSafe for IndexSlice<I, T> where
T: RefUnwindSafe,
impl<I, T: ?Sized> Send for IndexSlice<I, T> where
T: Send,
impl<I, T: ?Sized> Sync for IndexSlice<I, T> where
T: Sync,
impl<I, T: ?Sized> Unpin for IndexSlice<I, T> where
T: Unpin,
impl<I, T: ?Sized> UnwindSafe for IndexSlice<I, T> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<A> DynCastExt for A
impl<A> DynCastExt for A
fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
Use this to cast from one trait object type to another. Read more
fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
Use this to upcast a trait to one of its supertraits. Read more
fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more