[−][src]Trait bevy::prelude::IntoQuerySystem

pub trait IntoQuerySystem<Commands, R, Q> {
    fn system(self) -> Box<dyn System + 'static>;
}

Converts Self into a Query System

Required methods

`fn system(self) -> Box<dyn System + 'static>`

Loading content...

Implementors

`impl<Func> IntoQuerySystem<(Commands,), (), ()> for Func where Func: FnMut(Commands) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func> IntoQuerySystem<(), (), ()> for Func where Func: FnMut() + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A> IntoQuerySystem<(Commands,), (), (A,)> for Func where A: Query, Func: FnMut(Commands, Query<'_, A>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A> IntoQuerySystem<(), (), (A,)> for Func where A: Query, Func: FnMut(Query<'_, A>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B> IntoQuerySystem<(Commands,), (), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B> IntoQuerySystem<(), (), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Query<'_, A>, Query<'_, B>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C> IntoQuerySystem<(Commands,), (), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C> IntoQuerySystem<(), (), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D> IntoQuerySystem<(Commands,), (), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D> IntoQuerySystem<(), (), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E> IntoQuerySystem<(Commands,), (), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E> IntoQuerySystem<(), (), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E, F> IntoQuerySystem<(), (), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra> IntoQuerySystem<(Commands,), (Ra,), ()> for Func where Func: FnMut(Commands, Ra) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra> IntoQuerySystem<(), (Ra,), ()> for Func where Func: FnMut(Ra) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A> IntoQuerySystem<(Commands,), (Ra,), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A> IntoQuerySystem<(), (Ra,), (A,)> for Func where A: Query, Func: FnMut(Ra, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B> IntoQuerySystem<(Commands,), (Ra,), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B> IntoQuerySystem<(), (Ra,), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B, C> IntoQuerySystem<(Commands,), (Ra,), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B, C> IntoQuerySystem<(), (Ra,), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B, C, D> IntoQuerySystem<(Commands,), (Ra,), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B, C, D> IntoQuerySystem<(), (Ra,), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra,), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B, C, D, E> IntoQuerySystem<(), (Ra,), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra,), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, A, B, C, D, E, F> IntoQuerySystem<(), (Ra,), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb> IntoQuerySystem<(Commands,), (Ra, Rb), ()> for Func where Func: FnMut(Commands, Ra, Rb) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb> IntoQuerySystem<(), (Ra, Rb), ()> for Func where Func: FnMut(Ra, Rb) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, A> IntoQuerySystem<(Commands,), (Ra, Rb), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, A> IntoQuerySystem<(), (Ra, Rb), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, A, B> IntoQuerySystem<(Commands,), (Ra, Rb), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, A, B> IntoQuerySystem<(), (Ra, Rb), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, A, B, C> IntoQuerySystem<(), (Ra, Rb), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, A, B, C, D> IntoQuerySystem<(), (Ra, Rb), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, Rc> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, Rc> IntoQuerySystem<(), (Ra, Rb, Rc), ()> for Func where Func: FnMut(Ra, Rb, Rc) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, Rc, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, Rc, A> IntoQuerySystem<(), (Ra, Rb, Rc), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, Rc, A, B> IntoQuerySystem<(), (Ra, Rb, Rc), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb, Rc, Rd> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), ()> for Func where Func: FnMut(Ra, Rb, Rc, Rd) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Rd, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Rd, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), ()> for Func where Func: FnMut(Ra, Rb, Rc, Rd, Re) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), ()> for Func where Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), ()> for Func where Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), ()> for Func where Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), ()> for Func where Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), ()> for Func where Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), ()> for Func where Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A,)> for Func where A: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, Rc: ResourceQuery, Rd: ResourceQuery, Re: ResourceQuery, Rf: ResourceQuery, Rg: ResourceQuery, Rh: ResourceQuery, Ri: ResourceQuery, Rj: ResourceQuery, [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

Loading content...

[−][src]Trait bevy::prelude::IntoQuerySystem

Required methods

fn system(self) -> Box<dyn System + 'static>

Implementors

impl<Func> IntoQuerySystem<(Commands,), (), ()> for Func where Func: FnMut(Commands) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func> IntoQuerySystem<(), (), ()> for Func where Func: FnMut() + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A> IntoQuerySystem<(Commands,), (), (A,)> for Func where A: Query, Func: FnMut(Commands, Query<'_, A>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A> IntoQuerySystem<(), (), (A,)> for Func where A: Query, Func: FnMut(Query<'_, A>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B> IntoQuerySystem<(Commands,), (), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B> IntoQuerySystem<(), (), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C> IntoQuerySystem<(Commands,), (), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C> IntoQuerySystem<(), (), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C, D> IntoQuerySystem<(Commands,), (), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C, D> IntoQuerySystem<(), (), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C, D, E> IntoQuerySystem<(Commands,), (), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C, D, E> IntoQuerySystem<(), (), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, A, B, C, D, E, F> IntoQuerySystem<(), (), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, Ra> IntoQuerySystem<(Commands,), (Ra,), ()> for Func where Func: FnMut(Commands, Ra) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, Ra> IntoQuerySystem<(), (Ra,), ()> for Func where Func: FnMut(Ra) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, Ra, A> IntoQuerySystem<(Commands,), (Ra,), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, [src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, Ra, A> IntoQuerySystem<(), (Ra,), (A,)> for Func where A: Query, Func: FnMut(Ra, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery, [src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, Ra, A, B> IntoQuerySystem<(), (Ra,), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery, [src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

impl<Func, Ra, Rb> IntoQuerySystem<(), (Ra, Rb), ()> for Func where Func: FnMut(Ra, Rb) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery, [src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

fn system(self) -> Box<dyn System + 'static>[src]

`fn system(self) -> Box<dyn System + 'static>`

`impl<Func> IntoQuerySystem<(Commands,), (), ()> for Func where Func: FnMut(Commands) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func> IntoQuerySystem<(), (), ()> for Func where Func: FnMut() + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A> IntoQuerySystem<(Commands,), (), (A,)> for Func where A: Query, Func: FnMut(Commands, Query<'_, A>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A> IntoQuerySystem<(), (), (A,)> for Func where A: Query, Func: FnMut(Query<'_, A>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B> IntoQuerySystem<(Commands,), (), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B> IntoQuerySystem<(), (), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Query<'_, A>, Query<'_, B>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C> IntoQuerySystem<(Commands,), (), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C> IntoQuerySystem<(), (), (A, B, C)> for Func where A: Query, B: Query, C: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D> IntoQuerySystem<(Commands,), (), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D> IntoQuerySystem<(), (), (A, B, C, D)> for Func where A: Query, B: Query, C: Query, D: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E> IntoQuerySystem<(Commands,), (), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E> IntoQuerySystem<(), (), (A, B, C, D, E)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E, F> IntoQuerySystem<(Commands,), (), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Commands, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, A, B, C, D, E, F> IntoQuerySystem<(), (), (A, B, C, D, E, F)> for Func where A: Query, B: Query, C: Query, D: Query, E: Query, F: Query, Func: FnMut(Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra> IntoQuerySystem<(Commands,), (Ra,), ()> for Func where Func: FnMut(Commands, Ra) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra> IntoQuerySystem<(), (Ra,), ()> for Func where Func: FnMut(Ra) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A> IntoQuerySystem<(Commands,), (Ra,), (A,)> for Func where A: Query, Func: FnMut(Commands, Ra, Query<'_, A>) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A> IntoQuerySystem<(), (Ra,), (A,)> for Func where A: Query, Func: FnMut(Ra, Query<'_, A>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, A, B> IntoQuerySystem<(), (Ra,), (A, B)> for Func where A: Query, B: Query, Func: FnMut(Ra, Query<'_, A>, Query<'_, B>) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, Query<'_, A>, Query<'_, B>) + Send + Sync + 'static, Ra: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`impl<Func, Ra, Rb> IntoQuerySystem<(), (Ra, Rb), ()> for Func where Func: FnMut(Ra, Rb) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static, Ra: ResourceQuery, Rb: ResourceQuery,` [src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]

`fn system(self) -> Box<dyn System + 'static>`[src]