Struct FunctionSystem

pub struct FunctionSystem<Marker, F>
where
    F: SystemParamFunction<Marker>,
{ /* private fields */ }

The System counter part of an ordinary function.

You get this by calling IntoSystem::into_system on a function that only accepts SystemParams. The output of the system becomes the functions return type, while the input becomes the functions first parameter or () if no such parameter exists.

FunctionSystem must be .initialized before they can be run.

The Clone implementation for FunctionSystem returns a new instance which is NOT initialized. The cloned system must also be .initialized before it can be run.

Implementations

impl<Marker, F> FunctionSystem<Marker, F>

where F: SystemParamFunction<Marker>,

pub fn with_name(self, new_name: impl Into<Cow<'static, str>>) -> Self

Return this system with a new name.

Useful to give closure systems more readable and unique names for debugging and tracing.

Trait Implementations

impl<Marker, F> Clone for FunctionSystem<Marker, F>

where F: SystemParamFunction<Marker> + Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Marker, F> ReadOnlySystem for FunctionSystem<Marker, F>

where Marker: 'static, F: SystemParamFunction<Marker>, F::Param: ReadOnlySystemParam,

SAFETY: F’s param is ReadOnlySystemParam, so this system will only read from the world.

fn run_readonly( &mut self, input: SystemIn<'_, Self>, world: &World, ) -> Self::Out

Runs this system with the given input in the world.

impl<Marker, F> System for FunctionSystem<Marker, F>

where Marker: 'static, F: SystemParamFunction<Marker>,

type In = <F as SystemParamFunction<Marker>>::In

The system’s input.

type Out = <F as SystemParamFunction<Marker>>::Out

The system’s output.

fn name(&self) -> Cow<'static, str>

Returns the system’s name.

fn component_access(&self) -> &Access<ComponentId>

Returns the system’s component Access.

fn archetype_component_access(&self) -> &Access<ArchetypeComponentId>

Returns the system’s archetype component Access.

fn is_send(&self) -> bool

Returns true if the system is Send.

fn is_exclusive(&self) -> bool

Returns true if the system must be run exclusively.

fn has_deferred(&self) -> bool

Returns true if system has deferred buffers.

unsafe fn run_unsafe( &mut self, input: SystemIn<'_, Self>, world: UnsafeWorldCell<'_>, ) -> Self::Out

Runs the system with the given input in the world. Unlike System::run, this function can be called in parallel with other systems and may break Rust’s aliasing rules if used incorrectly, making it unsafe to call.

fn apply_deferred(&mut self, world: &mut World)

Applies any Deferred system parameters (or other system buffers) of this system to the world.

fn queue_deferred(&mut self, world: DeferredWorld<'_>)

Enqueues any Deferred system parameters (or other system buffers) of this system into the world’s command buffer.

unsafe fn validate_param_unsafe( &mut self, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>

Validates that all parameters can be acquired and that system can run without panic. Built-in executors use this to prevent invalid systems from running.

fn initialize(&mut self, world: &mut World)

Initialize the system.

fn update_archetype_component_access(&mut self, world: UnsafeWorldCell<'_>)

Update the system’s archetype component Access.

fn check_change_tick(&mut self, change_tick: Tick)

Checks any Ticks stored on this system and wraps their value if they get too old.

fn default_system_sets(&self) -> Vec<InternedSystemSet>

Returns the system’s default system sets.

fn get_last_run(&self) -> Tick

Gets the tick indicating the last time this system ran.

fn set_last_run(&mut self, last_run: Tick)

Overwrites the tick indicating the last time this system ran.

fn type_id(&self) -> TypeId

Returns the TypeId of the underlying system type.

fn run(&mut self, input: SystemIn<'_, Self>, world: &mut World) -> Self::Out

Runs the system with the given input in the world.

fn run_without_applying_deferred( &mut self, input: SystemIn<'_, Self>, world: &mut World, ) -> Self::Out

Runs the system with the given input in the world.

fn validate_param( &mut self, world: &World, ) -> Result<(), SystemParamValidationError>

Safe version of System::validate_param_unsafe. that runs on exclusive, single-threaded world pointer.