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.

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".into(), "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>

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Immutably borrows from an owned value.

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

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

Mutably borrows from an owned value.

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

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T> Default for RVec<T>

pub fn default() -> Self

Returns the "default value" for a type.

impl<T> Deref for RVec<T>

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for RVec<T>

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

Mutably dereferences the value.

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

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

pub fn drop(&mut self)

Executes the destructor for this type.

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

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

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

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

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

Feeds this value into the given Hasher.

pub 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>> for RVec<T>

pub 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?

pub 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?

pub 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?

pub 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.

pub fn into_rust(self) -> Self::ReprRust

Performs the conversion

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

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

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

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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> Send for RVec<T> where
    T: Send, 

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

pub 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.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

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

impl Write for RVec<u8>

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

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

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

Attempts to write an entire buffer into this writer.

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

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

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

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

pub 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.

pub 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.

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

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

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

Creates a "by reference" adaptor for this instance of Write.