Struct abi_stable::std_types::RVec

#[repr(C)]
pub struct RVec<T> { /* fields omitted */ }

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}
}

Implementations

impl<T> RVec<T>

pub const fn new() -> Self

Creates a new,empty RVec<T>.

This function does not allocate.

Example

use abi_stable::std_types::RVec;

let list=RVec::<u32>::new();

pub const fn capacity(&self) -> usize

This returns the amount 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

Gets a raw pointer to the start of this RVec’s buffer.

pub fn as_mut_ptr(&mut self) -> *mut T

Gets a mutable raw pointer to the start of this RVec’s buffer.

impl<T> RVec<T>

pub fn with_capacity(cap: usize) -> Self

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]>, 

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]>, 

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]

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]

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>

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>

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

Returns the amount 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)

Sets the length field of RVec<T> to new_len.

Safety

new_len must be less than or equal to self.capacity().

The elements betweem the old length and the new length 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)

Shrinks the capacity of the RVec 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

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>

Converts this RVec<T> into a Vec<T>.

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, 

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, 

Clones a &[T] into a new RVec<T>.

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)

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>

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

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

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".to_string(), "geo".into()] );

pub fn push(&mut self, new_val: T)

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>

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)

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)

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, 

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)

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)

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, 

pub fn resize(&mut self, new_len: usize, value: T)

Resizes the RVec<T> to new_len length. extending the RVec<T> 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])

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, 

pub fn extend_from_copy_slice(&mut self, slic_: &[T])

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>

pub fn drain<I>(&mut self, index: I) -> Drain<'_, T> where
    [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> AsMut<[T]> for RVec<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T> AsRef<[T]> for RVec<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> Borrow<[T]> for RVec<T>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T> BorrowMut<[T]> for RVec<T>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<T> Clone for RVec<T> where
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for RVec<T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for RVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for RVec<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for RVec<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T> Deserialize<'de> for RVec<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Drop for RVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Extend<T> for RVec<T>

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, T> From<&'a [T]> for RVec<T> where
    T: Clone, 

fn from(this: &'a [T]) -> Self

Performs the conversion.

impl<'a, T> From<Cow<'a, [T]>> for RVec<T> where
    T: Clone, 

fn from(this: Cow<'a, [T]>) -> Self

Performs the conversion.

impl<'a, T> From<RVec<T>> for RCow<'a, [T]> where
    T: Clone, 

fn from(this: RVec<T>) -> Self

Performs the conversion.

impl<T> From<Vec<T, Global>> for RVec<T>

fn from(this: Vec<T>) -> RVec<T>

Performs the conversion.

impl<T> FromIterator<T> for RVec<T>

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = T>, 

Creates a value from an iterator.

impl<T> GetStaticEquivalent_ for RVec<T> where
    T: __StableAbi, 

type StaticEquivalent = _static_RVec<__GetStaticEquivalent<T>>

impl<T> Hash for RVec<T> where
    T: Hash, 

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T> Into<Vec<T, Global>> for RVec<T>

fn into(self) -> Vec<T>

Performs the conversion.

impl<T> IntoIterator for RVec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a RVec<T>

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

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut RVec<T>

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

Creates an iterator from a value.

impl<T> IntoReprRust for RVec<T>

type ReprRust = Vec<T>

The #[repr(Rust)] equivalent.

fn into_rust(self) -> Self::ReprRust

Performs the conversion

impl<T> Ord for RVec<T> where
    T: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PartialEq<U>, U> PartialEq<&'_ [U]> for RVec<T>

fn eq(&self, other: &&[U]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq<U>, U, const N: usize> PartialEq<[U; N]> for RVec<T>

fn eq(&self, other: &[U; N]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq<U>, U> PartialEq<[U]> for RVec<T>

fn eq(&self, other: &[U]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq<U>, U> PartialEq<Cow<'_, [U]>> for RVec<T> where
    T: Clone,
    U: Clone, 

fn eq(&self, other: &Cow<'_, [U]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq<U>, U> PartialEq<RCow<'_, [U]>> for RVec<T> where
    T: Clone,
    U: Clone, 

fn eq(&self, other: &RCow<'_, [U]>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq<U>, U> PartialEq<RSlice<'_, U>> for RVec<T>

fn eq(&self, other: &RSlice<'_, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq<U>, U> PartialEq<RSliceMut<'_, U>> for RVec<T>

fn eq(&self, other: &RSliceMut<'_, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T> PartialEq<RVec<T>> for Vec<U>

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T> PartialEq<RVec<T>> for [U]

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T> PartialEq<RVec<T>> for &[U]

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T> PartialEq<RVec<T>> for RSlice<'_, U>

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T> PartialEq<RVec<T>> for RSliceMut<'_, U>

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T, const N: usize> PartialEq<RVec<T>> for [U; N]

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T> PartialEq<RVec<T>> for Cow<'_, [U]> where
    T: Clone,
    U: Clone, 

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<U: PartialEq<T>, T> PartialEq<RVec<T>> for RCow<'_, [U]> where
    T: Clone,
    U: Clone, 

fn eq(&self, other: &RVec<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> PartialEq<RVec<T>> for RVec<T> where
    T: PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq<U>, U> PartialEq<Vec<U, Global>> for RVec<T>

fn eq(&self, other: &Vec<U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, U> PartialOrd<&'_ [U]> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>, 

fn partial_cmp(&self, other: &&[U]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U, const N: usize> PartialOrd<[U; N]> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>, 

fn partial_cmp(&self, other: &[U; N]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<[U]> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>, 

fn partial_cmp(&self, other: &[U]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<Cow<'_, [U]>> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>,
    T: Clone,
    U: Clone, 

fn partial_cmp(&self, other: &Cow<'_, [U]>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<RCow<'_, [U]>> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>,
    T: Clone,
    U: Clone, 

fn partial_cmp(&self, other: &RCow<'_, [U]>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<RSlice<'_, U>> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>, 

fn partial_cmp(&self, other: &RSlice<'_, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<RSliceMut<'_, U>> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>, 

fn partial_cmp(&self, other: &RSliceMut<'_, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T> PartialOrd<RVec<T>> for Vec<U> where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T> PartialOrd<RVec<T>> for [U] where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T> PartialOrd<RVec<T>> for &[U] where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T> PartialOrd<RVec<T>> for RSlice<'_, U> where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T> PartialOrd<RVec<T>> for RSliceMut<'_, U> where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T, const N: usize> PartialOrd<RVec<T>> for [U; N] where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T> PartialOrd<RVec<T>> for Cow<'_, [U]> where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>,
    T: Clone,
    U: Clone, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<U, T> PartialOrd<RVec<T>> for RCow<'_, [U]> where
    U: PartialOrd<T>,
    [U]: PartialOrd<[T]>,
    T: Clone,
    U: Clone, 

fn partial_cmp(&self, other: &RVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> PartialOrd<RVec<T>> for RVec<T> where
    T: PartialOrd, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U> PartialOrd<Vec<U, Global>> for RVec<T> where
    T: PartialOrd<U>,
    [T]: PartialOrd<[U]>, 

fn partial_cmp(&self, other: &Vec<U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for RVec<T> where
    T: Serialize, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> StableAbi for RVec<T> where
    T: __StableAbi, 

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

impl Write for RVec<u8>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Write.

impl<T> Eq for RVec<T> where
    T: Eq, 

impl<T> Send for RVec<T> where
    T: Send, 

impl<T> Sync for RVec<T> where
    T: Sync,