Struct Storage

pub struct Storage<C, D: UnprotectedStorage<C>, I> { /* private fields */ }

A storage for components managed with specs_static::Id instead of Entity. This Storage behaves very similar to specs’ Storage.

Registering

These component storages also have to be registered. This can be done using the WorldExt trait and its register_tile_comp method.

Implementations

impl<C, D, I> Storage<C, D, I>

where C: Component, D: UnprotectedStorage<C>, I: Id,

pub fn get(&self, id: I) -> Option<&C>

Tries to retrieve a component by its Id. This will only check whether a component is inserted or not, without doing any liveness checks for the id.

Examples found in repository

examples/basic.rs (line 63)

    fn run(&mut self, (tiles, materials): Self::SystemData) {
        if let Some(mat) = materials.get(tiles.id(3, 4)) {
            println!("The material at (3, 4) is {:?}.", mat);
        }

        let num_water: usize = (&*materials)
            .join()
            .map(|mat| match *mat {
                Material::Water => 1,
                _ => 0,
            })
            .sum();

        println!("There are {} tiles with water.", num_water);
    }

pub fn get_mut(&mut self, id: I) -> Option<&mut C>

Tries to retrieve a component mutably by its Id. This will only check whether a component is inserted or not, without doing any liveness checks for the id.

pub fn insert(&mut self, id: I, comp: C) -> Option<C>

Inserts comp at id. If there already was a value, it will be returned.

In contrast to entities, there are no invalid ids.

Examples found in repository

examples/basic.rs (line 94)

fn main() {
    let mut d = DispatcherBuilder::new().with(Sys, "sys", &[]).build();
    let mut w = World::new();

    // Use method provided by `WorldExt`.
    w.add_resource(Tiles::new(8, 8));
    w.register_tile_comp::<Material, TileId>();

    // Initialize

    {
        let tiles = w.read_resource::<Tiles>();
        let mut materials: TileCompsMut<Material> = SystemData::fetch(&w.res);

        for tile_id in tiles.iter_all() {
            materials.insert(tile_id, Material::Dirt);
        }

        materials.insert(tiles.id(1, 5), Material::Grass);
        materials.insert(tiles.id(2, 5), Material::Grass);
        materials.insert(tiles.id(3, 4), Material::Water);
        materials.insert(tiles.id(3, 7), Material::Water);
    }

    // ---

    d.dispatch(&mut w.res);
}

pub fn remove(&mut self, id: I) -> Option<C>

Removes the component at id.

Trait Implementations

impl<C, D, I> Default for Storage<C, D, I>

where D: Default + UnprotectedStorage<C>,

fn default() -> Self

Returns the “default value” for a type.

impl<C, D, I> Drop for Storage<C, D, I>

where D: UnprotectedStorage<C>,

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, C, D, I> Join for &'a Storage<C, D, I>

where D: UnprotectedStorage<C>,

type Type = &'a C

Type of joined components.

type Value = &'a D

Type of joined storages.

type Mask = &'a BitSet

Type of joined bit mask.

unsafe fn open(self) -> (Self::Mask, Self::Value)

Open this join by returning the mask and the storages.

unsafe fn get(value: &mut Self::Value, id: u32) -> Self::Type

Get a joined component value by a given index.

fn join(self) -> JoinIter<Self>

where Self: Sized,

Create a joined iterator over the contents.

fn maybe(self) -> MaybeJoin<Self>

where Self: Sized,

Returns a Join-able structure that yields all indices, returning None for all missing elements and Some(T) for found elements.

fn is_unconstrained() -> bool

If this Join typically returns all indices in the mask, then iterating over only it or combined with other joins that are also dangerous will cause the JoinIter/ParJoin to go through all indices which is usually not what is wanted and will kill performance.

impl<'a, C, D, I> Join for &'a mut Storage<C, D, I>

where D: UnprotectedStorage<C>,

type Type = &'a mut C

Type of joined components.

type Value = &'a mut D

Type of joined storages.

type Mask = &'a BitSet

Type of joined bit mask.

unsafe fn open(self) -> (Self::Mask, Self::Value)

Open this join by returning the mask and the storages.

unsafe fn get(value: &mut Self::Value, id: u32) -> Self::Type

Get a joined component value by a given index.

fn join(self) -> JoinIter<Self>

where Self: Sized,

Create a joined iterator over the contents.

fn maybe(self) -> MaybeJoin<Self>

where Self: Sized,

Returns a Join-able structure that yields all indices, returning None for all missing elements and Some(T) for found elements.

fn is_unconstrained() -> bool

If this Join typically returns all indices in the mask, then iterating over only it or combined with other joins that are also dangerous will cause the JoinIter/ParJoin to go through all indices which is usually not what is wanted and will kill performance.

impl<C, D, I> Tracked for Storage<C, D, I>

where D: Tracked + UnprotectedStorage<C>, C: Component,

fn channel(&self) -> &EventChannel<ComponentEvent>

Event channel tracking modified/inserted/removed components.

fn channel_mut(&mut self) -> &mut EventChannel<ComponentEvent>

Mutable event channel tracking modified/inserted/removed components.