Struct otter_api_tests::IndexSlice [−]
#[repr(transparent)]pub struct IndexSlice<I, T> where
T: ?Sized,
I: Idx, { pub raw: T, // some fields omitted }
Expand description
A slice that only accepts indices of a specific type. Note that the intended
usage is as IndexSlice<I, [T]>
.
This is a thin wrapper around a [T]
, to the point where the backing is a
public property (called raw
). This is in part because I know this API is
not a complete mirror of Vec’s (patches welcome). In the worst case, you can
always do what you need to the slice itself.
Some notes on the APIs
-
Most of the Slice APIs are present.
- Any that aren’t can be trivially accessed on the underlying
raw
field, which is public.
- 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,
Construct a new IdxSlice by wrapping an existing slice.
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.
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.
Returns the underlying slice.
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
.
Get a iterator over reverences to our values.
See also IndexSlice::iter_enumerated
, which gives you indices (of the
correct type) as you iterate.
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.
Similar to self.iter().enumerate()
but with indices of I
and not
usize
.
Get an interator over all our indices.
Similar to self.iter_mut().enumerate()
but with indices of I
and not
usize
.
Forwards to the slice’s sort_by
implementation.
pub fn sort_by_key<F, K>(&mut self, f: F) where
K: Ord,
F: FnMut(&T) -> K,
pub fn sort_by_key<F, K>(&mut self, f: F) where
K: Ord,
F: FnMut(&T) -> K,
Forwards to the slice’s sort_by_key
implementation.
pub fn sort_by_cached_key<F, K>(&mut self, f: F) where
K: Ord,
F: FnMut(&T) -> K,
pub fn sort_by_cached_key<F, K>(&mut self, f: F) where
K: Ord,
F: FnMut(&T) -> K,
Forwards to the slice’s sort_by_cached_key
implementation.
pub fn sort_unstable(&mut self) where
T: Ord,
pub fn sort_unstable(&mut self) where
T: Ord,
Forwards to the slice’s sort_unstable
implementation.
pub fn sort_unstable_by<F>(&mut self, compare: F) where
F: FnMut(&T, &T) -> Ordering,
pub fn sort_unstable_by<F>(&mut self, compare: F) where
F: FnMut(&T, &T) -> Ordering,
Forwards to the slice’s sort_unstable_by
implementation.
pub fn sort_unstable_by_key<F, K>(&mut self, f: F) where
K: Ord,
F: FnMut(&T) -> K,
pub fn sort_unstable_by_key<F, K>(&mut self, f: F) where
K: Ord,
F: FnMut(&T) -> K,
Forwards to the slice’s sort_unstable_by_key
implementation.
Forwards to the slice’s ends_with
implementation.
Forwards to the slice’s starts_with
implementation.
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
.
Binary searches this sorted vec with a key extraction function, converting the indices it gives us back to our Idx type.
Searches for an element in an iterator, returning its index. This is
equivalent to Iterator::position
, but returns I
and not usize
.
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
T: Copy,
R: IdxRangeBounds<I>,
pub fn copy_within<R>(&mut self, src: R, dst: I) where
T: Copy,
R: IdxRangeBounds<I>,
Copies elements from one part of the slice to another part of itself, using a memmove.
pub fn get<J>(&self, index: J) -> Option<&<J as IdxSliceIndex<I, T>>::Output> where
J: IdxSliceIndex<I, T>,
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
Wraps the underlying slice’s windows
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s chunks
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s chunks_mut
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s chunks_exact
iterator with one that
yields IndexSlice
s with the correct index type.
Wraps the underlying slice’s chunks_exact_mut
iterator with one that
yields IndexSlice
s with the correct index type.
Wraps the underlying slice’s rchunks
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s rchunks_mut
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s rchunks_exact
iterator with one that
yields IndexSlice
s with the correct index type.
Wraps the underlying slice’s rchunks_exact_mut
iterator with one that
yields IndexSlice
s with the correct index type.
Wraps the underlying slice’s split
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s split_mut
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s rsplit
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s rsplit_mut
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s splitn
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s splitn_mut
iterator with one that yields
IndexSlice
s with the correct index type.
Wraps the underlying slice’s rsplitn
iterator with one that yields
IndexSlice
s with the correct index type.
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
pub fn as_mut(&mut self) -> &mut IndexSlice<I, [A]>
pub fn as_mut(&mut self) -> &mut IndexSlice<I, [A]>
Performs the conversion.
pub fn as_ref(&self) -> &IndexSlice<I, [A]>
pub fn as_ref(&self) -> &IndexSlice<I, [A]>
Performs the conversion.
pub fn borrow(&self) -> &IndexSlice<I, [T]>
pub fn borrow(&self) -> &IndexSlice<I, [T]>
Immutably borrows from an owned value. Read more
pub fn borrow_mut(&mut self) -> &mut IndexSlice<I, [T]>
pub fn borrow_mut(&mut self) -> &mut IndexSlice<I, [T]>
Mutably borrows from an owned value. Read more
pub fn clone(&self) -> IndexSlice<I, T>
pub fn clone(&self) -> IndexSlice<I, T>
Returns a copy of the value. Read more
Performs copy-assignment from source
. Read more
impl<I, T> Debug for IndexSlice<I, T> where
T: Debug + ?Sized,
I: Idx,
impl<I, T> Debug for IndexSlice<I, T> where
T: Debug + ?Sized,
I: Idx,
impl<'_, I, T> Default for &'_ IndexSlice<I, [T]> where
I: Idx,
impl<'_, I, T> Default for &'_ IndexSlice<I, [T]> where
I: Idx,
pub fn default() -> &'_ IndexSlice<I, [T]>
pub fn default() -> &'_ IndexSlice<I, [T]>
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,
pub fn default() -> &'_ mut IndexSlice<I, [T]>
pub fn default() -> &'_ mut IndexSlice<I, [T]>
Returns the “default value” for a type. Read more
pub fn from(a: &'a [T]) -> &'a IndexSlice<I, [T]>
pub fn from(a: &'a [T]) -> &'a IndexSlice<I, [T]>
Performs the conversion.
pub fn from(src: &'a IndexSlice<I, [T]>) -> IndexVec<I, T>
pub fn from(src: &'a IndexSlice<I, [T]>) -> IndexVec<I, T>
Performs the conversion.
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
impl<'a, I, T> From<&'a mut [T]> for &'a mut IndexSlice<I, [T]> where
I: Idx,
pub fn from(a: &'a mut [T]) -> &'a mut IndexSlice<I, [T]>
pub fn from(a: &'a mut [T]) -> &'a mut IndexSlice<I, [T]>
Performs the conversion.
pub fn from(src: &'a mut IndexSlice<I, [T]>) -> IndexVec<I, T>
pub fn from(src: &'a mut IndexSlice<I, [T]>) -> IndexVec<I, T>
Performs the conversion.
impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
R: IdxSliceIndex<I, T>,
I: Idx,
impl<I, R, T> Index<R> for IndexSlice<I, [T]> where
R: IdxSliceIndex<I, T>,
I: Idx,
type Output = <R as IdxSliceIndex<I, T>>::Output
type Output = <R as IdxSliceIndex<I, T>>::Output
The returned type after indexing.
pub fn index(&self, index: R) -> &<R as IdxSliceIndex<I, T>>::Output
pub fn index(&self, index: R) -> &<R as IdxSliceIndex<I, T>>::Output
Performs the indexing (container[index]
) operation. Read more
impl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
R: IdxSliceIndex<I, T>,
I: Idx,
impl<I, R, T> IndexMut<R> for IndexSlice<I, [T]> where
R: IdxSliceIndex<I, T>,
I: Idx,
pub fn index_mut(&mut self, index: R) -> &mut <R as IdxSliceIndex<I, T>>::Output
pub fn index_mut(&mut self, index: R) -> &mut <R as IdxSliceIndex<I, T>>::Output
Performs the mutable indexing (container[index]
) operation. Read more
impl<'a, I, T> IntoIterator for &'a 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<'a, 'b, A, B, I, J> PartialEq<&'a IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
J: Idx,
impl<'a, 'b, A, B, I, J> PartialEq<&'a IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
J: Idx,
impl<'a, 'b, A, B, I, J> PartialEq<&'a mut IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
J: Idx,
impl<'a, 'b, A, B, I, J> PartialEq<&'a mut IndexSlice<J, [B]>> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
J: Idx,
impl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
impl<'a, 'b, A, B, I> PartialEq<&'b mut [B]> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
pub fn eq(&self, other: &&'b mut [B]) -> bool
pub fn eq(&self, other: &&'b mut [B]) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
pub fn ne(&self, other: &&'b mut [B]) -> bool
pub fn ne(&self, other: &&'b mut [B]) -> bool
This method tests for !=
.
impl<I, A, B> PartialEq<IndexSlice<I, [B]>> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
impl<I, A, B> PartialEq<IndexSlice<I, [B]>> for IndexSlice<I, [A]> where
A: PartialEq<B>,
I: Idx,
impl<I, T> PartialOrd<IndexSlice<I, [T]>> for IndexSlice<I, [T]> where
T: PartialOrd<T>,
I: Idx,
impl<I, T> PartialOrd<IndexSlice<I, [T]>> for IndexSlice<I, [T]> where
T: PartialOrd<T>,
I: Idx,
pub fn partial_cmp(&self, other: &IndexSlice<I, [T]>) -> Option<Ordering>
pub 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
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
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
Mutably borrows from an owned value. Read more
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;
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
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub 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
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub 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
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
Use this to cast from one trait object type to another. Read more
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
Use this to upcast a trait to one of its supertraits. Read more
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
pub 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>,
pub 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
Compare self to key
and return true
if they are equal.
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;
[src]
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;
[src]Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
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;
[src]
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;
[src]pub fn vzip(self) -> V