Struct components_arena::ArenaItems

source ·

pub struct ArenaItems<C: Component> { /* private fields */ }

Expand description

A (mostly read-only) inner container holding Arena items. While Arena itself is unique (i.e. non-clonable) object, arena ‘items’ could be cloned.

Implementations§

source §

impl<C: Component> ArenaItems<C>

source

pub const fn item_size() -> usize

An amount of memory required to hold one component.

This information can be useful for memory management fine-tuning.

source

pub const fn item_align() -> usize

An alignment of a cell, holding a component with all required metadata.

This information can be useful for memory management fine-tuning.

source

pub fn allocator(&self) -> &C::Alloc

Returns a reference to the underlying allocator.

source

pub fn capacity(&self) -> usize

Returns the number of elements the arena can hold without reallocating.

source

pub fn len(&self) -> usize

Returns the number of elements in the arena.

This function has linear worst-case complexity.

source

pub fn len_equals_to_min_capacity(&self) -> bool

Returns true iff the number of elements in the arena equals the maximum number of elements ever in the arena.

Because the arena capacity cannot be less than min_capacity, the returned false means there is space for at least one more item.

The returned value equals to self.len() == self.min_capacity(), but unlike len this function has constant complexity.

source

pub fn is_empty(&self) -> bool

Returns true if the arena contains no elements.

This function has linear worst-case complexity.

source

pub fn min_capacity(&self) -> usize

Returns the maximum number of elements ever in the arena. The arena capacity cannot be less than min_capacity.

Arena min_capacity never decreases.

§Examples

let mut arena = Arena::new();
assert_eq!(arena.items().min_capacity(), 0);
let id_1 = arena.insert(|id| (MyComponent { /* ... */ }, id));
assert_eq!(arena.items().min_capacity(), 1);
let id_2 = arena.insert(|id| (MyComponent { /* ... */ }, id));
assert_eq!(arena.items().min_capacity(), 2);
arena.remove(id_1);
assert_eq!(arena.items().min_capacity(), 2);
let id_3 = arena.insert(|id| (MyComponent { /* ... */ }, id));
assert_eq!(arena.items().min_capacity(), 2);
let id_4 = arena.insert(|id| (MyComponent { /* ... */ }, id));
assert_eq!(arena.items().min_capacity(), 3);

source

pub fn reserve(&mut self, additional: usize)

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

§Panics

Panics if the new capacity overflows usize.

source

pub fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for exactly additional more elements. After calling reserve_exact, capacity will be greater than or equal to self.min_capacity() + additional. 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 new capacity overflows usize.

source

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the arena with a lower bound.

The capacity will remain at least as large as both the min_capacity and the supplied value.

source

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the vector as much as possible.

It will drop down as close as possible to the min_capacity but the allocator may still inform the arena that there is space for a few more elements.

source

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

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

§Errors

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

source

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

Tries to reserve capacity for exactly additional more elements. The collection may reserve more space to avoid frequent reallocations. After calling try_reserve_exact, capacity will be greater than or equal to self.min_capacity() + additional. 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.