Type Definition specs::WriteStorage

type WriteStorage<'a, T> = Storage<'a, T, FetchMut<'a, MaskedStorage<T>>>;

A storage with read and write access.

Additionally to what ReadStorage can do a storage with mutable access allows:

Aliasing

It is strictly disallowed to fetch both a ReadStorage and a WriteStorage of the same component. Because Specs uses interior mutability for its resources, we can't check this at compile time. If you try to do this, you will get a panic.

It is also disallowed to fetch multiple WriteStorages for the same component.

Retrieve components mutably

This works just like Storage::get, but returns a mutable reference:

let entity = world.create_entity()
    .with(Pos(2.0))
    .build();

assert_eq!(pos_storage.get_mut(entity), Some(&mut Pos(2.0)));
if let Some(pos) = pos_storage.get_mut(entity) {
    *pos = Pos(4.5);
}

assert_eq!(pos_storage.get(entity), Some(&Pos(4.5)));

Inserting and removing components

You can insert components using Storage::insert and remove them again with Storage::remove.

let entity = world.create_entity()
    .with(Pos(0.1))
    .build();

if let Ok(Some(p)) = pos_storage.insert(entity, Pos(4.0)) {
    println!("Overwrote {:?} with a new position", p);
}

There's also an Entry-API similar to the one provided by std::collections::HashMap.

Trait Implementations

impl<'a, T> SystemData<'a> for WriteStorage<'a, T> where
    T: Component, 

fn setup(res: &mut Resources)

Sets up the system data for fetching it from the Resources.

fn fetch(res: &'a Resources) -> Self

Fetches the system data from Resources. Note that this is only specified for one concrete lifetime 'a, you need to implement the SystemData trait for every possible lifetime.

Important traits for Vec<u8>

impl Write for Vec<u8>

fn reads() -> Vec<ResourceId>

Returns all read dependencies as fetched from Self::fetch.

Important traits for Vec<u8>

impl Write for Vec<u8>

fn writes() -> Vec<ResourceId>

Returns all write dependencies as fetched from Self::fetch.

impl<'a, T> GenericReadStorage for WriteStorage<'a, T> where
    T: Component, 

type Component = T

The component type of the storage

fn get(&self, entity: Entity) -> Option<&Self::Component>

Get immutable access to an Entitys component

fn _private() -> Seal

Private function to seal the trait

impl<'a: 'b, 'b, T> GenericReadStorage for &'b WriteStorage<'a, T> where
    T: Component, 

type Component = T

The component type of the storage

fn get(&self, entity: Entity) -> Option<&Self::Component>

Get immutable access to an Entitys component

fn _private() -> Seal

Private function to seal the trait

impl<'a, T> GenericWriteStorage for WriteStorage<'a, T> where
    T: Component, 

type Component = T

The component type of the storage

fn get_mut(&mut self, entity: Entity) -> Option<&mut Self::Component>

Get mutable access to an Entitys component

fn insert(
    &mut self,
    entity: Entity,
    comp: Self::Component
) -> InsertResult<Self::Component>

Insert a component for an Entity

fn remove(&mut self, entity: Entity)

Remove the component for an Entity

fn _private() -> Seal

Private function to seal the trait

impl<'a: 'b, 'b, T> GenericWriteStorage for &'b mut WriteStorage<'a, T> where
    T: Component, 

type Component = T

The component type of the storage

fn get_mut(&mut self, entity: Entity) -> Option<&mut Self::Component>

Get mutable access to an Entitys component

fn insert(
    &mut self,
    entity: Entity,
    comp: Self::Component
) -> InsertResult<Self::Component>

Insert a component for an Entity

fn remove(&mut self, entity: Entity)

Remove the component for an Entity

fn _private() -> Seal

Private function to seal the trait