Struct AppendOnlyVec 

pub struct AppendOnlyVec<T, const AMOUNT_OF_BINS: usize = 32, const BIN_OFFSET: u32 = 3> { /* private fields */ }

Append only vec of items T.

This vec will never re-allocate and never remove items. This means that as long as this vec is around, we can have valid references to all the data it stores. This also means that we can add items to the vec without having a mutable reference to it.

This vec has a fixed maximum capacity as configured by the const generic parameters. Calling Self::push after that capacity is exhausted will panic.

AMOUNT_OF_BINS is total amount of item bins (=arrays). Each bin has double the capacity then the one before, so even with a low number here, we should be able to store a huge amount of items.

BIN_OFFSET calculates the offset of the first bin. Effectively this mean our first bin will have 2^BIN_OFFSET size.

Implementations

impl<T, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>

pub fn new() -> Self

Create a new AppendOnlyVec of T items

use rama_utils::collections::AppendOnlyVec;
// This should fail because this overflow INITIAL_BIN_SIZE
_ = AppendOnlyVec::<usize, 300, 100>::new();

use rama_utils::collections::AppendOnlyVec;
// This should fail because the total size exceeds isize::MAX
_ = AppendOnlyVec::<u64, 60, 10>::new();

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

Pushes an element and returns its index.

Panics

Panics when the fixed maximum capacity is exceeded. Use Self::capacity to inspect the configured limit.

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

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub const fn capacity() -> usize

Returns the maximum number of elements this configuration can hold. Total capacity = initial_bin_size * (2^AMOUNT_OF_BINS - 1)

pub fn iter(&self) -> Iter<'_, T, AMOUNT_OF_BINS, BIN_OFFSET>

Returns an iterator over the elements currently in the vector. The iterator snapshots the length at creation time.

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

Get item with idx from this vec

Safety

This function is safe if idx < self.len()

Trait Implementations

impl<T: Debug, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> Debug for AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>

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

Formats the value using the given formatter.

impl<T, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> Default for AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> Drop for AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>

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, const BINS: usize, const OFFSET: u32> Extend<T> for AppendOnlyVec<T, BINS, OFFSET>

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: T)

🔬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, const BINS: usize, const OFFSET: u32> Extend<T> for &AppendOnlyVec<T, BINS, OFFSET>

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: T)

🔬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, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> FromIterator<T> for AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>

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

Creates a value from an iterator.

impl<T, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> Index<usize> for AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, T, const BINS: usize, const OFFSET: u32> IntoIterator for &'a AppendOnlyVec<T, BINS, OFFSET>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, BINS, OFFSET>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const BINS: usize, const OFFSET: u32> IntoIterator for AppendOnlyVec<T, BINS, OFFSET>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIterOwned<T, BINS, OFFSET>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Send, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> Send for AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>

impl<T: Send + Sync, const AMOUNT_OF_BINS: usize, const BIN_OFFSET: u32> Sync for AppendOnlyVec<T, AMOUNT_OF_BINS, BIN_OFFSET>