Struct qecs::with_dirty_state::WithDirtyState

pub struct WithDirtyState<S: StoreBase> { /* fields omitted */ }

Trait Implementations

impl<S> From<S> for WithDirtyState<S> where
    S: StoreBase, 

fn from(store: S) -> Self

Performs the conversion.

impl<S> Default for WithDirtyState<S> where
    S: StoreBase + Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<S> ServiceBase for WithDirtyState<S> where
    S: StoreBase, 

fn on_before_frame(&mut self)

fn on_after_frame(&mut self)

impl<S> StoreBase for WithDirtyState<S> where
    S: StoreBase, 

type Id = S::Id

fn len(&self) -> usize

fn is_assigned<'id>(&self, id: Valid<'id, Self::Id>) -> bool

fn release_drop<'id>(&mut self, id: Valid<'id, Self::Id>) -> bool

A variant of .release(id) which drops the returned component. Returns true if sucessful.

fn clear(&mut self)

impl<'a, S> _ComponentStore<'a> for WithDirtyState<S> where
    S: _ComponentStore<'a>, 

type _Value = S::_Value

type Values = S::Values

type ValuesMut = S::ValuesMut

impl<S> ComponentStore for WithDirtyState<S> where
    S: ComponentStore, 

type Value = S::Value

fn assign<'id, T>(
    &mut self,
    id: Valid<'id, Self::Id>,
    com: T
) -> Option<Self::Value> where
    T: Into<Self::Value>, 

fn release<'id>(&mut self, id: Valid<'id, Self::Id>) -> Option<Self::Value>

fn get<'id>(&self, id: Valid<'id, Self::Id>) -> Option<&Self::Value>

Returns None if id is not assigned.

fn get_mut<'id>(&mut self, id: Valid<'id, Self::Id>) -> Option<&mut Self::Value>

Returns None if id is not assigned.

fn values<'a>(&'a self) -> Self::Values

fn values_mut<'a>(&'a mut self) -> Self::ValuesMut

impl<'a, S> _ComponentStoreIter<'a> for WithDirtyState<S> where
    S: _ComponentStoreIter<'a>, 

type Iter = S::Iter

type IterMut = S::IterMut

impl<S> ComponentStoreIter for WithDirtyState<S> where
    S: ComponentStoreIter, 

fn iter<'a>(&'a self) -> Self::Iter

fn iter_mut<'a>(&'a mut self) -> Self::IterMut

impl<S> EntityStore for WithDirtyState<S> where
    S: EntityStore, 

fn assign<'id>(&mut self, id: Valid<'id, Self::Id>) -> bool

fn release<'id>(&mut self, id: Valid<'id, Self::Id>) -> bool

impl<'a, S> _EntityStoreIter<'a> for WithDirtyState<S> where
    S: _EntityStoreIter<'a>, 

type Iter = S::Iter

impl<S> EntityStoreIter for WithDirtyState<S> where
    S: EntityStoreIter, 

fn iter<'a>(&'a self) -> Self::Iter

impl<'a, S> _StoreWithDirtyState<'a> for WithDirtyState<S> where
    S: StoreBase, 

type DirtyEntities = DirtyEntities<'a, S::Id>

impl<S> StoreWithDirtyState for WithDirtyState<S> where
    S: StoreBase, 

fn was_cleared(&self) -> bool

fn dirty_entities<'a>(&'a self) -> Self::DirtyEntities

impl<'a, S> IntoIterator for &'a WithDirtyState<S> where
    S: StoreBase,
    &'a S: IntoIterator, 

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a S as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.