Struct stable_id::Entities

pub struct Entities<IndexT, DataT> { /* private fields */ }

This is a lazily memory-compact version of SparseEntities. Use cases are the same but there are different tradeoffs.

Tradeoff vs SparseEntities.

• this struct uses a hash-based virtual table to translate issued ids into an id used internally by its backing collection Tec. So accessing items should be similar – it’s dictated by HashMap’s access complexity, since once it finds the internal id, a random access follows.
• removing items is O(Tec::remove()) = O(n lg n) though I have plans to make it O(n). An added benefits is [remove()] will also try to compact the memory by removing dead slots from Tec when there’s a majority of dead slots – it’s another O(n) pass.

Implementations

impl<IndexT, DataT> Entities<IndexT, DataT>where IndexT: Default + Successor + Clone + Copy + Hash + Eq + CastUsize + Ord + Maximum,

pub fn with_capacity(capacity: usize) -> Self

Reserves spaces similar to Vec::with_capacity().

pub fn len(&self) -> usize

Returns the number of items in this data structure.

pub fn is_empty(&self) -> bool

Tells you if the collection is empty.

pub fn get(&self, index: IndexT) -> Option<&DataT>

Try getting the item with the given id.

pub fn get_mut(&mut self, index: IndexT) -> Option<&mut DataT>

Mutable version of get.

pub fn remove(&mut self, index: IndexT) -> Option<DataT>

Removes an element for the given id.

pub fn alloc(&mut self, data: DataT) -> IndexT

Allocate an entity with monotonically increase ids, just like crate::SparseEntities.

pub fn iter(&self) -> impl Iterator<Item = &DataT>

Return all data’s references.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut DataT>

Return all data in mutable references.

pub fn iter_with_id(&self) -> impl Iterator<Item = (IndexT, &DataT)>

Iterate every entries. This takes O(HashMap::iter()) to iterate the entire collection.

impl<IndexT, DataT> Entities<IndexT, DataT>where IndexT: Successor + CastUsize + Ord + Copy + Maximum + Hash, DataT: Clone,

pub fn populate(data: DataT, count: usize) -> Self

Populate count number of items by cloning the given data.

impl<IndexT, DataT> Entities<IndexT, DataT>where IndexT: CastUsize + Ord + Copy + Maximum + Successor + Hash, DataT: Clone + Default,

pub fn populate_defaults(count: usize) -> Self

Populate count number of items with the default value.

Trait Implementations

impl<IndexT: Clone, DataT: Clone> Clone for Entities<IndexT, DataT>

fn clone(&self) -> Entities<IndexT, DataT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<IndexT, DataT> Default for Entities<IndexT, DataT>where IndexT: Default + Maximum,

fn default() -> Self

Returns the “default value” for a type.

impl<IndexT, DataT> Index<IndexT> for Entities<IndexT, DataT>where IndexT: Successor + Clone + Copy + Hash + Eq + Default + CastUsize + Ord + Maximum,

type Output = DataT

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<IndexT, DataT> IndexMut<IndexT> for Entities<IndexT, DataT>where IndexT: Successor + Clone + Copy + Hash + Eq + Default + CastUsize + Ord + Maximum,

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

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