Struct LockFreeFrozenVec 

pub struct LockFreeFrozenVec<T: Copy> { /* private fields */ }

Append-only threadsafe version of std::vec::Vec where insertion does not require mutable access. Does not lock for reading, only allows Copy types and will spinlock on pushes without affecting reads. Note that this data structure is 34 pointers large on 64 bit systems, in contrast to Vec which is 3 pointers large.

Implementations

impl<T: Copy> LockFreeFrozenVec<T>

pub const fn new() -> Self

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

Pushes an element to the vector, potentially allocating new memory. Returns the index at which the element was inserted.

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

Load an element (if it exists). This operation is lock-free and performs minimal synchronization.

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub unsafe fn get_unchecked(&self, index: usize) -> T

Load an element (if it exists). This operation is lock-free and performs no synchronized atomic operations. This is a useful primitive to implement your own data structure with newtypes around the index.

Safety

index must be in bounds, i.e. it must be less than self.len()

Trait Implementations

impl<T: Copy + Clone> Clone for LockFreeFrozenVec<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: Copy> Default for LockFreeFrozenVec<T>

fn default() -> Self

Creates an empty LockFreeFrozenVec that does not allocate any heap allocations until the first time data is pushed to it.

impl<T: Copy> Drop for LockFreeFrozenVec<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: Copy + PartialEq> PartialEq for LockFreeFrozenVec<T>

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.