Struct Arena 

pub struct Arena<I: ArenaIndex, T: 'static, A: Allocator = Global> { /* private fields */ }

Unordered container with random access.

Implementations

impl<I: ArenaIndex, T, A: Allocator> Arena<I, T, A>

pub const fn new() -> Self

where A: ConstDefault,

Creates an arena instance.

pub fn with_capacity(capacity: usize) -> Self

where A: ConstDefault,

Creates an arena instance with the specified initial capacity.

pub const fn new_in(alloc: A) -> Self

Creates an arena instance.

pub fn with_capacity_in(capacity: usize, alloc: A) -> Self

Creates an arena instance with the specified initial capacity.

pub fn into_items(self) -> ArenaItems<I, T, A>

Returns contained items packed in a special container. While arena itself is unique (i.e. non-clonable) object, this special container could be cloned.

pub fn items(&self) -> &ArenaItems<I, T, A>

Returns reference to contained items packed in a special container. While arena itself is unique (i.e. non-clonable) object, this special container could be cloned.

pub fn items_mut(&mut self) -> &mut ArenaItems<I, T, A>

Returns mutable reference to contained items packed in a (mostly read-only) special container. While arena itself is unique (i.e. non-clonable) object, this special container could be cloned.

pub fn reserve(&mut self)

Reserves capacity for at least one more element. The collection may reserve more space to avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.items().len() + 1. Does nothing if capacity is already sufficient.

Panics

Panics if the required capacity overflows maximum index value + 1.

pub fn reserve_exact(&mut self)

Reserves the minimum capacity for exactly one more element. After calling reserve_exact, capacity will be greater than or equal to self.items().len() + 1. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the required capacity overflows maximum index value + 1.

pub fn try_reserve(&mut self) -> Result<(), TryReserveError>

Tries to reserve capacity for at least one more element. The collection may reserve more space to avoid frequent reallocations. After calling try_reserve, capacity will be greater than or equal to self.items().len() + 1. Does nothing if capacity is already sufficient.

Errors

If the capacity overflows, or the allocator reports a failure, then an error is returned.

pub fn try_reserve_exact(&mut self) -> Result<(), TryReserveError>

Tries to reserve capacity for exactly one more element. The collection may reserve more space to avoid frequent reallocations. After calling try_reserve_exact, capacity will be greater than or equal to self.items().len() + 1. Does nothing if capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer try_reserve if future insertions are expected.

Errors

If the capacity overflows, or the allocator reports a failure, then an error is returned.

pub fn insert<R>(&mut self, item: impl FnOnce(I) -> (T, R)) -> R

Place new item into the arena.

Examples

let mut arena: Arena<usize, Data> = Arena::new();
let new_item_index = arena.insert(|index| (Data { /* ... */ }, index));

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

Removes item with provided index.

Panics if index is not occupied.

Trait Implementations

impl<I: Debug + ArenaIndex, T: Debug + 'static, A: Debug + Allocator> Debug for Arena<I, T, A>

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

Formats the value using the given formatter.

impl<I: ArenaIndex, T, A> Default for Arena<I, T, A>

where A: ConstDefault + Allocator,

fn default() -> Self

Returns the “default value” for a type.

impl<I: ArenaIndex, T, A: Allocator> Index<I> for Arena<I, T, A>

type Output = T

The returned type after indexing.

fn index(&self, index: I) -> &T

Performs the indexing (container[index]) operation.

impl<I: ArenaIndex, T, A: Allocator> IndexMut<I> for Arena<I, T, A>

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

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