Struct SystemState 

pub struct SystemState<Param>
where
    Param: SystemParam + 'static,
{ /* private fields */ }

Holds on to persistent state required to drive SystemParam for a System.

This is a powerful and convenient tool for working with exclusive world access, allowing you to fetch data from the World as if you were running a System. However, simply calling world::run_system(my_system) using a World::run_system can be significantly simpler and ensures that change detection and command flushing work as expected.

Borrow-checking is handled for you, allowing you to mutably access multiple compatible system parameters at once, and arbitrary system parameters (like MessageWriter) can be conveniently fetched.

For an alternative approach to split mutable access to the world, see World::resource_scope.

Warning

SystemState values created can be cached to improve performance, and must be cached and reused in order for system parameters that rely on local state to work correctly. These include:

• Added, Changed and Spawned query filters
• Local variables that hold state
• MessageReader system parameters, which rely on a Local to track which messages have been seen

Note that this is automatically handled for you when using a World::run_system.

Example

Basic usage:

// Work directly on the `World`
let mut world = World::new();
world.init_resource::<Messages<MyMessage>>();

// Construct a `SystemState` struct, passing in a tuple of `SystemParam`
// as if you were writing an ordinary system.
let mut system_state: SystemState<(
    MessageWriter<MyMessage>,
    Option<ResMut<MyResource>>,
    Query<&MyComponent>,
)> = SystemState::new(&mut world);

// Use system_state.get_mut(&mut world) and unpack your system parameters into variables!
// system_state.get(&world) provides read-only versions of your system parameters instead.
let (message_writer, maybe_resource, query) = system_state.get_mut(&mut world);

// If you are using `Commands`, you can choose when you want to apply them to the world.
// You need to manually call `.apply(world)` on the `SystemState` to apply them.

Caching:

#[derive(Resource)]
struct CachedSystemState {
    message_state: SystemState<MessageReader<'static, 'static, MyMessage>>,
}

// Create and store a system state once
let mut world = World::new();
world.init_resource::<Messages<MyMessage>>();
let initial_state: SystemState<MessageReader<MyMessage>> = SystemState::new(&mut world);

// The system state is cached in a resource
world.insert_resource(CachedSystemState {
    message_state: initial_state,
});

// Later, fetch the cached system state, saving on overhead
world.resource_scope(|world, mut cached_state: Mut<CachedSystemState>| {
    let mut message_reader = cached_state.message_state.get_mut(world);

    for message in message_reader.read() {
        println!("Hello World!");
    }
});

Exclusive System:

fn exclusive_system(world: &mut World, system_state: &mut SystemState<MessageReader<MyMessage>>) {
    let mut message_reader = system_state.get_mut(world);

    for message in message_reader.read() {
        println!("Hello World!");
    }
}

Implementations

impl SystemState<()>

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut() -> InnerOut + SystemParamFunction<Marker, Param = (), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input) -> InnerOut + SystemParamFunction<Marker, Param = (), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P> SystemState<(P,)>

where P: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P,), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P,), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1> SystemState<(P0, P1)>

where P0: SystemParam, P1: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2> SystemState<(P0, P1, P2)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3> SystemState<(P0, P1, P2, P3)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4> SystemState<(P0, P1, P2, P3, P4)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5> SystemState<(P0, P1, P2, P3, P4, P5)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6> SystemState<(P0, P1, P2, P3, P4, P5, P6)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam, P9: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam, P9: SystemParam, P10: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam, P9: SystemParam, P10: SystemParam, P11: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam, P9: SystemParam, P10: SystemParam, P11: SystemParam, P12: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam, P9: SystemParam, P10: SystemParam, P11: SystemParam, P12: SystemParam, P13: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>, <P13 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>, <P13 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam, P9: SystemParam, P10: SystemParam, P11: SystemParam, P12: SystemParam, P13: SystemParam, P14: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>, <P13 as SystemParam>::Item<'_, '_>, <P14 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>, <P13 as SystemParam>::Item<'_, '_>, <P14 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> SystemState<(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>

where P0: SystemParam, P1: SystemParam, P2: SystemParam, P3: SystemParam, P4: SystemParam, P5: SystemParam, P6: SystemParam, P7: SystemParam, P8: SystemParam, P9: SystemParam, P10: SystemParam, P11: SystemParam, P12: SystemParam, P13: SystemParam, P14: SystemParam, P15: SystemParam,

pub fn build_system<InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(<P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>, <P13 as SystemParam>::Item<'_, '_>, <P14 as SystemParam>::Item<'_, '_>, <P15 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), In = (), Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with no input. You can use SystemState::build_system_with_input() if you have input, or SystemState::build_any_system() if you don’t need type inference.

pub fn build_system_with_input<Input, InnerOut, Out, Marker, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where Input: SystemInput, InnerOut: IntoResult<Out>, Out: 'static, F: FnMut(Input, <P0 as SystemParam>::Item<'_, '_>, <P1 as SystemParam>::Item<'_, '_>, <P2 as SystemParam>::Item<'_, '_>, <P3 as SystemParam>::Item<'_, '_>, <P4 as SystemParam>::Item<'_, '_>, <P5 as SystemParam>::Item<'_, '_>, <P6 as SystemParam>::Item<'_, '_>, <P7 as SystemParam>::Item<'_, '_>, <P8 as SystemParam>::Item<'_, '_>, <P9 as SystemParam>::Item<'_, '_>, <P10 as SystemParam>::Item<'_, '_>, <P11 as SystemParam>::Item<'_, '_>, <P12 as SystemParam>::Item<'_, '_>, <P13 as SystemParam>::Item<'_, '_>, <P14 as SystemParam>::Item<'_, '_>, <P15 as SystemParam>::Item<'_, '_>) -> InnerOut + SystemParamFunction<Marker, Param = (P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), In = Input, Out = InnerOut>,

Create a FunctionSystem from a SystemState. This method signature allows type inference of closure parameters for a system with input. You can use SystemState::build_system() if you have no input, or SystemState::build_any_system() if you don’t need type inference.

impl<Param> SystemState<Param>

where Param: SystemParam,

pub fn new(world: &mut World) -> SystemState<Param>

Creates a new SystemState with default state.

pub fn build_any_system<Marker, Out, F>( self, func: F, ) -> FunctionSystem<Marker, Out, F>

where F: SystemParamFunction<Marker, Param = Param>, <F as SystemParamFunction<Marker>>::Out: IntoResult<Out>,

Create a FunctionSystem from a SystemState. This method signature allows any system function, but the compiler will not perform type inference on closure parameters. You can use SystemState::build_system() or SystemState::build_system_with_input() to get type inference on parameters.

pub fn meta(&self) -> &SystemMeta

Gets the metadata for this instance.

pub fn meta_mut(&mut self) -> &mut SystemMeta

Gets the metadata for this instance.

pub fn get<'w, 's>( &'s mut self, world: &'w World, ) -> <Param as SystemParam>::Item<'w, 's>

where Param: ReadOnlySystemParam,

Retrieve the SystemParam values. This can only be called when all parameters are read-only.

pub fn get_mut<'w, 's>( &'s mut self, world: &'w mut World, ) -> <Param as SystemParam>::Item<'w, 's>

Retrieve the mutable SystemParam values.

pub fn apply(&mut self, world: &mut World)

Applies all state queued up for SystemParam values. For example, this will apply commands queued up by a Commands parameter to the given World. This function should be called manually after the values returned by SystemState::get and SystemState::get_mut are finished being used.

pub unsafe fn validate_param( state: &mut SystemState<Param>, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>

Wrapper over SystemParam::validate_param.

Safety

• The passed UnsafeWorldCell must have read-only access to world data in component_access_set.
• world must be the same World that was used to initialize state.

pub fn matches_world(&self, world_id: WorldId) -> bool

Returns true if world_id matches the World that was used to call SystemState::new. Otherwise, this returns false.

pub fn update_archetypes(&mut self, _world: &World)

👎Deprecated since 0.17.0: No longer has any effect. Calls may be removed.

Has no effect

pub fn update_archetypes_unsafe_world_cell( &mut self, _world: UnsafeWorldCell<'_>, )

👎Deprecated since 0.17.0: No longer has any effect. Calls may be removed.

Has no effect

pub fn get_manual<'w, 's>( &'s mut self, world: &'w World, ) -> <Param as SystemParam>::Item<'w, 's>

where Param: ReadOnlySystemParam,

👎Deprecated since 0.17.0: Call SystemState::get instead.

Identical to SystemState::get.

pub fn get_manual_mut<'w, 's>( &'s mut self, world: &'w mut World, ) -> <Param as SystemParam>::Item<'w, 's>

👎Deprecated since 0.17.0: Call SystemState::get_mut instead.

Identical to SystemState::get_mut.

pub unsafe fn get_unchecked_manual<'w, 's>( &'s mut self, world: UnsafeWorldCell<'w>, ) -> <Param as SystemParam>::Item<'w, 's>

👎Deprecated since 0.17.0: Call SystemState::get_unchecked instead.

Identical to SystemState::get_unchecked.

Safety

This call might access any of the input parameters in a way that violates Rust’s mutability rules. Make sure the data access is safe in the context of global World access. The passed-in World must be the World the SystemState was created with.

pub unsafe fn get_unchecked<'w, 's>( &'s mut self, world: UnsafeWorldCell<'w>, ) -> <Param as SystemParam>::Item<'w, 's>

Retrieve the SystemParam values.

Safety

This call might access any of the input parameters in a way that violates Rust’s mutability rules. Make sure the data access is safe in the context of global World access. The passed-in World must be the World the SystemState was created with.

pub fn param_state(&self) -> &<Param as SystemParam>::State

Returns a reference to the current system param states.

pub unsafe fn param_state_mut(&mut self) -> &mut <Param as SystemParam>::State

Returns a mutable reference to the current system param states. Marked as unsafe because modifying the system states may result in violation to certain assumptions made by the SystemParam. Use with care.

Safety

Modifying the system param states may have unintended consequences. The param state is generally considered to be owned by the SystemParam. Modifications should respect any invariants as required by the SystemParam. For example, modifying the system state of ResMut will obviously create issues.

Trait Implementations

impl<'a, P> ExclusiveSystemParam for &'a mut SystemState<P>

where P: SystemParam + 'static,

type State = SystemState<P>

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

type Item<'s> = &'s mut SystemState<P>

The item type returned when constructing this system param. See SystemParam::Item.

fn init( world: &mut World, _system_meta: &mut SystemMeta, ) -> <&'a mut SystemState<P> as ExclusiveSystemParam>::State

Creates a new instance of this param’s State.

fn get_param<'s>( state: &'s mut <&'a mut SystemState<P> as ExclusiveSystemParam>::State, _system_meta: &SystemMeta, ) -> <&'a mut SystemState<P> as ExclusiveSystemParam>::Item<'s>

Creates a parameter to be passed into an ExclusiveSystemParamFunction.

impl<Param> FromWorld for SystemState<Param>

where Param: SystemParam,

fn from_world(world: &mut World) -> SystemState<Param>

Creates Self using data from the given World.