[−][src]Struct abi_stable::std_types::RVec
Ffi-safe equivalent of std::vec::Vec
.
Example
Here is a function that partitions numbers by whether they are even or odd.
use abi_stable::{ std_types::{RSlice,RVec}, StableAbi, sabi_extern_fn, }; #[repr(C)] #[derive(StableAbi)] pub struct Partitioned{ pub even:RVec<u32>, pub odd :RVec<u32>, } #[sabi_extern_fn] pub fn partition_evenness(numbers:RSlice<'_,u32>)->Partitioned{ let (even,odd)=numbers.iter().cloned().partition(|n| *n % 2 == 0); Partitioned{even,odd} }
Methods
impl<T> RVec<T>
[src]
pub const fn capacity(&self) -> usize
[src]
This returns the ammount of elements this RVec can store without reallocating.
Example
use abi_stable::std_types::RVec; let mut list=RVec::new(); assert_eq!(list.capacity(),0); list.push(0); assert_ne!(list.capacity(),0);
pub const fn as_ptr(&self) -> *const T
[src]
Gets a raw pointer to the start of this RVec's buffer.
pub const fn new() -> Self
[src]
Creates a new,empty RVec<T>
.
This function does not allocate.
Example
use abi_stable::std_types::RVec; let list=RVec::<u32>::new();
impl<T> RVec<T>
[src]
pub fn with_capacity(cap: usize) -> Self
[src]
Creates a new,empty RVec<T>
,with a capacity of cap
.
This function does not allocate if cap
==0.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u32>::with_capacity(7); assert_eq!(list.len(),0); assert_eq!(list.capacity(),7); list.extend( std::iter::repeat(11).take(7) ); assert_eq!(list.len(),7); assert_eq!(list.capacity(),7); list.push(17); assert_ne!(list.capacity(),7);
pub fn slice<'a, I>(&'a self, range: I) -> RSlice<'a, T> where
[T]: Index<I, Output = [T]>,
[src]
[T]: Index<I, Output = [T]>,
Creates an RSlice<'a,T>
with access to the range
range of
elements of the RVec<T>
.
Example
use abi_stable::std_types::{RSlice,RVec}; let list=RVec::from(vec![0,1,2,3,4,5,6,7,8]); assert_eq!( list.slice(..), RSlice::from_slice(&[0,1,2,3,4,5,6,7,8]) ); assert_eq!( list.slice(..4), RSlice::from_slice(&[0,1,2,3]) ); assert_eq!( list.slice(4..), RSlice::from_slice(&[4,5,6,7,8]) ); assert_eq!( list.slice(4..7), RSlice::from_slice(&[4,5,6]) );
pub fn slice_mut<'a, I>(&'a mut self, i: I) -> RSliceMut<'a, T> where
[T]: IndexMut<I, Output = [T]>,
[src]
[T]: IndexMut<I, Output = [T]>,
Creates an RSliceMut<'a,T>
with access to the range
range of
elements of the RVec<T>
.
Example
use abi_stable::std_types::{RSliceMut,RVec}; let mut list=RVec::from(vec![0,1,2,3,4,5,6,7,8]); assert_eq!( list.slice_mut(..), RSliceMut::from_mut_slice(&mut [0,1,2,3,4,5,6,7,8]) ); assert_eq!( list.slice_mut(..4), RSliceMut::from_mut_slice(&mut [0,1,2,3]) ); assert_eq!( list.slice_mut(4..), RSliceMut::from_mut_slice(&mut [4,5,6,7,8]) ); assert_eq!( list.slice_mut(4..7), RSliceMut::from_mut_slice(&mut [4,5,6]) );
pub fn as_slice(&self) -> &[T]
[src]
Creates a &[T]
with access to all the elements of the RVec<T>
.
Example
use abi_stable::std_types::RVec; let list=RVec::from(vec![0,1,2,3]); assert_eq!(list.as_slice(), &[0,1,2,3]);
pub fn as_mut_slice(&mut self) -> &mut [T]
[src]
Creates a &mut [T]
with access to all the elements of the RVec<T>
.
Example
use abi_stable::std_types::RVec; let mut list=RVec::from(vec![0,1,2,3]); assert_eq!(list.as_mut_slice(), &mut [0,1,2,3]);
pub const fn as_rslice(&self) -> RSlice<T>
[src]
Creates an RSlice<'_,T>
with access to all the elements of the RVec<T>
.
Example
use abi_stable::std_types::{RSlice,RVec}; let list=RVec::from(vec![0,1,2,3]); assert_eq!(list.as_rslice(), RSlice::from_slice(&[0,1,2,3]));
pub fn as_mut_rslice(&mut self) -> RSliceMut<T>
[src]
Creates an RSliceMut<'_,T>
with access to all the elements of the RVec<T>
.
Example
use abi_stable::std_types::{RSliceMut,RVec}; let mut list=RVec::from(vec![0,1,2,3]); assert_eq!(list.as_mut_rslice(), RSliceMut::from_mut_slice(&mut [0,1,2,3]));
pub const fn len(&self) -> usize
[src]
Returns the ammount of elements of the RVec<T>
.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u64>::new(); assert_eq!(list.len(),0); list.push(0xDEAFBEEF); assert_eq!(list.len(),1); list.push(0xCAFE); assert_eq!(list.len(),2);
pub unsafe fn set_len(&mut self, new_len: usize)
[src]
Sets the length field of RVec<T>
to new_len
.
Safety
new_len
must be less than or equal to self.capacity()
.
The elements at old_len..new_len must be initialized.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u64>::new(); list.reserve_exact(10); unsafe{ let start=list.as_mut_ptr(); for i in 0..10 { start.add(i as usize).write(i); } list.set_len(10); } assert_eq!( list, (0..10).collect::<RVec<u64>>() );
pub fn shrink_to_fit(&mut self)
[src]
Shrinks the capacity of the RString to match its length.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u32>::with_capacity(7); list.extend( std::iter::repeat(11).take(4) ); assert_eq!(list.len(),4); assert_eq!(list.capacity(),7); list.shrink_to_fit(); assert_eq!(list.len(),4); assert_eq!(list.capacity(),4);
pub const fn is_empty(&self) -> bool
[src]
Whether the length of the RVec<T>
is 0.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u64>::new(); assert_eq!(list.is_empty(),true); list.push(0x1337); assert_eq!(list.is_empty(),false); list.push(0xC001); assert_eq!(list.is_empty(),false);
pub fn into_vec(self) -> Vec<T>
[src]
Returns a Vec<T>
,consuming self
.
Allocation
If this is invoked outside of the dynamic library/binary that created it,
it will allocate a new Vec<T>
and move the data into it.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u64>::new(); list.push(0); list.push(1); list.push(2); assert_eq!(list.into_vec(), vec![0,1,2]);
pub fn to_vec(&self) -> Vec<T> where
T: Clone,
[src]
T: Clone,
Creates a Vec<T>
,copying all the elements of this RVec<T>
.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u64>::new(); list.extend( (4..=7).rev() ); assert_eq!(list.to_vec(), vec![7,6,5,4] );
pub fn from_slice(slic: &[T]) -> RVec<T> where
T: Clone,
[src]
T: Clone,
Clones a &[T]
into a new RVec.
This function was defined to aid type inference,
because eg:&[0,1]
is a &[i32;2]
not a &[i32]
.
Example
use abi_stable::std_types::RVec; let slic=&[99,88,77,66]; let list=RVec::<u64>::from_slice(slic); assert_eq!(list.as_slice(),slic);
pub fn insert(&mut self, index: usize, value: T)
[src]
Inserts the value
value at index
position.
Panics
Panics if self.len() < index.
Example
use abi_stable::std_types::RVec; let mut list=RVec::from(vec![0,1,2,3]); list.insert(2,22); assert_eq!(list.as_slice(),&[0,1,22,2,3]); list.insert(5,55); assert_eq!(list.as_slice(),&[0,1,22,2,3,55]);
pub fn try_remove(&mut self, index: usize) -> Option<T>
[src]
Attemps to remove the element at index
position,
returns None if self.len() <= index.
Example
use abi_stable::std_types::RVec; let mut list=RVec::from(vec![0,1,2,3]); assert_eq!(list.try_remove(4),None); assert_eq!(list.try_remove(3),Some(3)); assert_eq!(list.try_remove(1),Some(1)); assert_eq!(list.as_slice(), &[0,2]);
pub fn remove(&mut self, index: usize) -> T
[src]
Removes the element at index
position,
Panic
Panics if self.len() <= index.
Example
use abi_stable::{ std_types::{RStr,RVec}, traits::IntoReprC, }; // This type annotation is purely for the reader. let mut list:RVec<RStr<'static>>= vec!["foo".into_c(), "bar".into(), "baz".into()].into_c(); assert_eq!( list.remove(2), "baz".into_c() ); assert_eq!(list.as_slice(), &["foo".into_c(), "bar".into_c()] ); assert_eq!( list.remove(0), "foo".into_c() ); assert_eq!(list.as_slice(), &["bar".into_c()] );
pub fn swap_remove(&mut self, index: usize) -> T
[src]
Swaps the element at index
position with the last element,and then removes it.
Panic
Panics if self.len() <= index.
Example
use abi_stable::{ std_types::{RStr,RVec}, traits::IntoReprC, }; // This type annotation is purely for the reader. let mut list:RVec<RStr<'static>>= vec!["foo".into_c(), "bar".into(), "baz".into(), "geo".into()].into_c(); assert_eq!( list.swap_remove(1), "bar".into_c() ); assert_eq!( list.as_slice(), &["foo".into_c(), "geo".into(), "baz".into()] ); assert_eq!( list.swap_remove(0), "foo".into_c() ); assert_eq!( list.as_slice(), &["baz".into(), "geo".into()] );
pub fn push(&mut self, new_val: T)
[src]
Appends new_val
at the end of the RVec<T>
.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u32>::new(); list.push(11); assert_eq!(list.as_slice(), &[11]); list.push(22); assert_eq!(list.as_slice(), &[11,22]); list.push(55); assert_eq!(list.as_slice(), &[11,22,55]);
pub fn pop(&mut self) -> Option<T>
[src]
Attempts to remove the last element,
returns None if the RVec<T>
is empty.
Example
use abi_stable::std_types::{RSlice,RVec}; let mut list=RVec::<u32>::from_slice(&[11,22,55]); assert_eq!(list.pop(), Some(55)); assert_eq!(list.as_slice(), &[11,22]); assert_eq!(list.pop(), Some(22)); assert_eq!(list.as_slice(), &[11]); assert_eq!(list.pop(), Some(11)); assert_eq!(list.as_rslice(), RSlice::<u32>::EMPTY ); assert_eq!(list.pop(), None);
pub fn truncate(&mut self, to: usize)
[src]
Truncates the RVec<T>
to to
length.
Does nothing if self.len() <= to.
Note:this has no effect on the capacity of the RVec<T>
.
Example
use abi_stable::std_types::{RSlice,RVec}; let mut list=RVec::<u32>::from_slice(&[11,22,55,66,77]); list.truncate(3); assert_eq!(list.as_slice(), &[11,22,55] ); list.truncate(0); assert_eq!(list.as_rslice(), RSlice::<u32>::EMPTY ); list.truncate(5555); //This is a no-op.
pub fn clear(&mut self)
[src]
Removes all the elements from collection.
Note:this has no effect on the capacity of the RVec<T>
.
Example
use abi_stable::std_types::{RSlice,RVec}; let mut list=RVec::<u32>::from_slice(&[11,22,55]); assert_eq!( list.as_slice(), &[11,22,55] ); list.clear(); assert_eq!( list.as_rslice(), RSlice::<u32>::EMPTY ); assert_ne!( list.capacity(), 0 );
pub fn retain<F>(&mut self, pred: F) where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Retains only the elements that satisfy the pred
predicate
This means that a element will be removed if pred(that_element)
returns false.
Example
use abi_stable::std_types::RVec; { let mut list=(0..=10).collect::<Vec<u32>>(); list.retain(|x| *x%3 ==0 ); assert_eq!(list.as_slice(), &[0,3,6,9]); } { let mut list=(0..=10).collect::<Vec<u32>>(); list.retain(|x| *x%5 ==0 ); assert_eq!(list.as_slice(), &[0,5,10]); }
pub fn reserve(&mut self, additional: usize)
[src]
Reserves àdditional
additional capacity for extra elements.
This may reserve more than necessary for the additional capacity.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u32>::new(); list.reserve(10); assert!( list.capacity()>=10 ); let cap=list.capacity(); list.extend(0..10); assert_eq!( list.capacity(),cap );
pub fn reserve_exact(&mut self, additional: usize)
[src]
Reserves àdditional
additional capacity for extra elements.
Prefer using reserve
for most situations.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u32>::new(); list.reserve_exact(17); assert_eq!( list.capacity(),17 ); let cap=list.capacity(); list.extend(0..17); assert_eq!( list.capacity(),cap );
impl<T> RVec<T> where
T: Clone,
[src]
T: Clone,
pub fn resize(&mut self, new_len: usize, value: T)
[src]
Resizes the RVec<T>
to new_len
length.
if new_len is larger than the current length,
the RVec<T>
is extended with clones of value
to reach the new length.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u32>::new(); list.resize(5,88); assert_eq!( list.as_slice(), &[88,88,88,88,88] ); list.resize(3,0); assert_eq!( list.as_slice(), &[88,88,88] ); list.resize(6,123); assert_eq!( list.as_slice(), &[88,88,88,123,123,123] );
pub fn extend_from_slice(&mut self, slic_: &[T])
[src]
Extends this RVec<_>
with clones of the elements of the slice.
Example
use abi_stable::std_types::RVec; let mut list=RVec::<u64>::new(); list.extend_from_slice(&[99,88]); list.extend_from_slice(&[77,66]); assert_eq!( list.as_slice(), &[99,88,77,66] );
impl<T> RVec<T> where
T: Copy,
[src]
T: Copy,
pub fn extend_from_copy_slice(&mut self, slic_: &[T])
[src]
Extends this RVec<_>
with copies of the elements of the slice.
Example
use abi_stable::{ std_types::{RStr,RVec}, traits::IntoReprC, }; let mut list=RVec::<RStr<'_>>::new(); list.extend_from_slice(&["foo".into_c(), "bar".into()]); list.extend_from_slice(&["baz".into_c(), "goo".into()]); assert_eq!( list.as_slice(), &["foo".into_c(), "bar".into(), "baz".into(), "goo".into()], );
impl<T> RVec<T>
[src]
ⓘImportant traits for Drain<'a, T>pub fn drain<'a, I>(&'a mut self, index: I) -> Drain<'a, T> where
[T]: IndexMut<I, Output = [T]>,
[src]
[T]: IndexMut<I, Output = [T]>,
Creates a draining iterator that removes the specified range in
the RVec<T>
and yields the removed items.
Panic
Panics if the index is out of bounds or if the start of the range is greater than the end of the range.
Consumption
The elements in the range will be removed even if the iterator was dropped before yielding them.
Example
use abi_stable::std_types::{RSlice,RVec}; { let mut list=RVec::from(vec![0,1,2,3,4,5]); assert_eq!( list.drain(2..4).collect::<Vec<_>>(), vec![2,3] ); assert_eq!( list.as_slice(), &[0,1,4,5] ); } { let mut list=RVec::from(vec![0,1,2,3,4,5]); assert_eq!( list.drain(2..).collect::<Vec<_>>(), vec![2,3,4,5] ); assert_eq!( list.as_slice(), &[0,1] ); } { let mut list=RVec::from(vec![0,1,2,3,4,5]); assert_eq!( list.drain(..2).collect::<Vec<_>>(), vec![0,1] ); assert_eq!( list.as_slice(), &[2,3,4,5] ); } { let mut list=RVec::from(vec![0,1,2,3,4,5]); assert_eq!( list.drain(..).collect::<Vec<_>>(), vec![0,1,2,3,4,5] ); assert_eq!( list.as_rslice(), RSlice::<u32>::EMPTY ); }
Trait Implementations
impl<T> IntoReprRust for RVec<T>
[src]
impl<T> GetStaticEquivalent_ for RVec<T> where
T: __StableAbi,
[src]
T: __StableAbi,
type StaticEquivalent = _static_RVec<__GetStaticEquivalent<T>>
impl<T> SharedStableAbi for RVec<T> where
T: __StableAbi,
[src]
T: __StableAbi,
type IsNonZeroType = False
Whether this type has a single invalid bit-pattern. Read more
type Kind = __ValueKind
The kind of abi stability of this type,there are 2: Read more
const S_LAYOUT: &'static TypeLayout
[src]
const S_ABI_CONSTS: AbiConsts
[src]
impl<T> Send for RVec<T> where
T: Send,
[src]
T: Send,
impl<T> Sync for RVec<T> where
T: Sync,
[src]
T: Sync,
impl<T> Drop for RVec<T>
[src]
impl<T> AsRef<[T]> for RVec<T>
[src]
impl<T> AsMut<[T]> for RVec<T>
[src]
impl<T> Into<Vec<T>> for RVec<T>
[src]
impl<'a, T> From<RVec<T>> for RCow<'a, [T]> where
T: Clone,
[src]
T: Clone,
impl<T> From<Vec<T>> for RVec<T>
[src]
impl<'a, T> From<&'a [T]> for RVec<T> where
T: Clone,
[src]
T: Clone,
impl<'a, T> From<Cow<'a, [T]>> for RVec<T> where
T: Clone,
[src]
T: Clone,
impl<T> Extend<T> for RVec<T>
[src]
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T> IntoIterator for RVec<T>
[src]
type Item = T
The type of the elements being iterated over.
type IntoIter = IntoIter<T>
Which kind of iterator are we turning this into?
ⓘImportant traits for IntoIter<T>fn into_iter(self) -> IntoIter<T>
[src]
impl<'a, T> IntoIterator for &'a RVec<T>
[src]
type Item = &'a T
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<'a, T> IntoIterator for &'a mut RVec<T>
[src]
type Item = &'a mut T
The type of the elements being iterated over.
type IntoIter = IterMut<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<T> Clone for RVec<T> where
T: Clone,
[src]
T: Clone,
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T> Default for RVec<T>
[src]
impl<T> Eq for RVec<T> where
T: Eq,
[src]
T: Eq,
impl<T> Ord for RVec<T> where
T: Ord,
[src]
T: Ord,
fn cmp(&self, other: &Self) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T> PartialEq<RVec<T>> for RVec<T> where
T: PartialEq,
[src]
T: PartialEq,
impl<T> PartialOrd<RVec<T>> for RVec<T> where
T: PartialOrd,
[src]
T: PartialOrd,
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T> Debug for RVec<T> where
T: Debug,
[src]
T: Debug,
impl<T> Deref for RVec<T>
[src]
impl<T> DerefMut for RVec<T>
[src]
impl<T> Hash for RVec<T> where
T: Hash,
[src]
T: Hash,
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T> FromIterator<T> for RVec<T>
[src]
fn from_iter<I>(iter: I) -> Self where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T> Borrow<[T]> for RVec<T>
[src]
impl<T> BorrowMut<[T]> for RVec<T>
[src]
fn borrow_mut(&mut self) -> &mut [T]
[src]
impl Write for RVec<u8>
[src]
fn write(&mut self, buf: &[u8]) -> Result<usize>
[src]
fn write_all(&mut self, buf: &[u8]) -> Result<()>
[src]
fn flush(&mut self) -> Result<()>
[src]
fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>
1.36.0[src]
fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>
1.0.0[src]
fn by_ref(&mut self) -> &mut Self
1.0.0[src]
impl<'de, T> Deserialize<'de> for RVec<T> where
T: Deserialize<'de>,
[src]
T: Deserialize<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl<T> Serialize for RVec<T> where
T: Serialize,
[src]
T: Serialize,
Auto Trait Implementations
impl<T> Unpin for RVec<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for RVec<T> where
T: RefUnwindSafe + UnwindSafe,
T: RefUnwindSafe + UnwindSafe,
impl<T> RefUnwindSafe for RVec<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
impl<This> GetConstGenericVTable for This where
This: StableAbi + Eq + PartialEq<This> + Debug + Send + Sync,
[src]
This: StableAbi + Eq + PartialEq<This> + Debug + Send + Sync,
const VTABLE: ConstGenericVTableFor<This>
[src]
impl<This> StableAbi for This where
This: SharedStableAbi<Kind = ValueKind>,
[src]
This: SharedStableAbi<Kind = ValueKind>,
const LAYOUT: &'static TypeLayout
[src]
const ABI_CONSTS: AbiConsts
[src]
impl<This> TransmuteElement for This where
This: ?Sized,
[src]
This: ?Sized,
unsafe fn transmute_element<T>(self) -> Self::TransmutedPtr where
Self: CanTransmuteElement<T>,
Self::Target: Sized,
[src]
Self: CanTransmuteElement<T>,
Self::Target: Sized,
impl<'a, T> BorrowOwned<'a> for T where
T: 'a + Clone,
[src]
T: 'a + Clone,
type ROwned = T
type RBorrowed = &'a T
fn r_borrow(
&'a <T as BorrowOwned<'a>>::ROwned
) -> <T as BorrowOwned<'a>>::RBorrowed
[src]
&'a <T as BorrowOwned<'a>>::ROwned
) -> <T as BorrowOwned<'a>>::RBorrowed
fn r_to_owned(
<T as BorrowOwned<'a>>::RBorrowed
) -> <T as BorrowOwned<'a>>::ROwned
[src]
<T as BorrowOwned<'a>>::RBorrowed
) -> <T as BorrowOwned<'a>>::ROwned
fn deref_borrowed(&<T as BorrowOwned<'a>>::RBorrowed) -> &T
[src]
fn deref_owned(&<T as BorrowOwned<'a>>::ROwned) -> &T
[src]
fn from_cow_borrow(&'a T) -> <T as BorrowOwned<'a>>::RBorrowed
[src]
fn from_cow_owned(<T as ToOwned>::Owned) -> <T as BorrowOwned<'a>>::ROwned
[src]
fn into_cow_borrow(<T as BorrowOwned<'a>>::RBorrowed) -> &'a T
[src]
fn into_cow_owned(<T as BorrowOwned<'a>>::ROwned) -> <T as ToOwned>::Owned
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> TypeIdentity for T where
T: ?Sized,
[src]
T: ?Sized,
type Type = T
The same type as Self. Read more
fn into_type_val(self) -> Self::Type where
Self::Type: Sized,
[src]
Self::Type: Sized,
fn into_type_ref(&self) -> &Self::Type
[src]
fn into_type_mut(&mut self) -> &mut Self::Type
[src]
fn into_type_box(self: Box<Self>) -> Box<Self::Type>
[src]
fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>
[src]
fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>
[src]
fn from_type_val(this: Self::Type) -> Self where
Self::Type: Sized,
[src]
Self::Type: Sized,
fn from_type_ref(this: &Self::Type) -> &Self
[src]
fn from_type_mut(this: &mut Self::Type) -> &mut Self
[src]
fn from_type_box(this: Box<Self::Type>) -> Box<Self>
[src]
fn from_type_arc(this: Arc<Self::Type>) -> Arc<Self>
[src]
fn from_type_rc(this: Rc<Self::Type>) -> Rc<Self>
[src]
impl<T> SelfOps for T where
T: ?Sized,
[src]
T: ?Sized,
const T: PhantomData<fn() -> Self>
[src]
const T_D: PhantomData<Self>
[src]
fn assert_ty(self, _other: PhantomData<fn() -> Self>) -> Self
[src]
fn assert_ty_ref(&self, _other: PhantomData<fn() -> Self>) -> &Self
[src]
fn assert_ty_mut(&mut self, _other: PhantomData<fn() -> Self>) -> &mut Self
[src]
fn ty_(&self) -> PhantomData<fn() -> Self>
[src]
fn ty_d(&self) -> PhantomData<Self>
[src]
fn ty_inv(&self) -> PhantomData<fn(Self) -> Self>
[src]
fn ty_inv_ref(&self) -> PhantomData<Cell<&Self>>
[src]
fn eq_id(&self, other: &Self) -> bool
[src]
fn piped<F, U>(self, f: F) -> U where
F: FnOnce(Self) -> U,
[src]
F: FnOnce(Self) -> U,
fn piped_ref<'a, F, U>(&'a self, f: F) -> U where
F: FnOnce(&'a Self) -> U,
[src]
F: FnOnce(&'a Self) -> U,
fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U where
F: FnOnce(&'a mut Self) -> U,
[src]
F: FnOnce(&'a mut Self) -> U,
fn mutated<F>(self, f: F) -> Self where
F: FnOnce(&mut Self),
[src]
F: FnOnce(&mut Self),
fn observe<F>(self, f: F) -> Self where
F: FnOnce(&Self),
[src]
F: FnOnce(&Self),
fn into_<T>(self, PhantomData<fn() -> T>) -> T where
Self: Into<T>,
[src]
Self: Into<T>,
fn as_ref_<T>(&self) -> &T where
Self: AsRef<T>,
T: ?Sized,
[src]
Self: AsRef<T>,
T: ?Sized,
fn as_mut_<T>(&mut self) -> &mut T where
Self: AsMut<T>,
T: ?Sized,
[src]
Self: AsMut<T>,
T: ?Sized,
fn drop_(self)
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The error type returned when the conversion fails.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
T: Deserialize<'de>,