Struct rkyv::util::ScratchVec

pub struct ScratchVec<T> { /* fields omitted */ }

A vector view into serializer scratch space.

Implementations

impl<T> ScratchVec<T>

pub unsafe fn new<S: ScratchSpace + ?Sized>(
    scratch_space: &mut S,
    capacity: usize
) -> Result<Self, S::Error>

Constructs a new, empty ScratchVec with the specified capacity.

The vector will be able to hold exactly capacity elements. If capacity is 0, the vector will not allocate.

Safety

• The vector must not outlive the given scratch space.
• Vectors must be dropped in the reverse order they are allocated.

pub unsafe fn free<S: ScratchSpace + ?Sized>(
    self,
    scratch_space: &mut S
) -> Result<(), S::Error>

Frees the memory associated with the scratch vec and releases it back to the scratch space.

This must be called when serialization succeeds, but may be omitted when serialization fails. In that case, the elements of the scratch vec will be dropped but the memory will not be popped. It is the duty of the scratch space in that case to ensure that memory resources are properly cleaned up.

Safety

The given scratch space must be the same one used to allocate the scratch vec.

pub fn clear(&mut self)

Clears the vector, removing all values.

Note that this method has no effect on the allocated capacity of the vector.

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

Returns an unsafe mutable pointer to the vector’s buffer.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage.

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

Extracts a mutable slice of the entire vector.

Equivalent to &mut s[..].

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the vector’s buffer.

The caller must ensure that the vector outlives the pointer this functions returns, or else it will end up pointing to garbage.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

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

Extracts a slice containing the entire vector.

Equivalent to &s[..].

pub fn capacity(&self) -> usize

Returns the number of elements the vector can hole without reallocating.

pub fn reserve(&mut self, additional: usize)

Ensures that there is capacity for at least additional more elements to be inserted into the ScratchVec.

Panics

Panics if the required capacity exceeds the available capacity.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its length.

pub fn extend_from_slice(&mut self, other: &[T])

Copies and appends all elements in a slice to the ScratchVec.

The elements of the slice are appended in-order.

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

Removes the last element from a vector and returns it, or None if it is empty.

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

Appends an element to the back of a collection.

pub fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for exactly additional more elements to be inserted in the given AlignedVec. After calling reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

Panics

Panics if the required capacity exceeds the available capacity.

pub unsafe fn set_len(&mut self, new_len: usize)

Forces the length of the vector to new_len.

This is a low-level operation that maintains none of the normal invariants of the type.

Safety

• new_len must be less than or equal to capacity()
• The elements at old_len..new_len must be initialized

pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> Drain<'_, T>

Creates a draining iterator that removes the specified range in the vector and yields the removed items.

When the iterator is dropped, all elements in the range are removed from the vector, even if the iterator was not fully consumed. If the iterator is not dropped (with mem::forget for example), it is unspecified how many elements are removed.

Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

impl<T> ScratchVec<MaybeUninit<T>>

pub fn assume_init(self) -> ScratchVec<T>

Assuming that all the elements are initialized, removes the MaybeUninit wrapper from the vector.

Safety

It is up to the caller to guarantee that the MaybeUninit<T> elements really are in an initialized state. Calling this when the content is not yet fully initialized causes undefined behavior.

Trait Implementations

impl<T> AsMut<[T]> for ScratchVec<T>

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Immutably borrows from an owned value.

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

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

Mutably borrows from an owned value.

impl<T: Debug> Debug for ScratchVec<T>

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

Formats the value using the given formatter.

impl<T> Deref for ScratchVec<T>

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for ScratchVec<T>

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

Mutably dereferences the value.

impl<T> Drop for ScratchVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, I: SliceIndex<[T]>> Index<I> for ScratchVec<T>

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, I: SliceIndex<[T]>> IndexMut<I> for ScratchVec<T>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.