Trait SystemParam 

pub trait SystemParam {
    type Item<'a>;
    type State: Default + 'static;

    // Required method
    fn fetch<'a>(
        state: &'a mut Self::State,
        world: &'a World,
        resources: &'a Resources,
    ) -> Self::Item<'a>;
}

Trait implemented for each valid system parameter type.

The macro-generated [impl_system!] blanket implementations use this to fetch each parameter from the world and resources before calling the system function. State is per-system storage owned by the FunctionSystem itself (as opposed to Item, which only lives for the duration of one call) — this is what lets Local persist between runs.

Required Associated Types

type Item<'a>

type State: Default + 'static

Required Methods

fn fetch<'a>( state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<T> SystemParam for Option<AsyncEventWriter<'static, T>>

where T: Send + Sync + 'static,

Soft-access variant of AsyncEventWriter<T>: None instead of panicking while T isn’t registered via add_async_event (or BackgroundTasksPlugin isn’t installed yet). Useful for systems that only opportunistically spawn background work and shouldn’t hard-fail while the app is still assembling its plugins.

type Item<'a> = Option<AsyncEventWriter<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<EventReader<'static, T>>

where T: Send + Sync + 'static,

Soft-access variant of EventReader<T>: None instead of panicking while T isn’t registered (via App::add_event), so a system that should just skip when an event type it optionally consumes hasn’t been set up yet doesn’t have to hard-depend on it. The read cursor still persists correctly across ticks once the event type does appear later — it lives in the same per-system State slot either way.

type Item<'a> = Option<EventReader<'a, T>>

type State = usize

fn fetch<'a>( state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<EventWriter<'static, T>>

where T: Send + Sync + 'static,

Soft-access variant of EventWriter<T>: None instead of panicking while T isn’t registered (via App::add_event).

type Item<'a> = Option<EventWriter<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<Res<'static, T>>

where T: 'static + Sync + Send,

type Item<'a> = Option<Res<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resource: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<ResMut<'static, T>>

where T: 'static + Sync + Send,

type Item<'a> = Option<ResMut<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resource: &'a Resources, ) -> Self::Item<'a>

Implementors

impl SystemParam for &'static Resources

type Item<'a> = &'a Resources

type State = ()

impl SystemParam for &'static World

type Item<'a> = &'a World

type State = ()

impl SystemParam for Commands<'static>

type Item<'a> = Commands<'a>

type State = ()

impl<Q> SystemParam for Query<'static, Q>

where Q: Query + 'static,

type Item<'a> = Query<'a, Q>

type State = ()

impl<T> SystemParam for AsyncEventWriter<'static, T>

where T: Send + Sync + 'static,

type Item<'a> = AsyncEventWriter<'a, T>

type State = ()

impl<T> SystemParam for EventReader<'static, T>

where T: Send + Sync + 'static,

type Item<'a> = EventReader<'a, T>

type State = usize

impl<T> SystemParam for EventWriter<'static, T>

where T: Send + Sync + 'static,

type Item<'a> = EventWriter<'a, T>

type State = ()

impl<T> SystemParam for Local<'static, T>

where T: Default + Send + Sync + 'static,

type Item<'a> = Local<'a, T>

type State = T

impl<T> SystemParam for Res<'static, T>

where T: 'static + Sync + Send,

type Item<'a> = Res<'a, T>

type State = ()

impl<T> SystemParam for ResMut<'static, T>

where T: 'static + Sync + Send,

type Item<'a> = ResMut<'a, T>

type State = ()