Struct VecObject

pub struct VecObject<T: Invariant, A: Allocator> { /* private fields */ }

Implementations

impl<T: Invariant, A: Allocator> VecObject<T, A>

pub fn object(&self) -> &Object<Vec<T, A>>

pub fn into_object(self) -> Object<Vec<T, A>>

pub fn iter(&self) -> VecIter<'_, T>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn reserve(&mut self, additional: usize) -> Result<()>

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

pub fn truncate(&mut self, len: usize) -> Result<()>

pub fn as_slice(&self) -> RefSlice<'_, T>

pub fn slice(&self, range: impl RangeBounds<usize>) -> RefSlice<'_, T>

pub fn with_mut_slice<R>( &mut self, range: impl RangeBounds<usize>, f: impl FnOnce(&mut [T]) -> Result<R>, ) -> Result<R>

pub fn get_ref(&self, idx: usize) -> Option<Ref<'_, T>>

pub fn swap(&mut self, a: usize, b: usize) -> Result<()>

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

pub fn retain<F>(&mut self, f: F) -> Result<()>

where F: FnMut(&T) -> bool, T: StoreCopy,

pub fn first_ref(&self) -> Option<Ref<'_, T>>

pub fn last_ref(&self) -> Option<Ref<'_, T>>

pub fn binary_search(&self, x: &T) -> Result<usize, usize>

where T: Ord,

pub fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>

where F: FnMut(&T) -> Ordering,

pub fn binary_search_by_key<B, F>(&self, b: &B, f: F) -> Result<usize, usize>

where F: FnMut(&T) -> B, B: Ord,

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

where T: Ord,

pub fn sort_by<F>(&mut self, compare: F) -> Result<()>

where F: FnMut(&T, &T) -> Ordering,

pub fn sort_by_key<K, F>(&mut self, f: F) -> Result<()>

where F: FnMut(&T) -> K, K: Ord,

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

where T: Ord,

pub fn sort_unstable_by<F>(&mut self, compare: F) -> Result<()>

where F: FnMut(&T, &T) -> Ordering,

pub fn sort_unstable_by_key<K, F>(&mut self, f: F) -> Result<()>

where F: FnMut(&T) -> K, K: Ord,

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

pub fn starts_with(&self, needle: &[T]) -> bool

where T: PartialEq,

pub fn ends_with(&self, needle: &[T]) -> bool

where T: PartialEq,

pub fn contains(&self, x: &T) -> bool

where T: PartialEq,

pub fn with_slice<R>(&self, f: impl FnOnce(&[T]) -> R) -> R

pub fn with_slice_mut<R>( &mut self, f: impl FnOnce(&mut [T]) -> Result<R>, ) -> Result<R>

impl<T: Invariant + StoreCopy, A: Allocator> VecObject<T, A>

pub fn push(&mut self, val: T) -> Result<()>

pub fn append(&mut self, vals: impl IntoIterator<Item = T>) -> Result<()>

pub fn pop(&mut self) -> Result<Option<T>>

pub fn remove(&mut self, idx: usize) -> Result<T>

pub fn split_off(&mut self, _point: usize) -> Result<Self>

pub fn swap_remove(&mut self, _idx: usize) -> Result<T>

impl<T: Invariant> VecObject<T, VecObjectAlloc>

pub fn new(builder: ObjectBuilder<Vec<T, VecObjectAlloc>>) -> Result<Self>

impl<T: Invariant, A: Allocator + SingleObjectAllocator> VecObject<T, A>

pub fn push_inplace(&mut self, val: T) -> Result<()>

pub fn append_inplace( &mut self, vals: impl IntoIterator<Item = T>, ) -> Result<()>

pub fn push_ctor<F>(&mut self, ctor: F) -> Result<()>

where F: FnOnce(RefMut<'_, MaybeUninit<T>>) -> Result<RefMut<'_, T>>,

pub fn remove_inplace(&mut self, idx: usize) -> Result<()>

pub fn swap_remove_inplace(&mut self, _idx: usize) -> Result<()>

Trait Implementations

impl<T: Invariant, A: Allocator> Clone for VecObject<T, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Invariant + StoreCopy, A: Allocator> Extend<T> for VecObject<T, A>

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

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<T: Invariant, A: Allocator> From<Object<Vec<T, A>>> for VecObject<T, A>

fn from(value: Object<Vec<T, A>>) -> Self

Converts to this type from the input type.

impl<'a, T: Invariant, A: Allocator> IntoIterator for &'a VecObject<T, A>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = VecIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.