Struct spirt::EntityDefs

pub struct EntityDefs<E: Entity> {
    complete_chunk_start_to_flattened_base: FxHashMap<E, usize>,
    incomplete_chunk_start_and_flattened_base: Option<(E, usize)>,
    flattened: Vec<E::Def>,
}

Collection holding the actual definitions for Context-allocated entities.

By design there is no way to iterate the contents of an EntityDefs, or generate entity indices without defining the entity in an EntityDefs.

Fields

complete_chunk_start_to_flattened_base: FxHashMap<E, usize>

Entities are grouped into chunks, with per-entity-type chunk sizes (powers of 2) specified via entities! below. This allows different EntityDefss to independently define more entities, without losing compactness (until a whole chunk is filled).

incomplete_chunk_start_and_flattened_base: Option<(E, usize)>

Similar to a single entry in complete_chunk_start_to_flattened_base, but kept outside of the map for efficiency. Also, this is the only chunk that doesn’t have its full size already (and therefore allows defining more entities into it, without allocating new chunks).

flattened: Vec<E::Def>

All chunks’ definitions are flattened into one contiguous Vec, where the start of each chunk’s definitions in flattened is indicated by either complete_chunk_start_to_flattened_base (for completed chunks) or incomplete_chunk_start_and_flattened_base.

Implementations

impl<E: Entity> EntityDefs<E>

pub fn new() -> Self

pub fn define(&mut self, cx: &Context, def: E::Def) -> E

fn entity_to_flattened(&self, entity: E) -> Option<usize>

Trait Implementations

impl<E: Clone + Entity> Clone for EntityDefs<E>

where E::Def: Clone,

fn clone(&self) -> EntityDefs<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Entity> Default for EntityDefs<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E: Entity> Index<E> for EntityDefs<E>

type Output = <E as Entity>::Def

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<E: Entity> IndexMut<E> for EntityDefs<E>

fn index_mut(&mut self, entity: E) -> &mut Self::Output

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