Struct SparseEntities

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

This is a sandwich of HashMap and Sequence.

Features:

• stable indices and not redeemable
• generated indices

Use cases:

• you’re removing more entities than you are adding
• you don’t care about relaiming ids

Implementations

impl<IndexT, DataT> SparseEntities<IndexT, DataT>

where IndexT: Successor + Clone + Copy + Hash + Eq + Default,

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

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

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

Panic if index is invalid

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

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

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

Trait Implementations

impl<IndexT, DataT> Default for SparseEntities<IndexT, DataT>

where IndexT: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<IndexT, DataT> Index<IndexT> for SparseEntities<IndexT, DataT>

where IndexT: Successor + Clone + Copy + Hash + Eq + Default,

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 SparseEntities<IndexT, DataT>

where IndexT: Successor + Clone + Copy + Hash + Eq + Default,

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

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

impl<IndexT, DataT> IntoIterator for SparseEntities<IndexT, DataT>

where IndexT: Successor + Clone + Copy + Default + Hash + Eq,

type Item = (IndexT, DataT)

The type of the elements being iterated over.

type IntoIter = IntoIter<IndexT, DataT>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.