Struct valence::ecs::system::StaticSystemParam

pub struct StaticSystemParam<'w, 's, P>(/* private fields */)
where
    P: SystemParam;

A helper for using system parameters in generic contexts

This type is a SystemParam adapter which always has Self::State::Item == Self (ignoring lifetimes for brevity), no matter the argument SystemParam (P) (other than that P must be 'static)

This makes it useful for having arbitrary SystemParam type arguments to function systems, or for generic types using the SystemParam derive:

use bevy_ecs::system::{SystemParam, StaticSystemParam};
#[derive(SystemParam)]
struct GenericParam<'w,'s, T: SystemParam + 'static> {
    field: StaticSystemParam<'w, 's, T>,
}
fn do_thing_generically<T: SystemParam + 'static>(t: StaticSystemParam<T>) {}

fn check_always_is_system<T: SystemParam + 'static>(){
    bevy_ecs::system::assert_is_system(do_thing_generically::<T>);
}

Note that in a real case you’d generally want additional bounds on P, for your use of the parameter to have a reason to be generic.

For example, using this would allow a type to be generic over whether a resource is accessed mutably or not, with impls being bounded on P: Deref<Target=MyType>, and P: DerefMut<Target=MyType> depending on whether the method requires mutable access or not.

The method which doesn’t use this type will not compile:

fn do_thing_generically<T: SystemParam + 'static>(t: T) {}

#[derive(SystemParam)]
struct GenericParam<'w, 's, T: SystemParam> {
    field: T,
    // Use the lifetimes in this type, or they will be unbound.
    phantom: core::marker::PhantomData<&'w &'s ()>
}

Implementations

impl<'w, 's, P> StaticSystemParam<'w, 's, P>

where P: SystemParam,

pub fn into_inner(self) -> <P as SystemParam>::Item<'w, 's>

Get the value of the parameter

Trait Implementations

impl<'w, 's, P> Deref for StaticSystemParam<'w, 's, P>

where P: SystemParam,

type Target = <P as SystemParam>::Item<'w, 's>

The resulting type after dereferencing.

fn deref(&self) -> &<StaticSystemParam<'w, 's, P> as Deref>::Target

Dereferences the value.

impl<'w, 's, P> DerefMut for StaticSystemParam<'w, 's, P>

where P: SystemParam,

fn deref_mut(&mut self) -> &mut <StaticSystemParam<'w, 's, P> as Deref>::Target

Mutably dereferences the value.

impl<P> SystemParam for StaticSystemParam<'_, '_, P>

where P: SystemParam + 'static,

type State = <P as SystemParam>::State

Used to store data which persists across invocations of a system.

type Item<'world, 'state> = StaticSystemParam<'world, 'state, P>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state( world: &mut World, system_meta: &mut SystemMeta, ) -> <StaticSystemParam<'_, '_, P> as SystemParam>::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.

unsafe fn new_archetype( state: &mut <StaticSystemParam<'_, '_, P> as SystemParam>::State, archetype: &Archetype, system_meta: &mut SystemMeta, )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).a

fn apply( state: &mut <StaticSystemParam<'_, '_, P> as SystemParam>::State, system_meta: &SystemMeta, world: &mut World, )

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during apply_deferred.

fn queue( state: &mut <StaticSystemParam<'_, '_, P> as SystemParam>::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next apply_deferred.

unsafe fn get_param<'world, 'state>( state: &'state mut <StaticSystemParam<'_, '_, P> as SystemParam>::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'world>, change_tick: Tick, ) -> <StaticSystemParam<'_, '_, P> as SystemParam>::Item<'world, 'state>

Creates a parameter to be passed into a SystemParamFunction.

impl<'w, 's, P> ReadOnlySystemParam for StaticSystemParam<'w, 's, P>

where P: ReadOnlySystemParam + 'static,