Type Alias oxygengine_core::ecs::life_cycle::EventsSystemResources

pub type EventsSystemResources<'a, T> = (WorldRef, Comp<&'a mut Events<T>>);

Trait Implementations

impl<A, B> AccessType for (A, B)where A: AccessType, B: AccessType,

fn feed_types(reads: &mut HashSet<TypeId>, writes: &mut HashSet<TypeId>)

fn get_types() -> (HashSet<TypeId>, HashSet<TypeId>)

([reads], [writes])

impl<B, A> DynamicBundle for (B, A)where B: Component, A: Component,

fn has<T>(&self) -> boolwhere T: Component,

Checks if the Bundle contains the given T:

impl<B, A> Fetch for (B, A)where B: Fetch, A: Fetch,

type State = (<B as Fetch>::State, <A as Fetch>::State)

The type of the data which can be cached to speed up retrieving the relevant type states from a matching Archetype

fn dangling() -> (B, A)

A value on which get may never be called

fn access(archetype: &Archetype) -> Option<Access>

How this query will access archetype, if at all

fn borrow(archetype: &Archetype, state: <(B, A) as Fetch>::State)

Acquire dynamic borrows from archetype

fn prepare(archetype: &Archetype) -> Option<<(B, A) as Fetch>::State>

Look up state for archetype if it should be traversed

fn execute(archetype: &Archetype, state: <(B, A) as Fetch>::State) -> (B, A)

Construct a Fetch for archetype based on the associated state

fn release(archetype: &Archetype, state: <(B, A) as Fetch>::State)

Release dynamic borrows acquired by borrow

fn for_each_borrow(f: impl FnMut(TypeId, bool))

Invoke f for every component type that may be borrowed and whether the borrow is unique

impl<B, A> Query for (B, A)where B: Query, A: Query,

type Item<'q> = (<B as Query>::Item<'q>, <A as Query>::Item<'q>)

Type of results yielded by the query

impl<A, B> ResQuery for (A, B)where A: ResQuery, B: ResQuery,

type Fetch = (<A as ResQuery>::Fetch, <B as ResQuery>::Fetch)

fn fetch(universe: &Universe) -> Self::Fetch

impl<B, A> Bundle for (B, A)where B: Component, A: Component,

impl<B, A> DynamicBundleClone for (B, A)where B: Component + Clone, A: Component + Clone,

impl<B, A> QueryShared for (B, A)where B: QueryShared, A: QueryShared,

impl<A, B> ResAccess for (A, B)where A: ResAccess, B: ResAccess,