Struct goggles::world::ComponentAccess

pub struct ComponentAccess<'a, C, R> where
    C: Component,  { /* fields omitted */ }

Returned from the World methods read_component, write_component, and get_component_mut.

This is a simple wrapper around a MaskedStorage paired with an entity Allocator. It prevents you from inserting or accessing components that do not have a live Entity associated with them.

Implementations

impl<'a, C, R> ComponentAccess<'a, C, R> where
    C: Component,
    R: Deref<Target = ComponentStorage<C>>, 

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

pub fn storage(&self) -> &ComponentStorage<C>

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

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

impl<'a, C, R> ComponentAccess<'a, C, R> where
    C: Component,
    R: DerefMut<Target = ComponentStorage<C>>, 

pub fn storage_mut(&mut self) -> &mut ComponentStorage<C>

Access the inner MaskedStorage type.

It is possible by using this type directly to insert components into the underlying MaskedStorage for indexes that do not have a live Entity associated with them. This is not unsafe to do, but it is probably incorrect, and such components may either never be automatically removed or possibly be assigned to new entities that have the same index.

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

pub fn get_or_insert_with(
    &mut self,
    e: Entity,
    f: impl FnOnce() -> C
) -> Result<&mut C, WrongGeneration>

pub fn insert(&mut self, e: Entity, c: C) -> Result<Option<C>, WrongGeneration>

pub fn update(&mut self, e: Entity, c: C) -> Result<Option<C>, WrongGeneration> where
    C: PartialEq, 

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

pub fn guard(&mut self) -> GuardedJoin<'_, C::Storage>

impl<'a, C, R> ComponentAccess<'a, C, R> where
    C: Component,
    C::Storage: DenseStorage,
    R: Deref<Target = ComponentStorage<C>>, 

pub fn as_slice(&self) -> &[C]

impl<'a, C, R> ComponentAccess<'a, C, R> where
    C: Component,
    C::Storage: TrackedStorage,
    R: Deref<Target = ComponentStorage<C>>, 

pub fn tracking_modified(&self) -> bool

pub fn modified_indexes(&self) -> &ModifiedBitSet

pub fn mark_modified(&self, entity: Entity) -> Result<(), WrongGeneration>

pub fn modified(&self) -> ModifiedJoin<'_, C::Storage>

impl<'a, C, R> ComponentAccess<'a, C, R> where
    C: Component,
    C::Storage: DenseStorage,
    R: DerefMut<Target = ComponentStorage<C>>, 

pub fn as_mut_slice(&mut self) -> &mut [C]

impl<'a, C, R> ComponentAccess<'a, C, R> where
    C: Component,
    C::Storage: TrackedStorage,
    R: DerefMut<Target = ComponentStorage<C>>, 

pub fn set_track_modified(&mut self, flag: bool)

pub fn clear_modified(&mut self)

pub fn modified_mut(&mut self) -> ModifiedJoinMut<'_, C::Storage>

Trait Implementations

impl<'a, 'b, C, R> IntoJoin for &'a ComponentAccess<'b, C, R> where
    C: Component,
    R: Deref<Target = ComponentStorage<C>> + 'a, 

type Item = &'a C

type IntoJoin = &'a ComponentStorage<C>

fn into_join(self) -> Self::IntoJoin

impl<'a, 'b, C, R> IntoJoin for &'a mut ComponentAccess<'b, C, R> where
    C: Component,
    R: DerefMut<Target = ComponentStorage<C>> + 'a, 

type Item = &'a mut C

type IntoJoin = &'a mut ComponentStorage<C>

fn into_join(self) -> Self::IntoJoin