Struct oxc::index::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
rawfield, 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 an [IdxRangeBounds<I>][IdxRangeBounds], which is basically aRangeBounds<I>. -
Apis that take
SliceIndex<usize>take an [IdxSliceIndex<I>][IdxSliceIndex], which is basically aSliceIndex<I>. -
Most iterator functions where
the_iter().enumerate()would refer to indices have been given_enumeratedvariants. 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
enumeratediterators mentioned earlier IndexSlice::position,IndexSlice::rpositionasself.iter().position()will return aOption<usize>
Fields§
§raw: TImplementations§
§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]>
pub fn new<S>(s: &S) -> &IndexSlice<I, [T]>
Construct a new IdxSlice by wrapping an existing slice.
pub fn new_mut<S>(s: &mut S) -> &mut IndexSlice<I, [T]>
pub fn new_mut<S>(s: &mut S) -> &mut IndexSlice<I, [T]>
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]>>) -> IndexVec<I, T>
pub fn into_vec(self: Box<IndexSlice<I, [T]>>) -> 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]
pub fn as_raw_slice_mut(&mut self) -> &mut [T]
Returns the underlying slice.
pub fn as_raw_slice(&self) -> &[T]
pub fn as_raw_slice(&self) -> &[T]
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> ⓘ
pub fn iter(&self) -> Iter<'_, T> ⓘ
Get a iterator over reverences to our values.
See also IndexSlice::iter_enumerated, which gives you indices (of the
correct type) as you iterate.
pub fn iter_mut(&mut self) -> IterMut<'_, T> ⓘ
pub fn iter_mut(&mut self) -> IterMut<'_, T> ⓘ
Get a iterator over mut reverences to our values.
See also IndexSlice::iter_mut_enumerated, which gives you indices (of
the correct type) as you iterate.
pub fn iter_enumerated(
&self
) -> Map<Enumerate<Iter<'_, T>>, fn(_: (usize, &T)) -> (I, &T)> ⓘ
pub fn iter_enumerated( &self ) -> Map<Enumerate<Iter<'_, T>>, fn(_: (usize, &T)) -> (I, &T)> ⓘ
Similar to self.iter().enumerate() but with indices of I and not
usize.
pub fn indices(&self) -> Map<Range<usize>, fn(_: usize) -> I> ⓘ
pub fn indices(&self) -> Map<Range<usize>, fn(_: usize) -> I> ⓘ
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)> ⓘ
pub fn iter_mut_enumerated( &mut self ) -> Map<Enumerate<IterMut<'_, T>>, fn(_: (usize, &mut T)) -> (I, &mut T)> ⓘ
Similar to self.iter_mut().enumerate() but with indices of I and not
usize.
pub fn sort_by<F>(&mut self, compare: F)
pub fn sort_by<F>(&mut self, compare: F)
Forwards to the slice’s sort_by implementation.
pub fn sort_by_key<F, K>(&mut self, f: F)
pub fn sort_by_key<F, K>(&mut self, f: F)
Forwards to the slice’s sort_by_key implementation.
pub fn sort_by_cached_key<F, K>(&mut self, f: F)
pub fn sort_by_cached_key<F, K>(&mut self, f: F)
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)
pub fn sort_unstable_by<F>(&mut self, compare: F)
Forwards to the slice’s sort_unstable_by implementation.
pub fn sort_unstable_by_key<F, K>(&mut self, f: F)
pub fn sort_unstable_by_key<F, K>(&mut self, f: F)
Forwards to the slice’s sort_unstable_by_key implementation.
pub fn starts_with<S>(&self, needle: &S) -> bool
pub fn starts_with<S>(&self, needle: &S) -> bool
Forwards to the slice’s starts_with implementation.
pub fn contains(&self, x: &T) -> boolwhere
T: PartialEq,
pub fn contains(&self, x: &T) -> boolwhere
T: PartialEq,
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>
pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<I, I>
Binary searches this sorted vec with a comparator function, converting the indices it gives us back to our Idx type.
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>
pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<I, I>
Binary searches this sorted vec with a key extraction function, converting the indices it gives us back to our Idx type.
pub fn position<F>(&self, f: F) -> Option<I>
pub fn position<F>(&self, f: F) -> Option<I>
Searches for an element in an iterator, returning its index. This is
equivalent to Iterator::position, but returns I and not usize.
pub fn rposition<F>(&self, f: F) -> Option<I>
pub fn rposition<F>(&self, f: F) -> Option<I>
Searches for an element in an iterator from the right, returning its
index. This is equivalent to Iterator::position, but returns I and
not usize.
pub fn swap(&mut self, a: I, b: I)
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]>> ⓘ
pub fn windows( &self, size: usize ) -> Map<Windows<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s windows iterator with one that yields
IndexSlices with the correct index type.
pub fn chunks(
&self,
size: usize
) -> Map<Chunks<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn chunks( &self, size: usize ) -> Map<Chunks<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s chunks iterator with one that yields
IndexSlices with the correct index type.
pub fn chunks_mut(
&mut self,
size: usize
) -> Map<ChunksMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn chunks_mut( &mut self, size: usize ) -> Map<ChunksMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s chunks_mut iterator with one that yields
IndexSlices with the correct index type.
pub fn chunks_exact(
&self,
chunk_size: usize
) -> Map<ChunksExact<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn chunks_exact( &self, chunk_size: usize ) -> Map<ChunksExact<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s chunks_exact iterator with one that
yields IndexSlices with the correct index type.
pub fn chunks_exact_mut(
&mut self,
chunk_size: usize
) -> Map<ChunksExactMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn chunks_exact_mut( &mut self, chunk_size: usize ) -> Map<ChunksExactMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s chunks_exact_mut iterator with one that
yields IndexSlices with the correct index type.
pub fn rchunks(
&self,
size: usize
) -> Map<RChunks<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn rchunks( &self, size: usize ) -> Map<RChunks<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rchunks iterator with one that yields
IndexSlices with the correct index type.
pub fn rchunks_mut(
&mut self,
size: usize
) -> Map<RChunksMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn rchunks_mut( &mut self, size: usize ) -> Map<RChunksMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rchunks_mut iterator with one that yields
IndexSlices with the correct index type.
pub fn rchunks_exact(
&self,
chunk_size: usize
) -> Map<RChunksExact<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn rchunks_exact( &self, chunk_size: usize ) -> Map<RChunksExact<'_, T>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rchunks_exact iterator with one that
yields IndexSlices with the correct index type.
pub fn rchunks_exact_mut(
&mut self,
chunk_size: usize
) -> Map<RChunksExactMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn rchunks_exact_mut( &mut self, chunk_size: usize ) -> Map<RChunksExactMut<'_, T>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rchunks_exact_mut iterator with one that
yields IndexSlices with the correct index type.
pub fn split<F>(
&self,
f: F
) -> Map<Split<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn split<F>( &self, f: F ) -> Map<Split<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s split iterator with one that yields
IndexSlices with the correct index type.
pub fn split_mut<F>(
&mut self,
f: F
) -> Map<SplitMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn split_mut<F>( &mut self, f: F ) -> Map<SplitMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s split_mut iterator with one that yields
IndexSlices with the correct index type.
pub fn rsplit<F>(
&self,
f: F
) -> Map<RSplit<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn rsplit<F>( &self, f: F ) -> Map<RSplit<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rsplit iterator with one that yields
IndexSlices with the correct index type.
pub fn rsplit_mut<F>(
&mut self,
f: F
) -> Map<RSplitMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn rsplit_mut<F>( &mut self, f: F ) -> Map<RSplitMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rsplit_mut iterator with one that yields
IndexSlices with the correct index type.
pub fn splitn<F>(
&self,
n: usize,
f: F
) -> Map<SplitN<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn splitn<F>( &self, n: usize, f: F ) -> Map<SplitN<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s splitn iterator with one that yields
IndexSlices with the correct index type.
pub fn splitn_mut<F>(
&mut self,
n: usize,
f: F
) -> Map<SplitNMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn splitn_mut<F>( &mut self, n: usize, f: F ) -> Map<SplitNMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s splitn_mut iterator with one that yields
IndexSlices with the correct index type.
pub fn rsplitn<F>(
&self,
n: usize,
f: F
) -> Map<RSplitN<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
pub fn rsplitn<F>( &self, n: usize, f: F ) -> Map<RSplitN<'_, T, F>, fn(_: &[T]) -> &IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rsplitn iterator with one that yields
IndexSlices with the correct index type.
pub fn rsplitn_mut<F>(
&mut self,
n: usize,
f: F
) -> Map<RSplitNMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
pub fn rsplitn_mut<F>( &mut self, n: usize, f: F ) -> Map<RSplitNMut<'_, T, F>, fn(_: &mut [T]) -> &mut IndexSlice<I, [T]>> ⓘ
Wraps the underlying slice’s rsplitn_mut iterator with one that yields
IndexSlices with the correct index type.
pub 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]>
§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]>
§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]>
§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]>
§impl<I, T> Clone for IndexSlice<I, T>
impl<I, T> Clone for IndexSlice<I, T>
§fn clone(&self) -> IndexSlice<I, T>
fn clone(&self) -> IndexSlice<I, T>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read more§impl<I, T> Debug for IndexSlice<I, T>
impl<I, T> Debug for IndexSlice<I, T>
§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]>
§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]>
§impl<I, A> Default for Box<IndexSlice<I, [A]>>where
I: Idx,
impl<I, A> Default for Box<IndexSlice<I, [A]>>where
I: Idx,
§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]>
§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>
§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]>
§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>
§impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>>where
I: Idx,
impl<I, A> FromIterator<A> for Box<IndexSlice<I, [A]>>where
I: Idx,
§fn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>>where
T: IntoIterator<Item = A>,
fn from_iter<T>(iter: T) -> Box<IndexSlice<I, [A]>>where
T: IntoIterator<Item = A>,
§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>,
§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>,
§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<'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<I, A> IntoIterator for Box<IndexSlice<I, [A]>>where
I: Idx,
impl<I, A> IntoIterator for Box<IndexSlice<I, [A]>>where
I: Idx,
§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
self and other values to be equal, and is used
by ==.§fn ne(&self, other: &&'a IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'a IndexSlice<J, [B]>) -> bool
!=. The default implementation is almost always
sufficient, and should not be overridden without very good reason.§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
self and other values to be equal, and is used
by ==.§fn ne(&self, other: &&'b IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'b IndexSlice<J, [B]>) -> bool
!=. The default implementation is almost always
sufficient, and should not be overridden without very good reason.§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
self and other values to be equal, and is used
by ==.§fn ne(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'a mut IndexSlice<J, [B]>) -> bool
!=. The default implementation is almost always
sufficient, and should not be overridden without very good reason.§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
self and other values to be equal, and is used
by ==.§fn ne(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool
fn ne(&self, other: &&'b mut IndexSlice<J, [B]>) -> bool
!=. The default implementation is almost always
sufficient, and should not be overridden without very good reason.§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
self and other values to be equal, and is used
by ==.§fn ne(&self, other: &IndexSlice<I, [B]>) -> bool
fn ne(&self, other: &IndexSlice<I, [B]>) -> bool
!=. The default implementation is almost always
sufficient, and should not be overridden without very good reason.§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, 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> PartialEq<Vec<B>> for &'a mut IndexSlice<I, [A]>where
I: Idx,
A: PartialEq<B>,
impl<'a, 'b, A, B, I> PartialEq<Vec<B>> for &'a mut IndexSlice<I, [A]>where
I: Idx,
A: PartialEq<B>,
§impl<I, T> PartialOrd for IndexSlice<I, [T]>where
I: Idx,
T: PartialOrd,
impl<I, T> PartialOrd for IndexSlice<I, [T]>where
I: Idx,
T: PartialOrd,
§fn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>
fn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self and other) and is used by the <=
operator. 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,
impl<I, T> Copy for IndexSlice<I, T>
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> !Send for IndexSlice<I, T>
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§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<I, C> CompactStringExt for C
impl<I, C> CompactStringExt for C
§fn concat_compact(&self) -> CompactString
fn concat_compact(&self) -> CompactString
CompactString] Read more§fn join_compact<S>(&self, seperator: S) -> CompactString
fn join_compact<S>(&self, seperator: S) -> CompactString
CompactString] Read more§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key and return true if they are equal.§impl<D> OwoColorize for D
impl<D> OwoColorize for D
§fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>where
C: Color,
fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>where
C: Color,
§fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>where
C: Color,
fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>where
C: Color,
§fn on_yellow<'a>(&'a self) -> BgColorDisplay<'a, Yellow, Self>
fn on_yellow<'a>(&'a self) -> BgColorDisplay<'a, Yellow, Self>
§fn magenta<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
fn magenta<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>
§fn on_magenta<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
fn on_magenta<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
§fn on_purple<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
fn on_purple<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>
§fn default_color<'a>(&'a self) -> FgColorDisplay<'a, Default, Self>
fn default_color<'a>(&'a self) -> FgColorDisplay<'a, Default, Self>
§fn on_default_color<'a>(&'a self) -> BgColorDisplay<'a, Default, Self>
fn on_default_color<'a>(&'a self) -> BgColorDisplay<'a, Default, Self>
§fn bright_black<'a>(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>
fn bright_black<'a>(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>
§fn on_bright_black<'a>(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>
fn on_bright_black<'a>(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>
§fn bright_red<'a>(&'a self) -> FgColorDisplay<'a, BrightRed, Self>
fn bright_red<'a>(&'a self) -> FgColorDisplay<'a, BrightRed, Self>
§fn on_bright_red<'a>(&'a self) -> BgColorDisplay<'a, BrightRed, Self>
fn on_bright_red<'a>(&'a self) -> BgColorDisplay<'a, BrightRed, Self>
§fn bright_green<'a>(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>
fn bright_green<'a>(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>
§fn on_bright_green<'a>(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>
fn on_bright_green<'a>(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>
§fn bright_yellow<'a>(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>
fn bright_yellow<'a>(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>
§fn on_bright_yellow<'a>(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>
fn on_bright_yellow<'a>(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>
§fn bright_blue<'a>(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>
fn bright_blue<'a>(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>
§fn on_bright_blue<'a>(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>
fn on_bright_blue<'a>(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>
§fn bright_magenta<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
fn bright_magenta<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
§fn on_bright_magenta<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
fn on_bright_magenta<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
§fn bright_purple<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
fn bright_purple<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>
§fn on_bright_purple<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
fn on_bright_purple<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>
§fn bright_cyan<'a>(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>
fn bright_cyan<'a>(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>
§fn on_bright_cyan<'a>(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>
fn on_bright_cyan<'a>(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>
§fn bright_white<'a>(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>
fn bright_white<'a>(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>
§fn on_bright_white<'a>(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>
fn on_bright_white<'a>(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>
§fn blink_fast<'a>(&'a self) -> BlinkFastDisplay<'a, Self>
fn blink_fast<'a>(&'a self) -> BlinkFastDisplay<'a, Self>
§fn strikethrough<'a>(&'a self) -> StrikeThroughDisplay<'a, Self>
fn strikethrough<'a>(&'a self) -> StrikeThroughDisplay<'a, Self>
§fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
OwoColorize::fg or
a color-specific method, such as OwoColorize::green, Read more§fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>where
Color: DynColor,
OwoColorize::bg or
a color-specific method, such as OwoColorize::on_yellow, Read more