Struct oxygengine_core::ecs::Storage

pub struct Storage<'e, T, D> { /* fields omitted */ }

A wrapper around the masked storage and the generations vector. Can be used for safe lookup of components, insertions and removes. This is what World::read/write fetches for the user.

Implementations

impl<'e, T, D> Storage<'e, T, D> where
    D: DerefMut<Target = MaskedStorage<T>>,
    T: Component, 

pub fn entry<'a>(
    &'a mut self,
    e: Entity
) -> Result<StorageEntry<'a, 'e, T, D>, WrongGeneration> where
    'e: 'a, 

Returns an entry to the component associated to the entity.

Behaves somewhat similarly to std::collections::HashMap’s entry api.

Example

if let Ok(entry) = storage.entry(entity) {
    entry.or_insert(Comp { field: 55 });
}

pub fn entries(&'a mut self) -> Entries<'a, 'e, T, D>

Returns a Join-able structure that yields all indices, returning Entry for all elements

WARNING: Do not have a join of only Entriess. Otherwise the join will iterate over every single index of the bitset. If you want a join with all Entriess, add an EntitiesRes to the join as well to bound the join to all entities that are alive.

Example

for (mut counter, _) in (counters.entries(), &marker).join() {
    let counter = counter.or_insert_with(Default::default);
    counter.increase();

    if counter.reached_limit() {
        counter.reset();
        // Do something
    }
}

impl<'st, T, D> Storage<'st, T, D> where
    D: Deref<Target = MaskedStorage<T>>,
    T: Component, 

pub fn restrict(
    &'rf self
) -> RestrictedStorage<'rf, 'st, T, &'rf <T as Component>::Storage, &'rf BitSet, ImmutableParallelRestriction>

Builds an immutable RestrictedStorage out of a Storage. Allows deferred unchecked access to the entity’s component.

This is returned as a ParallelRestriction version since you can only get immutable components with this which is safe for parallel by default.

impl<'st, T, D> Storage<'st, T, D> where
    D: DerefMut<Target = MaskedStorage<T>>,
    T: Component, 

pub fn restrict_mut(
    &'rf mut self
) -> RestrictedStorage<'rf, 'st, T, &'rf mut <T as Component>::Storage, &'rf BitSet, SequentialRestriction>

Builds a mutable RestrictedStorage out of a Storage. Allows restricted access to the inner components without allowing invalidating the bitset for iteration in Join.

pub fn par_restrict_mut(
    &'rf mut self
) -> RestrictedStorage<'rf, 'st, T, &'rf mut <T as Component>::Storage, &'rf BitSet, MutableParallelRestriction>

Builds a mutable, parallel RestrictedStorage, does not allow mutably getting other components aside from the current iteration.

impl<'e, T, D> Storage<'e, T, D> where
    D: Deref<Target = MaskedStorage<T>>,
    T: Component,
    <T as Component>::Storage: Tracked, 

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

Returns the event channel tracking modified components.

impl<'e, T, D> Storage<'e, T, D> where
    D: DerefMut<Target = MaskedStorage<T>>,
    T: Component,
    <T as Component>::Storage: Tracked, 

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

Returns the event channel for insertions/removals/modifications of this storage’s components.

pub fn register_reader(&mut self) -> ReaderId<ComponentEvent>

Starts tracking component events. Note that this reader id should be used every frame, otherwise events will pile up and memory use by the event channel will grow waiting for this reader.

pub fn flag(&mut self, event: ComponentEvent)

Flags an index with a ComponentEvent.

impl<'e, T, D> Storage<'e, T, D>

pub fn new(entities: Fetch<'e, EntitiesRes>, data: D) -> Storage<'e, T, D>

Creates a new Storage from a fetched allocator and a immutable or mutable MaskedStorage, named data.

impl<'e, T, D> Storage<'e, T, D> where
    D: Deref<Target = MaskedStorage<T>>,
    T: Component, 

pub fn unprotected_storage(&self) -> &<T as Component>::Storage

Gets the wrapped storage.

pub fn fetched_entities(&self) -> &EntitiesRes

Returns the EntitiesRes resource fetched by this storage. This does not have anything to do with the components inside. You only want to use this when implementing additional methods for Storage via an extension trait.

pub fn get(&self, e: Entity) -> Option<&T>

Tries to read the data associated with an Entity.

pub fn count(&self) -> usize

Computes the number of elements this Storage contains by counting the bits in the bit set. This operation will never be performed in constant time.

pub fn is_empty(&self) -> bool

Checks whether this Storage is empty. This operation is very cheap.

pub fn contains(&self, e: Entity) -> bool

Returns true if the storage has a component for this entity, and that entity is alive.

pub fn mask(&self) -> &BitSet

Returns a reference to the bitset of this storage which allows filtering by the component type without actually getting the component.

impl<'e, T, D> Storage<'e, T, D> where
    D: Deref<Target = MaskedStorage<T>>,
    T: Component,
    <T as Component>::Storage: SliceAccess<T>, 

pub fn as_slice(
    &self
) -> &[<<T as Component>::Storage as SliceAccess<T>>::Element]

Returns the component data as a slice.

The indices of this slice may not correspond to anything in particular. Check the underlying storage documentation for details.

impl<'e, T, D> Storage<'e, T, D> where
    D: DerefMut<Target = MaskedStorage<T>>,
    T: Component,
    <T as Component>::Storage: SliceAccess<T>, 

pub fn as_mut_slice(
    &mut self
) -> &mut [<<T as Component>::Storage as SliceAccess<T>>::Element]

Returns the component data as a slice.

The indices of this slice may not correspond to anything in particular. Check the underlying storage documentation for details.

impl<'e, T, D> Storage<'e, T, D> where
    D: DerefMut<Target = MaskedStorage<T>>,
    T: Component, 

pub unsafe fn unprotected_storage_mut(
    &mut self
) -> &mut <T as Component>::Storage

Gets mutable access to the wrapped storage.

Safety

This is unsafe because modifying the wrapped storage without also updating the mask bitset accordingly can result in illegal memory access.

pub fn get_mut(&mut self, e: Entity) -> Option<&mut T>

Tries to mutate the data associated with an Entity.

pub fn insert(&mut self, e: Entity, v: T) -> Result<Option<T>, Error>

Inserts new data for a given Entity. Returns the result of the operation as a InsertResult<T>

If a component already existed for the given Entity, then it will be overwritten with the new component. If it did overwrite, then the result will contain Some(T) where T is the previous component.

pub fn remove(&mut self, e: Entity) -> Option<T>

Removes the data associated with an Entity.

pub fn clear(&mut self)

Clears the contents of the storage.

pub fn drain(&mut self) -> Drain<'_, T>

Creates a draining storage wrapper which can be .joined to get a draining iterator.

Trait Implementations

impl<'a, T, D> Clone for Storage<'a, T, D> where
    D: Clone, 

pub fn clone(&self) -> Storage<'a, T, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T, D> DistinctStorage for Storage<'a, T, D> where
    T: Component,
    <T as Component>::Storage: DistinctStorage, 

impl<'a, 'b, T> GenericReadStorage for &'b Storage<'a, T, Fetch<'a, MaskedStorage<T>>> where
    'a: 'b,
    T: Component, 

type Component = T

The component type of the storage

pub fn get(
    &self,
    entity: Entity
) -> Option<&<&'b Storage<'a, T, Fetch<'a, MaskedStorage<T>>> as GenericReadStorage>::Component>

Get immutable access to an Entitys component

pub fn _private() -> Seal

Private function to seal the trait

impl<'a, T> GenericReadStorage for Storage<'a, T, Fetch<'a, MaskedStorage<T>>> where
    T: Component, 

type Component = T

The component type of the storage

pub fn get(
    &self,
    entity: Entity
) -> Option<&<Storage<'a, T, Fetch<'a, MaskedStorage<T>>> as GenericReadStorage>::Component>

Get immutable access to an Entitys component

pub fn _private() -> Seal

Private function to seal the trait

impl<'a, 'b, T> GenericReadStorage for &'b Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> where
    'a: 'b,
    T: Component, 

type Component = T

The component type of the storage

pub fn get(
    &self,
    entity: Entity
) -> Option<&<&'b Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericReadStorage>::Component>

Get immutable access to an Entitys component

pub fn _private() -> Seal

Private function to seal the trait

impl<'a, T> GenericReadStorage for Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> where
    T: Component, 

type Component = T

The component type of the storage

pub fn get(
    &self,
    entity: Entity
) -> Option<&<Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericReadStorage>::Component>

Get immutable access to an Entitys component

pub fn _private() -> Seal

Private function to seal the trait

impl<'a, 'b, T> GenericWriteStorage for &'b mut Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> where
    'a: 'b,
    T: Component, 

type Component = T

The component type of the storage

pub fn get_mut(
    &mut self,
    entity: Entity
) -> Option<&mut <&'b mut Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component>

Get mutable access to an Entitys component

pub fn get_mut_or_default(
    &mut self,
    entity: Entity
) -> Option<&mut <&'b mut Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component> where
    <&'b mut Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component: Default, 

Get mutable access to an Entitys component. If the component does not exist, it is automatically created using Default::default().

pub fn insert(
    &mut self,
    entity: Entity,
    comp: <&'b mut Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component
) -> Result<Option<<&'b mut Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component>, Error>

Insert a component for an Entity

pub fn remove(&mut self, entity: Entity)

Remove the component for an Entity

pub fn _private() -> Seal

Private function to seal the trait

impl<'a, T> GenericWriteStorage for Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> where
    T: Component, 

type Component = T

The component type of the storage

pub fn get_mut(
    &mut self,
    entity: Entity
) -> Option<&mut <Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component>

Get mutable access to an Entitys component

pub fn get_mut_or_default(
    &mut self,
    entity: Entity
) -> Option<&mut <Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component> where
    <Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component: Default, 

Get mutable access to an Entitys component. If the component does not exist, it is automatically created using Default::default().

pub fn insert(
    &mut self,
    entity: Entity,
    comp: <Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component
) -> Result<Option<<Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> as GenericWriteStorage>::Component>, Error>

Insert a component for an Entity

pub fn remove(&mut self, entity: Entity)

Remove the component for an Entity

pub fn _private() -> Seal

Private function to seal the trait

impl<'a, 'e, T, D> Join for &'a mut Storage<'e, T, D> where
    D: DerefMut<Target = MaskedStorage<T>>,
    T: Component, 

type Mask = &'a BitSet

Type of joined bit mask.

type Type = &'a mut T

Type of joined components.

type Value = &'a mut <T as Component>::Storage

Type of joined storages.

pub unsafe fn open(
    self
) -> (<&'a mut Storage<'e, T, D> as Join>::Mask, <&'a mut Storage<'e, T, D> as Join>::Value)

Open this join by returning the mask and the storages.

pub unsafe fn get(
    v: &mut <&'a mut Storage<'e, T, D> as Join>::Value,
    i: u32
) -> &'a mut T

Get a joined component value by a given index.

pub fn join(self) -> JoinIter<Self>

Create a joined iterator over the contents.

pub fn maybe(self) -> MaybeJoin<Self>

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

pub 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, 'e, T, D> Join for &'a Storage<'e, T, D> where
    D: Deref<Target = MaskedStorage<T>>,
    T: Component, 

type Mask = &'a BitSet

Type of joined bit mask.

type Type = &'a T

Type of joined components.

type Value = &'a <T as Component>::Storage

Type of joined storages.

pub unsafe fn open(
    self
) -> (<&'a Storage<'e, T, D> as Join>::Mask, <&'a Storage<'e, T, D> as Join>::Value)

Open this join by returning the mask and the storages.

pub unsafe fn get(
    v: &mut <&'a Storage<'e, T, D> as Join>::Value,
    i: u32
) -> &'a T

Get a joined component value by a given index.

pub fn join(self) -> JoinIter<Self>

Create a joined iterator over the contents.

pub fn maybe(self) -> MaybeJoin<Self>

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

pub 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, 'e, T, D> Not for &'a Storage<'e, T, D> where
    D: Deref<Target = MaskedStorage<T>>,
    T: Component, 

type Output = AntiStorage<'a>

The resulting type after applying the ! operator.

pub fn not(self) -> <&'a Storage<'e, T, D> as Not>::Output

Performs the unary ! operation.

impl<'a, T> SystemData<'a> for Storage<'a, T, FetchMut<'a, MaskedStorage<T>>> where
    T: Component, 

pub fn setup(res: &mut World)

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

pub fn fetch(res: &'a World) -> Storage<'a, T, FetchMut<'a, MaskedStorage<T>>>

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

pub fn reads() -> Vec<ResourceId, Global>

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

pub fn writes() -> Vec<ResourceId, Global>

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

impl<'a, T> SystemData<'a> for Storage<'a, T, Fetch<'a, MaskedStorage<T>>> where
    T: Component, 

pub fn setup(res: &mut World)

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

pub fn fetch(res: &'a World) -> Storage<'a, T, Fetch<'a, MaskedStorage<T>>>

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

pub fn reads() -> Vec<ResourceId, Global>

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

pub fn writes() -> Vec<ResourceId, Global>

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