Expand description
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 bypush
.IndexVec::push
returns the index the item was inserted at.
Fields
raw: Vec<T, Global>
Our wrapped Vec.
Implementations
sourceimpl<I, T> IndexVec<I, T> where
I: Idx,
impl<I, T> IndexVec<I, T> where
I: Idx,
sourcepub fn from_vec(vec: Vec<T, Global>) -> IndexVec<I, T>
pub fn from_vec(vec: Vec<T, Global>) -> IndexVec<I, T>
Construct a IndexVec
from a Vec<T>
.
Panics if it’s length is too large for our index type.
sourcepub fn with_capacity(capacity: usize) -> IndexVec<I, T>
pub fn with_capacity(capacity: usize) -> IndexVec<I, T>
Construct an IndexVec that can hold at least capacity
items before
reallocating. See Vec::with_capacity
.
sourcepub fn into_iter_enumerated(
self
) -> Map<Enumerate<IntoIter<T, Global>>, 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 into_iter_enumerated(
self
) -> Map<Enumerate<IntoIter<T, Global>>, 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.into_iter().enumerate()
but with indices of I
and
not usize
.
sourcepub fn splice<R, It>(
&mut self,
range: R,
replace_with: It
) -> Splice<'_, <It as IntoIterator>::IntoIter, Global>ⓘNotable traits for Splice<'_, I, A>impl<'_, I, A> Iterator for Splice<'_, I, A> where
I: Iterator,
A: Allocator, type Item = <I as Iterator>::Item;
where
It: IntoIterator<Item = T>,
R: IdxRangeBounds<I>,
pub fn splice<R, It>(
&mut self,
range: R,
replace_with: It
) -> Splice<'_, <It as IntoIterator>::IntoIter, Global>ⓘNotable traits for Splice<'_, I, A>impl<'_, I, A> Iterator for Splice<'_, I, A> where
I: Iterator,
A: Allocator, type Item = <I as Iterator>::Item;
where
It: IntoIterator<Item = T>,
R: IdxRangeBounds<I>,
I: Iterator,
A: Allocator, type Item = <I as Iterator>::Item;
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
sourcepub fn drain_enumerated<R>(
&mut self,
range: R
) -> Map<Enumerate<Drain<'_, T, Global>>, 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;
where
R: IdxRangeBounds<I>,
pub fn drain_enumerated<R>(
&mut self,
range: R
) -> Map<Enumerate<Drain<'_, T, Global>>, 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;
where
R: IdxRangeBounds<I>,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
Similar to self.drain(r).enumerate()
but with indices of I
and not
usize
.
sourcepub 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]
Get a the storage as a &[T]
sourcepub 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]
Get a the storage as a &mut [T]
sourcepub fn as_vec(&self) -> &Vec<T, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
pub fn as_vec(&self) -> &Vec<T, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Equivalent to accessing our raw
field, but as a function.
sourcepub fn as_mut_vec(&mut self) -> &mut Vec<T, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
pub fn as_mut_vec(&mut self) -> &mut Vec<T, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where
A: Allocator,
A: Allocator,
Equivalent to accessing our raw
field mutably, but as a function, if
that’s what you’d prefer.
sourcepub fn into_boxed_slice(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<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
pub fn into_boxed_slice(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<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<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Converts the vector into an owned IdxSlice, dropping excess capacity.
sourcepub fn drain<R>(&mut self, range: R) -> Drain<'_, T, Global>ⓘNotable traits for Drain<'_, T, A>impl<'_, T, A> Iterator for Drain<'_, T, A> where
A: Allocator, type Item = T;
where
R: IdxRangeBounds<I>,
pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, Global>ⓘNotable traits for Drain<'_, T, A>impl<'_, T, A> Iterator for Drain<'_, T, A> where
A: Allocator, type Item = T;
where
R: IdxRangeBounds<I>,
A: Allocator, type Item = 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.
sourcepub fn shrink_to_fit(&mut self)
pub fn shrink_to_fit(&mut self)
Shrinks the capacity of the vector as much as possible.
sourcepub fn truncate(&mut self, a: usize)
pub fn truncate(&mut self, a: usize)
Shortens the vector, keeping the first len
elements and dropping
the rest. See Vec::truncate
sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Clear our vector. See Vec::clear
.
sourcepub fn reserve(&mut self, c: usize)
pub fn reserve(&mut self, c: usize)
Reserve capacity for c
more elements. See Vec::reserve
sourcepub 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.
sourcepub 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
sourcepub fn resize(&mut self, new_len: usize, value: T) where
T: Clone,
pub fn resize(&mut self, new_len: usize, value: T) where
T: Clone,
Resize ourselves in-place to new_len
. See Vec::resize
.
sourcepub fn resize_with<F>(&mut self, new_len: usize, f: F) where
F: FnMut() -> T,
pub fn resize_with<F>(&mut self, new_len: usize, f: F) where
F: FnMut() -> T,
Resize ourselves in-place to new_len
. See Vec::resize_with
.
sourcepub fn append(&mut self, other: &mut IndexVec<I, T>)
pub fn append(&mut self, other: &mut IndexVec<I, T>)
Moves all the elements of other
into Self
, leaving other
empty.
See Vec::append
.
sourcepub fn split_off(&mut self, idx: I) -> IndexVec<I, T>
pub fn split_off(&mut self, idx: I) -> IndexVec<I, T>
Splits the collection into two at the given index. See
Vec::split_off
.
sourcepub fn remove(&mut self, index: I) -> T
pub fn remove(&mut self, index: I) -> T
Remove the item at index
. See Vec::remove
.
sourcepub fn swap_remove(&mut self, index: I) -> T
pub fn swap_remove(&mut self, index: I) -> T
Remove the item at index
without maintaining order. See
Vec::swap_remove
.
sourcepub fn insert(&mut self, index: I, element: T)
pub fn insert(&mut self, index: I, element: T)
Insert an item at index
. See Vec::insert
.
sourcepub fn extend_from_slice(&mut self, other: &IndexSlice<I, [T]>) where
T: Clone,
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.
sourcepub fn retain<F>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> bool,
pub fn retain<F>(&mut self, f: F) where
F: for<'_> FnMut(&T) -> bool,
Forwards to the Vec::retain
implementation.
sourcepub fn dedup_by_key<F, K>(&mut self, key: F) where
F: for<'_> FnMut(&mut T) -> K,
K: PartialEq<K>,
pub fn dedup_by_key<F, K>(&mut self, key: F) where
F: for<'_> FnMut(&mut T) -> K,
K: PartialEq<K>,
Forwards to the Vec::dedup_by_key
implementation.
sourcepub fn dedup_by<F>(&mut self, same_bucket: F) where
F: for<'_, '_> FnMut(&mut T, &mut T) -> bool,
pub fn dedup_by<F>(&mut self, same_bucket: F) where
F: for<'_, '_> FnMut(&mut T, &mut T) -> bool,
Forwards to the Vec::dedup_by
implementation.
sourcepub fn as_slice(&self) -> &IndexSlice<I, [T]>
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
).
sourcepub fn as_mut_slice(&mut self) -> &mut IndexSlice<I, [T]>
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]>>
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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
.
sourcepub 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.
sourcepub 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
.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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
.
sourcepub 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
.
sourcepub 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.
sourcepub 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
.
sourcepub 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
.
sourcepub 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.
sourcepub 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.
sourcepub 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
sourcepub 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
sourcepub fn first_mut(&mut self) -> Option<&mut T>
pub fn first_mut(&mut self) -> Option<&mut T>
Return the the first element, if we are not empty.
sourcepub 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.
sourcepub 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.
sourcepub 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
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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.
sourcepub 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
sourceimpl<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,
sourcefn 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.
sourceimpl<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,
sourcefn 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.
sourceimpl<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,
sourcefn borrow(&self) -> &IndexSlice<I, [T]>
fn borrow(&self) -> &IndexSlice<I, [T]>
Immutably borrows from an owned value. Read more
sourceimpl<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,
sourcefn 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
sourceimpl<I, A> Deref for IndexVec<I, A> where
I: Idx,
impl<I, A> Deref for IndexVec<I, A> where
I: Idx,
type Target = IndexSlice<I, [A]>
type Target = IndexSlice<I, [A]>
The resulting type after dereferencing.
sourcefn deref(&self) -> &IndexSlice<I, [A]>
fn deref(&self) -> &IndexSlice<I, [A]>
Dereferences the value.
sourceimpl<I, A> DerefMut for IndexVec<I, A> where
I: Idx,
impl<I, A> DerefMut for IndexVec<I, A> where
I: Idx,
sourcefn deref_mut(&mut self) -> &mut IndexSlice<I, [A]>
fn deref_mut(&mut self) -> &mut IndexSlice<I, [A]>
Mutably dereferences the value.
sourceimpl<'de, I, T> Deserialize<'de> for IndexVec<I, T> where
I: Idx,
T: Deserialize<'de>,
impl<'de, I, T> Deserialize<'de> for IndexVec<I, T> where
I: Idx,
T: Deserialize<'de>,
sourcefn deserialize<D>(
deserializer: D
) -> Result<IndexVec<I, T>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D
) -> Result<IndexVec<I, T>, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
sourceimpl<'a, I, T> Extend<&'a T> for IndexVec<I, T> where
I: Idx,
T: 'a + Copy,
impl<'a, I, T> Extend<&'a T> for IndexVec<I, T> where
I: Idx,
T: 'a + Copy,
sourcefn extend<J>(&mut self, iter: J) where
J: IntoIterator<Item = &'a T>,
fn extend<J>(&mut self, iter: J) where
J: IntoIterator<Item = &'a T>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
sourceimpl<I, T> Extend<T> for IndexVec<I, T> where
I: Idx,
impl<I, T> Extend<T> for IndexVec<I, T> where
I: Idx,
sourcefn extend<J>(&mut self, iter: J) where
J: IntoIterator<Item = T>,
fn extend<J>(&mut self, iter: J) where
J: IntoIterator<Item = T>,
Extends a collection with the contents of an iterator. Read more
sourcefn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)Extends a collection with exactly one element.
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
sourceimpl<'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,
sourcefn 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.
sourceimpl<'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,
sourcefn 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.
sourceimpl<'a, I, T> From<Cow<'a, IndexSlice<I, [T]>>> for IndexVec<I, T> where
I: Idx,
IndexSlice<I, [T]>: ToOwned,
<IndexSlice<I, [T]> as ToOwned>::Owned == IndexVec<I, T>,
impl<'a, I, T> From<Cow<'a, IndexSlice<I, [T]>>> for IndexVec<I, T> where
I: Idx,
IndexSlice<I, [T]>: ToOwned,
<IndexSlice<I, [T]> as ToOwned>::Owned == IndexVec<I, T>,
sourceimpl<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,
sourcefn 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<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<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<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.
sourceimpl<I, T> FromIterator<T> for IndexVec<I, T> where
I: Idx,
impl<I, T> FromIterator<T> for IndexVec<I, T> where
I: Idx,
sourcefn from_iter<J>(iter: J) -> IndexVec<I, T> where
J: IntoIterator<Item = T>,
fn from_iter<J>(iter: J) -> IndexVec<I, T> where
J: IntoIterator<Item = T>,
Creates a value from an iterator. Read more
sourceimpl<I, T> IndexVecITExt<I, T> for IndexVec<I, T> where
I: Idx,
impl<I, T> IndexVecITExt<I, T> for IndexVec<I, T> where
I: Idx,
fn get_or_extend_with<F>(&mut self, i: I, f: F) -> &mut T where
F: FnMut() -> T,
sourceimpl<'a, I, T> IntoIterator for &'a mut IndexVec<I, T> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a mut IndexVec<I, T> where
I: Idx,
sourceimpl<I, T> IntoIterator for IndexVec<I, T> where
I: Idx,
impl<I, T> IntoIterator for IndexVec<I, T> where
I: Idx,
type Item = T
type Item = T
The type of the elements being iterated over.
sourceimpl<'a, I, T> IntoIterator for &'a IndexVec<I, T> where
I: Idx,
impl<'a, I, T> IntoIterator for &'a IndexVec<I, T> where
I: Idx,
sourceimpl<I, T> Ord for IndexVec<I, T> where
I: Ord + Idx,
T: Ord,
impl<I, T> Ord for IndexVec<I, T> where
I: Ord + Idx,
T: Ord,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 10]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 10]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 11]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 11]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 12]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 12]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 13]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 13]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 14]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 14]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 15]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 15]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 16]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 16]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 17]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 17]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 18]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 18]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 19]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 19]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 20]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 20]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 21]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 21]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 22]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 22]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 23]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 23]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 24]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 24]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 25]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 25]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 26]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 26]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 27]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 27]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 28]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 28]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 29]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 29]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 30]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 30]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 31]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 31]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b [B; 32]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b [B; 32]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'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>,
sourceimpl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<'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>,
sourceimpl<I, T> PartialEq<IndexVec<I, T>> for IndexVec<I, T> where
I: PartialEq<I> + Idx,
T: PartialEq<T>,
impl<I, T> PartialEq<IndexVec<I, T>> for IndexVec<I, T> where
I: PartialEq<I> + Idx,
T: PartialEq<T>,
sourceimpl<'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>,
sourceimpl<'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>,
sourceimpl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B, Global>> for IndexVec<I, A> where
I: Idx,
A: PartialEq<B>,
sourceimpl<I, T> PartialOrd<IndexVec<I, T>> for IndexVec<I, T> where
I: PartialOrd<I> + Idx,
T: PartialOrd<T>,
impl<I, T> PartialOrd<IndexVec<I, T>> for IndexVec<I, T> where
I: PartialOrd<I> + Idx,
T: PartialOrd<T>,
sourcefn partial_cmp(&self, other: &IndexVec<I, T>) -> Option<Ordering>
fn partial_cmp(&self, other: &IndexVec<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
sourceimpl<I, T> Serialize for IndexVec<I, T> where
I: Idx,
T: Serialize,
impl<I, T> Serialize for IndexVec<I, T> where
I: Idx,
T: Serialize,
sourcefn 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> Eq for IndexVec<I, T> where
I: Eq + Idx,
T: Eq,
impl<I, T> Send for IndexVec<I, T> where
I: Idx,
T: Send,
impl<I, T> StructuralEq for IndexVec<I, T> where
I: Idx,
impl<I, T> StructuralPartialEq for IndexVec<I, T> where
I: Idx,
Auto Trait Implementations
impl<I, T> RefUnwindSafe for IndexVec<I, T> where
T: RefUnwindSafe,
impl<I, T> Sync for IndexVec<I, T> where
T: Sync,
impl<I, T> Unpin for IndexVec<I, T> where
T: Unpin,
impl<I, T> UnwindSafe for IndexVec<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
sourceimpl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
sourcefn 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<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<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<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
sourcefn 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
sourcefn 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
sourcefn 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
sourceimpl<T> DowncastSync for T where
T: Any + Send + Sync,
impl<T> DowncastSync for T where
T: Any + Send + Sync,
sourceimpl<A> DynCastExt for A
impl<A> DynCastExt for A
sourcefn 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
sourcefn 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
sourcefn 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,
sourcefn 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