Skip to main content

OnceFunctionSystem

pebble::ecs::system

Struct OnceFunctionSystem 

Source 
pub struct OnceFunctionSystem<F, Marker, State = ()> { /* private fields */ }
Expand description

Type-erased wrapper produced by OnceExt::once. Runs func every time it’s invoked until func returns Some(()), at which point it’s permanently retired — every subsequent invocation (and requirement check) is a no-op. The “have I already succeeded” bookkeeping lives entirely in done, hidden inside this wrapper; the wrapped function itself just returns None (“not ready, call me again”) or Some(()) (“done”).

Trait Implementations§

Source§

impl<T> IntoSystem<()> for OnceFunctionSystem<T, (), ()>
where T: for<'a> FnMut() -> Option<()> + 'static,

Source§

type System = OnceFunctionSystem<T, ()>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B> IntoSystem<(A, B)> for OnceFunctionSystem<T, (A, B), (A::State, B::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B), (<A as SystemParam>::State, <B as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C> IntoSystem<(A, B, C)> for OnceFunctionSystem<T, (A, B, C), (A::State, B::State, C::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D> IntoSystem<(A, B, C, D)> for OnceFunctionSystem<T, (A, B, C, D), (A::State, B::State, C::State, D::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E> IntoSystem<(A, B, C, D, E)> for OnceFunctionSystem<T, (A, B, C, D, E), (A::State, B::State, C::State, D::State, E::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E, F> IntoSystem<(A, B, C, D, E, F)> for OnceFunctionSystem<T, (A, B, C, D, E, F), (A::State, B::State, C::State, D::State, E::State, F::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E, F), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E, F, G> IntoSystem<(A, B, C, D, E, F, G)> for OnceFunctionSystem<T, (A, B, C, D, E, F, G), (A::State, B::State, C::State, D::State, E::State, F::State, G::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E, F, G), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E, F, G, H> IntoSystem<(A, B, C, D, E, F, G, H)> for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E, F, G, H), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E, F, G, H, I> IntoSystem<(A, B, C, D, E, F, G, H, I)> for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E, F, G, H, I, J> IntoSystem<(A, B, C, D, E, F, G, H, I, J)> for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State, J::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State, <J as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E, F, G, H, I, J, K> IntoSystem<(A, B, C, D, E, F, G, H, I, J, K)> for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State, J::State, K::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>, K::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static, K: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State, <J as SystemParam>::State, <K as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A, B, C, D, E, F, G, H, I, J, K, L> IntoSystem<(A, B, C, D, E, F, G, H, I, J, K, L)> for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K, L), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State, J::State, K::State, L::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>, K::Item<'a>, L::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static, K: SystemParam + 'static, L: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K, L), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State, <J as SystemParam>::State, <K as SystemParam>::State, <L as SystemParam>::State)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T, A> IntoSystem<(A,)> for OnceFunctionSystem<T, (A,), (A::State,)>
where T: for<'a> FnMut(A::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static,

Source§

type System = OnceFunctionSystem<T, (A,), (<A as SystemParam>::State,)>

Source§

fn into_system(self) -> Self::System

Source§

impl<T> System for OnceFunctionSystem<T, (), ()>
where T: for<'a> FnMut() -> Option<()> + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A> System for OnceFunctionSystem<T, (A,), (A::State,)>
where T: for<'a> FnMut(A::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B> System for OnceFunctionSystem<T, (A, B), (A::State, B::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C> System for OnceFunctionSystem<T, (A, B, C), (A::State, B::State, C::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D> System for OnceFunctionSystem<T, (A, B, C, D), (A::State, B::State, C::State, D::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E> System for OnceFunctionSystem<T, (A, B, C, D, E), (A::State, B::State, C::State, D::State, E::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E, F> System for OnceFunctionSystem<T, (A, B, C, D, E, F), (A::State, B::State, C::State, D::State, E::State, F::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E, F, G> System for OnceFunctionSystem<T, (A, B, C, D, E, F, G), (A::State, B::State, C::State, D::State, E::State, F::State, G::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E, F, G, H> System for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E, F, G, H, I> System for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E, F, G, H, I, J> System for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State, J::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E, F, G, H, I, J, K> System for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State, J::State, K::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>, K::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static, K: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.
Source§

impl<T, A, B, C, D, E, F, G, H, I, J, K, L> System for OnceFunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K, L), (A::State, B::State, C::State, D::State, E::State, F::State, G::State, H::State, I::State, J::State, K::State, L::State)>
where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>, K::Item<'a>, L::Item<'a>) -> Option<()> + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static, K: SystemParam + 'static, L: SystemParam + 'static,

Source§

fn run(&mut self, _world: &World, _resources: &Resources)

Source§

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.
Source§

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.

Auto Trait Implementations§

§

impl<F, Marker, State> Freeze for OnceFunctionSystem<F, Marker, State>
where F: Freeze, State: Freeze,

§

impl<F, Marker, State> RefUnwindSafe for OnceFunctionSystem<F, Marker, State>
where F: RefUnwindSafe, State: RefUnwindSafe, Marker: RefUnwindSafe,

§

impl<F, Marker, State> Send for OnceFunctionSystem<F, Marker, State>
where F: Send, State: Send, Marker: Send,

§

impl<F, Marker, State> Sync for OnceFunctionSystem<F, Marker, State>
where F: Sync, State: Sync, Marker: Sync,

§

impl<F, Marker, State> Unpin for OnceFunctionSystem<F, Marker, State>
where F: Unpin, State: Unpin, Marker: Unpin,

§

impl<F, Marker, State> UnsafeUnpin for OnceFunctionSystem<F, Marker, State>
where F: UnsafeUnpin, State: UnsafeUnpin,

§

impl<F, Marker, State> UnwindSafe for OnceFunctionSystem<F, Marker, State>
where F: UnwindSafe, State: UnwindSafe, Marker: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> Component for T
where T: Send + Sync + 'static,

Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<Marker, T> RunIfExt<Marker> for T
where T: IntoSystem<Marker>,

Source§

fn run_if<C: RunCondition>(self) -> RunIfSystem<Self, Marker, C>

Source§

impl<Marker, T> RunIfFnExt<Marker> for T
where T: IntoSystem<Marker>,

Source§

fn run_if_fn<F>(self, cond: F) -> RunIfFnSystem<Self, Marker, F>
where F: Fn(&World, &Resources) -> bool + 'static,

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<T> WasmNotSend for T
where T: Send,

Source§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

Source§

impl<T> WasmNotSync for T
where T: Sync,

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more