Struct AppendVec 

pub struct AppendVec<T> { /* private fields */ }

A thread-safe, append-only vector implementation with amortized O(1) push operations.

This data structure is optimized for concurrent append operations while maintaining strong memory safety guarantees. It uses a series of dynamically allocated buckets that grow exponentially in size to reduce allocation frequency.

Implementations

impl<T> AppendVec<T>

pub const fn new() -> Self

Creates a new, empty AppendVec.

pub fn with_capacity(capacity: usize) -> Self

Creates a new, empty AppendVec with a specified capacity.

This method pre-allocates buckets up to the specified capacity, reducing the number of reallocations as elements are added.

Arguments

• capacity - The initial capacity of the vector.

Returns

A new AppendVec with the specified capacity.

pub fn capacity(&self) -> usize

Returns the total capacity of the vector before reallocation would be needed.

pub fn max_capacity(&self) -> usize

Returns the maximum capacity of the vector.

pub fn clear(&mut self)

Clears the vector, dropping all elements and deallocating memory.

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

Creates an iterator that yields references to individual elements.

pub fn get(&self, index: usize) -> Option<&T>

Get a reference to the element at the specified index, if it exists.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Get a mutable reference to the element at the specified index, if it exists.

pub fn len(&self) -> usize

Returns the number of elements in the vector.

pub fn is_empty(&self) -> bool

Checks if the vector is empty.

pub fn push(&self, item: T) -> usize

Pushes an item to the vector.

pub fn grow_with(&self, size: usize, init: impl FnMut(usize) -> T) -> usize

Grows the vector to at least size elements, initializing new elements with the provided function.

This method ensures the vector contains at least size elements. If the current length is less than size, new elements are initialized by calling init with their index.

Arguments

• size - The minimum size the vector should have
• init - A function that produces initial values for new elements, called with the index of each new element

Returns

The previous length of the vector before growth

pub fn grow_default(&self, size: usize) -> usize

where T: Default,

Grows the vector to at least size elements, initializing new elements with their default value.

This is a convenience method that calls grow_with using T::default() for new elements.

Arguments

• size - The minimum size the vector should have

Returns

The previous length of the vector before growth

pub fn grow(&self, size: usize, value: T) -> usize

where T: Clone,

Grows the vector to at least size elements, initializing new elements with the provided value.

This is a convenience method that calls grow_with using value.clone() for new elements.

Arguments

• size - The minimum size the vector should have
• value - The value to initialize new elements with

Returns

The previous length of the vector before growth

pub fn extend( &self, items: impl IntoIterator<Item = T, IntoIter: ExactSizeIterator>, ) -> usize

Pushes multiple items at once when exclusive access is guaranteed.

Panics

Panics if the reported iterator length would overflow the vector’s maximum capacity, or if the iterator yields a different number of items than reported by ExactSizeIterator::len. If it yields too few items, the reserved range is not published and the vector is left in a poisoned state, so subsequent insertions may stall. If it yields too many items, exactly the reported prefix is published before the panic and the vector remains usable.

pub fn extend_unbounded(&mut self, items: impl IntoIterator<Item = T>) -> usize

Extends the vector with the given items, without any bounds checking.

This method is useful when you have exclusive access to the vector and want to extend it with an unknown iterator.

Panics

Panics if a previous insertion panicked leaving the vector in a poisoned state.

pub fn slice(&self, range: Range<usize>) -> AppendSlice<'_, T>

Returns a view over a contiguous range of elements.

The returned AppendSlice is a lightweight wrapper around several slice references, each coming from a different internal bucket. It offers the standard slice-like API (len, indexing, iteration) without copying the underlying data.

The function is lock-free and does not allocate.

Panics

Panics if range.end is greater than the current length of the vector, or if range.start > range.end.

Examples

use omp_core::append_vec::AppendVec;
let vec = AppendVec::with_capacity(10);
for i in 0..10 {
	vec.push(i);
}
let window = vec.slice(2..5);
assert_eq!(window.len(), 3);
assert_eq!(window[0], 2);

impl<T: Clone> AppendVec<T>

pub fn to_vec(&self) -> Vec<T>

Creates a standard Vec from this AppendVec.

Trait Implementations

impl<T: Clone> Clone for AppendVec<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AppendVec<T>

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

Formats the value using the given formatter.

impl<T> Default for AppendVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for AppendVec<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T> FromIterator<T> for AppendVec<T>

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

Creates a value from an iterator.

impl<T> Index<usize> for AppendVec<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for AppendVec<T>

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

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

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

Implementation of IntoIterator for AppendVec

type IntoIter = AppendVecIter<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Send> Send for AppendVec<T>

impl<T: Send + Sync> Sync for AppendVec<T>