Trait IntoSystem 

pub trait IntoSystem<Marker> {
    type System: System;

    // Required method
    fn into_system(self) -> Self::System;
}

Converts a function (or closure) with valid system parameters into a System that can be registered with App::add_system.

Implemented via the [impl_system!] macro for function arities 0–8.

Required Associated Types

type System: System

Required Methods

fn into_system(self) -> Self::System

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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,

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)>

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 T

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>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E, F, G, H, I, J, K, L), 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,

type System = FunctionSystem<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)>

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,

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)>

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 T

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>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E, F, G, H, I, J, K), 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,

type System = FunctionSystem<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)>

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,

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)>

impl<T, A, B, C, D, E, F, G, H, I, J> IntoSystem<(A, B, C, D, E, F, G, H, I, J)> for T

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>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E, F, G, H, I, J), 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,

type System = FunctionSystem<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)>

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,

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)>

impl<T, A, B, C, D, E, F, G, H, I> IntoSystem<(A, B, C, D, E, F, G, H, I)> for T

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>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E, F, G, H, I), 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,

type System = FunctionSystem<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)>

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,

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)>

impl<T, A, B, C, D, E, F, G, H> IntoSystem<(A, B, C, D, E, F, G, H)> for T

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>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E, F, G, H), A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static,

type System = FunctionSystem<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)>

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,

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)>

impl<T, A, B, C, D, E, F, G> IntoSystem<(A, B, C, D, E, F, G)> for T

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>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E, F, G), A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static,

type System = FunctionSystem<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)>

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,

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)>

impl<T, A, B, C, D, E, F> IntoSystem<(A, B, C, D, E, F)> for T

where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E, F), A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static,

type System = FunctionSystem<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)>

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,

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)>

impl<T, A, B, C, D, E> IntoSystem<(A, B, C, D, E)> for T

where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D, E), A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static,

type System = FunctionSystem<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)>

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,

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

impl<T, A, B, C, D> IntoSystem<(A, B, C, D)> for T

where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>) + 'static, for<'a> &'a mut T: FnMut(A, B, C, D), A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static,

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

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,

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

impl<T, A, B, C> IntoSystem<(A, B, C)> for T

where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>) + 'static, for<'a> &'a mut T: FnMut(A, B, C), A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static,

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

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,

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

impl<T, A, B> IntoSystem<(A, B)> for T

where T: for<'a> FnMut(A::Item<'a>, B::Item<'a>) + 'static, for<'a> &'a mut T: FnMut(A, B), A: SystemParam + 'static, B: SystemParam + 'static,

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

impl<T, A> IntoSystem<(A,)> for OnceFunctionSystem<T, (A,), (A::State,)>

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

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

impl<T, A> IntoSystem<(A,)> for T

where T: for<'a> FnMut(A::Item<'a>) + 'static, for<'a> &'a mut T: FnMut(A), A: SystemParam + 'static,

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

impl<T, Marker, C> IntoSystem<Marker> for RunIfSystem<T, Marker, C>

where T: IntoSystem<Marker>, C: RunCondition,

type System = Conditional<<T as IntoSystem<Marker>>::System, C>

impl<T, Marker, F> IntoSystem<Marker> for RunIfFnSystem<T, Marker, F>

where T: IntoSystem<Marker>, F: Fn(&World, &Resources) -> bool + 'static, Marker: 'static,

type System = ConditionalFn<<T as IntoSystem<Marker>>::System, F>

impl<T> IntoSystem<()> for OnceFunctionSystem<T, (), ()>

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

type System = OnceFunctionSystem<T, ()>

impl<T> IntoSystem<()> for T

where T: for<'a> FnMut() + 'static, for<'a> &'a mut T: FnMut(),

type System = FunctionSystem<T, ()>