Struct entity_data::entity_storage::EntityStorage

pub struct EntityStorage { /* private fields */ }

A container of entities.

Implementations

impl EntityStorage

pub fn new() -> EntityStorage

Creates an empty EntityStorage.

pub fn add<S: ArchetypeState>(&mut self, state: S) -> EntityId

Creates a new entity and returns its identifier.

pub fn get_archetype<A: StaticArchetype>(&self) -> Option<&ArchetypeStorage>

Returns a reference to the specified archetype.

pub fn get_archetype_mut<A: StaticArchetype>( &mut self ) -> Option<&mut ArchetypeStorage>

Returns a mutable reference to the specified archetype.

pub fn type_id_to_archetype_id(&self, type_id: &TypeId) -> Option<ArchetypeId>

Maps the specified TypeId to respective ArchetypeId. If the storage doesn’t contain an archetype of type type_id, it returns None.

pub fn get_archetype_by_id( &mut self, id: ArchetypeId ) -> Option<&ArchetypeStorage>

Returns a reference to the specified archetype.

pub fn get_mut_archetype_by_id( &mut self, id: ArchetypeId ) -> Option<&mut ArchetypeStorage>

Returns a mutable reference to the specified archetype.

pub fn contains(&self, entity: &EntityId) -> bool

Returns true if the storage contains the specified entity.

pub fn get<C: Component>(&self, entity: &EntityId) -> Option<&C>

Returns a reference to the component C of the specified entity.

pub fn get_mut<C: Component>(&mut self, entity: &EntityId) -> Option<&mut C>

Returns a mutable reference to the component C of the specified entity.

pub fn entry(&self, entity: &EntityId) -> Option<Entry<'_>>

Returns an entry of entity in the corresponding archetype.

pub fn entry_mut(&mut self, entity: &EntityId) -> Option<EntryMut<'_>>

Returns a mutable entry of entity in the corresponding archetype.

pub fn remove(&mut self, entity: &EntityId) -> bool

Removes an entity from the storage. Returns true if the entity was present in the storage.

pub fn entities(&self) -> AllEntities<'_>

pub fn n_archetypes(&mut self) -> usize

Returns the number of entities in the storage.

pub fn count_entities(&self) -> usize

Returns the number of entities in the storage.

impl EntityStorage

pub fn access(&mut self) -> SystemAccess<'_>

Provides access to all components. Allows simultaneous mutable access to multiple components.

pub fn dispatch<'a>(&self, systems: impl AsMut<[System<'a>]>)

Dispatches systems sequentially. For parallel execution, see dispatch_par (requires rayon feature).

Example

use entity_data::{EntityId, EntityStorage, System, SystemHandler};
use entity_data::system::SystemAccess;
use macros::Archetype;

#[derive(Default, Debug)]
struct Position {
    x: f32,
    y: f32,
}

#[derive(Archetype)]
struct Dog {
    pos: Position,
}

let mut storage = EntityStorage::new();
let dog0 = storage.add(Dog { pos: Default::default() });
let dog1 = storage.add(Dog { pos: Position { x: 3.0, y: 5.0 } });

struct PositionsPrintSystem {
    to_process: Vec<EntityId>,
}

impl SystemHandler for PositionsPrintSystem {
    fn run(&mut self, data: SystemAccess) {
        let positions = data.component::<Position>();
        for entity in &self.to_process {
            println!("{:?}", positions.get(entity));
        }
    }
}

let mut sys = PositionsPrintSystem {
    to_process: vec![dog0, dog1]
};
storage.dispatch(&mut [System::new(&mut sys).with::<Position>()]);

Trait Implementations

impl Default for EntityStorage

fn default() -> EntityStorage

Returns the “default value” for a type.