Struct DynSystemParam 

pub struct DynSystemParam<'w, 's> { /* private fields */ }

A SystemParam with a type that can be configured at runtime.

To be useful, this must be configured using a DynParamBuilder to build the system using a SystemParamBuilder.

Examples

// If the inner parameter doesn't require any special building, use `ParamBuilder`.
// Either specify the type parameter on `DynParamBuilder::new()` ...
let system = (DynParamBuilder::new::<Res<A>>(ParamBuilder),)
    .build_state(&mut world)
    .build_system(expects_res_a);

// ... or use a factory method on `ParamBuilder` that returns a specific type.
let system = (DynParamBuilder::new(ParamBuilder::resource::<A>()),)
    .build_state(&mut world)
    .build_system(expects_res_a);

fn expects_res_a(mut param: DynSystemParam) {
    // Use the `downcast` methods to retrieve the inner parameter.
    // They will return `None` if the type does not match.
    assert!(param.is::<Res<A>>());
    assert!(!param.is::<Res<B>>());
    assert!(param.downcast_mut::<Res<B>>().is_none());
    let res = param.downcast_mut::<Res<A>>().unwrap();
    // The type parameter can be left out if it can be determined from use.
    let res: Res<A> = param.downcast().unwrap();
}

let system = (
    // If the inner parameter also requires building,
    // pass the appropriate `SystemParamBuilder`.
    DynParamBuilder::new(LocalBuilder(10usize)),
    // `DynSystemParam` is just an ordinary `SystemParam`,
    // and can be combined with other parameters as usual!
    ParamBuilder::query(),
)
    .build_state(&mut world)
    .build_system(|param: DynSystemParam, query: Query<()>| {
        let local: Local<usize> = param.downcast::<Local<usize>>().unwrap();
        assert_eq!(*local, 10);
    });

Implementations

impl<'w, 's> DynSystemParam<'w, 's>

pub fn is<T>(&self) -> bool

where T: SystemParam, <T as SystemParam>::Item<'static, 'static>: SystemParam<Item<'w, 's> = T> + 'static,

Returns true if the inner system param is the same as T.

pub fn downcast<T>(self) -> Option<T>

where T: SystemParam, <T as SystemParam>::Item<'static, 'static>: SystemParam<Item<'w, 's> = T> + 'static,

Returns the inner system param if it is the correct type. This consumes the dyn param, so the returned param can have its original world and state lifetimes.

pub fn downcast_mut<'a, T>(&'a mut self) -> Option<T>

where T: SystemParam, <T as SystemParam>::Item<'static, 'static>: SystemParam<Item<'a, 'a> = T> + 'static,

Returns the inner system parameter if it is the correct type. This borrows the dyn param, so the returned param is only valid for the duration of that borrow.

pub fn downcast_mut_inner<'a, T>(&'a mut self) -> Option<T>

where T: ReadOnlySystemParam, <T as SystemParam>::Item<'static, 'static>: SystemParam<Item<'w, 'a> = T> + 'static,

Returns the inner system parameter if it is the correct type. This borrows the dyn param, so the returned param is only valid for the duration of that borrow, but since it only performs read access it can keep the original world lifetime. This can be useful with methods like Query::iter_inner() or Res::into_inner() to obtain references with the original world lifetime.

Trait Implementations

impl SystemParam for DynSystemParam<'_, '_>

type State = DynSystemParamState

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

type Item<'world, 'state> = DynSystemParam<'world, 'state>

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, ) -> <DynSystemParam<'_, '_> as SystemParam>::State

Creates a new instance of this param’s State.

fn init_access( state: &<DynSystemParam<'_, '_> as SystemParam>::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )

Registers any World access used by this SystemParam.

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

Creates a parameter to be passed into a SystemParamFunction.

fn apply( state: &mut <DynSystemParam<'_, '_> 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 ApplyDeferred.

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

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

impl<'a, 'w, 's> SystemParamBuilder<DynSystemParam<'w, 's>> for DynParamBuilder<'a>

fn build( self, world: &mut World, ) -> <DynSystemParam<'w, 's> as SystemParam>::State

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

fn build_state(self, world: &mut World) -> SystemState<P>

Create a SystemState from a SystemParamBuilder. To create a system, call SystemState::build_system on the result.

fn build_system<Marker, In, Out, Func>( self, func: Func, ) -> IntoBuilderSystem<Marker, In, Out, Func, Self>

where Self: 'static, Func: SystemParamFunction<Marker, Param = P>,

Create a System from a SystemParamBuilder directly.