Trait IntoSystem

pub trait IntoSystem<In, Out, Marker>: Sized {
    type System: System<In = In, Out = Out>;

    // Required method
    fn into_system(this: Self) -> Self::System;

    // Provided methods
    fn pipe<B, Final, MarkerB>(
        self,
        system: B,
    ) -> PipeSystem<Self::System, B::System>
       where B: IntoSystem<Out, Final, MarkerB> { ... }
    fn map<T, F>(self, f: F) -> AdapterSystem<F, Self::System>
       where F: Send + Sync + 'static + FnMut(Out) -> T { ... }
    fn system_type_id(&self) -> TypeId { ... }
}

Conversion trait to turn something into a System.

Use this to get a system from a function. Also note that every system implements this trait as well.

Examples

use bevy_ecs::prelude::*;

fn my_system_function(a_usize_local: Local<usize>) {}

let system = IntoSystem::into_system(my_system_function);

Required Associated Types

type System: System<In = In, Out = Out>

The type of System that this instance converts into.

Required Methods

fn into_system(this: Self) -> Self::System

Turns this value into its corresponding System.

Provided Methods

fn pipe<B, Final, MarkerB>( self, system: B, ) -> PipeSystem<Self::System, B::System>

where B: IntoSystem<Out, Final, MarkerB>,

Pass the output of this system A into a second system B, creating a new compound system.

The second system must have In<T> as its first parameter, where T is the return type of the first system.

fn map<T, F>(self, f: F) -> AdapterSystem<F, Self::System>

where F: Send + Sync + 'static + FnMut(Out) -> T,

Pass the output of this system into the passed function f, creating a new system that outputs the value returned from the function.

// Ignores the output of a system that may fail.
schedule.add_systems(my_system.map(drop));

fn my_system(res: Res<T>) -> Result<(), Err> {
    // ...
}

fn system_type_id(&self) -> TypeId

Get the TypeId of the System produced after calling into_system.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Marker, F> IntoSystem<<F as ExclusiveSystemParamFunction<Marker>>::In, <F as ExclusiveSystemParamFunction<Marker>>::Out, (IsExclusiveFunctionSystem, Marker)> for F

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

type System = ExclusiveFunctionSystem<Marker, F>

impl<Marker, F> IntoSystem<<F as SystemParamFunction<Marker>>::In, <F as SystemParamFunction<Marker>>::Out, (IsFunctionSystem, Marker)> for F

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

type System = FunctionSystem<Marker, F>

impl<T: System> IntoSystem<<T as System>::In, <T as System>::Out, ()> for T

type System = T