Struct compact::CVec

pub struct CVec<T, A: Allocator = DefaultHeap> { /* fields omitted */ }

A dynamically-sized vector that can be stored in compact sequential storage and automatically spills over into free heap storage using Allocator. Tries to closely follow the API of std::vec::Vec, but is not complete.

Implementations

impl<T: Compact + Clone, A: Allocator> CompactVec<T, A>

pub fn len(&self) -> usize

Get the number of elements in the vector

pub fn is_empty(&self) -> bool

Is the vector empty?

pub fn new() -> CompactVec<T, A>

Create a new, empty vector

pub fn with_capacity(cap: usize) -> CompactVec<T, A>

Create a new, empty vector with a given capacity

pub unsafe fn from_raw_parts(
    ptr: *mut T,
    len: usize,
    cap: usize
) -> CompactVec<T, A>

Create a new vector from raw parts Assumes that ptr has been allocated by the same Allocator that is A

pub fn capacity(&self) -> usize

current capacity

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

Push an item onto the vector, spills onto the heap if the capacity in compact storage is insufficient

pub fn push_at(&mut self, _: usize, value: T)

push at position

pub fn extend_from_copy_slice(&mut self, other: &[T]) where
    T: Copy, 

Extend from a copyable slice

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

Pop and return the last element, if the vector wasn't empty

pub fn insert(&mut self, index: usize, value: T)

Insert a value at index, copying the elements after index upwards

pub fn remove(&mut self, index: usize) -> T

Remove the element at index, copying the elements after index downwards

pub fn swap_remove(&mut self, index: usize) -> T

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

pub fn retain<F: FnMut(&T) -> bool>(&mut self, keep: F)

Take a function which returns whether an element should be kept, and mutably removes all elements from the vector which are not kept

pub fn truncate(&mut self, desired_len: usize)

Truncate the vector to the given length

pub fn clear(&mut self)

Clear the vector

pub fn drain(&mut self) -> IntoIter<T, A>

Drain (empty & iterate over) the vector

pub fn ptr_to_string(&self) -> String

debug printing

Trait Implementations

impl<T: Compact + Clone, A: Allocator> Clone for CompactVec<T, A>

default fn clone(&self) -> CompactVec<T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy, A: Allocator> Clone for CompactVec<T, A>

fn clone(&self) -> CompactVec<T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Compact + Clone, A: Allocator> Compact for CompactVec<T, A>

default fn is_still_compact(&self) -> bool

Is the object's dynamic part stored compactly?

default fn dynamic_size_bytes(&self) -> usize

Size of the dynamic part in bytes

unsafe default fn compact(
    source: *mut Self,
    dest: *mut Self,
    new_dynamic_part: *mut u8
)

Copy the static part of source to dest and compactly store the dynamic part of source as the new dynamic part of dest at new_dynamic_part. This semantically moves source into dest.

unsafe default fn decompact(source: *const Self) -> Self

Creates a clone of self with the dynamic part guaranteed to be stored freely.

fn total_size_bytes(&self) -> usize

Total size of the object (static part + dynamic part)

unsafe fn behind(ptr: *mut Self) -> *mut u8

Get a pointer to behind the static part of self (commonly used place for the dynamic part)

unsafe fn compact_behind(source: *mut Self, dest: *mut Self)

Like compact with new_dynamic_part set to dest.behind()

impl<T: Copy, A: Allocator> Compact for CompactVec<T, A>

fn is_still_compact(&self) -> bool

Is the object's dynamic part stored compactly?

fn dynamic_size_bytes(&self) -> usize

Size of the dynamic part in bytes

unsafe fn compact(source: *mut Self, dest: *mut Self, new_dynamic_part: *mut u8)

Copy the static part of source to dest and compactly store the dynamic part of source as the new dynamic part of dest at new_dynamic_part. This semantically moves source into dest.

fn total_size_bytes(&self) -> usize

Total size of the object (static part + dynamic part)

unsafe fn behind(ptr: *mut Self) -> *mut u8

Get a pointer to behind the static part of self (commonly used place for the dynamic part)

unsafe fn compact_behind(source: *mut Self, dest: *mut Self)

Like compact with new_dynamic_part set to dest.behind()

unsafe fn decompact(source: *const Self) -> Self

Creates a clone of self with the dynamic part guaranteed to be stored freely.

impl<T: Compact + Debug, A: Allocator> Debug for CompactVec<T, A>

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

Formats the value using the given formatter.

impl<T: Compact, A: Allocator> Default for CompactVec<T, A>

fn default() -> CompactVec<T, A>

Returns the "default value" for a type.

impl<T, A: Allocator> Deref for CompactVec<T, A>

type Target = [T]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, A: Allocator> DerefMut for CompactVec<T, A>

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

Mutably dereferences the value.

impl<T, A: Allocator> Drop for CompactVec<T, A>

fn drop(&mut self)

Drop elements and deallocate free heap storage, if any is allocated

impl<T: Compact + Clone, A: Allocator> Extend<T> for CompactVec<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: Compact + Clone, A: Allocator> From<Vec<T>> for CompactVec<T, A>

fn from(vec: Vec<T>) -> Self

Create a CompactVec from a normal Vec, directly using the backing storage as free heap storage

impl<T: Compact + Clone, A: Allocator> FromIterator<T> for CompactVec<T, A>

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

Creates a value from an iterator.

impl<T: Hash> Hash for CompactVec<T>

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

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, A: Allocator> IntoIterator for CompactVec<T, A>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

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, A: Allocator> IntoIterator for &'a mut CompactVec<T, A>

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.