Trait IntoObserverSystem 

pub trait IntoObserverSystem<E, Marker> {
    type System: ObserverSystem<E>;

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

Required Associated Types

type System: ObserverSystem<E>

Required Methods

fn into_observer_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, Evt: 'static, A, B, C, D, E, F, G, H, I, J, K, L> IntoObserverSystem<Evt, (A, B, C, D, E, F, G, H, I, J, K, L)> for T

where T: FnMut(Trigger<'_, Evt>, A, B, C, D, E, F, G, H, I, J, K, L) + for<'a> FnMut(Trigger<'a, Evt>, 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, 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 = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D, E, F, G, H, I, J, K> IntoObserverSystem<Evt, (A, B, C, D, E, F, G, H, I, J, K)> for T

where T: FnMut(Trigger<'_, Evt>, A, B, C, D, E, F, G, H, I, J, K) + for<'a> FnMut(Trigger<'a, Evt>, 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, 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 = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D, E, F, G, H, I, J> IntoObserverSystem<Evt, (A, B, C, D, E, F, G, H, I, J)> for T

where T: FnMut(Trigger<'_, Evt>, A, B, C, D, E, F, G, H, I, J) + for<'a> FnMut(Trigger<'a, Evt>, 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, 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 = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D, E, F, G, H, I> IntoObserverSystem<Evt, (A, B, C, D, E, F, G, H, I)> for T

where T: FnMut(Trigger<'_, Evt>, A, B, C, D, E, F, G, H, I) + for<'a> FnMut(Trigger<'a, Evt>, 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, 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 = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D, E, F, G, H> IntoObserverSystem<Evt, (A, B, C, D, E, F, G, H)> for T

where T: FnMut(Trigger<'_, Evt>, A, B, C, D, E, F, G, H) + for<'a> FnMut(Trigger<'a, Evt>, 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, 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 = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D, E, F, G> IntoObserverSystem<Evt, (A, B, C, D, E, F, G)> for T

where T: FnMut(Trigger<'_, Evt>, A, B, C, D, E, F, G) + for<'a> FnMut(Trigger<'a, Evt>, A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static,

type System = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D, E, F> IntoObserverSystem<Evt, (A, B, C, D, E, F)> for T

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

type System = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D, E> IntoObserverSystem<Evt, (A, B, C, D, E)> for T

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

type System = FunctionObserver<T, Evt, (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, Evt: 'static, A, B, C, D> IntoObserverSystem<Evt, (A, B, C, D)> for T

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

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

impl<T, Evt: 'static, A, B, C> IntoObserverSystem<Evt, (A, B, C)> for T

where T: FnMut(Trigger<'_, Evt>, A, B, C) + for<'a> FnMut(Trigger<'a, Evt>, A::Item<'a>, B::Item<'a>, C::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static,

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

impl<T, Evt: 'static, A, B> IntoObserverSystem<Evt, (A, B)> for T

where T: FnMut(Trigger<'_, Evt>, A, B) + for<'a> FnMut(Trigger<'a, Evt>, A::Item<'a>, B::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static,

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

impl<T, Evt: 'static, A> IntoObserverSystem<Evt, (A,)> for T

where T: FnMut(Trigger<'_, Evt>, A) + for<'a> FnMut(Trigger<'a, Evt>, A::Item<'a>) + 'static, A: SystemParam + 'static,

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

impl<T, Evt: 'static> IntoObserverSystem<Evt, ()> for T

where T: FnMut(Trigger<'_, Evt>) + for<'a> FnMut(Trigger<'a, Evt>) + 'static,

type System = FunctionObserver<T, Evt, ()>