Trait SystemInput

pub trait SystemInput: Sized {
    type Param<'i>: SystemInput;
    type Inner<'i>;

    // Required method
    fn wrap(this: Self::Inner<'_>) -> Self::Param<'_>;
}

Trait for types that can be used as input to Systems.

Provided implementations are:

• (): No input
• In<T>: For values
• InRef<T>: For read-only references to values
• InMut<T>: For mutable references to values
• Trigger<E, B>: For ObserverSystems
• StaticSystemInput<I>: For arbitrary SystemInputs in generic contexts
• Tuples of SystemInputs up to 8 elements

For advanced usecases, you can implement this trait for your own types.

Examples

Tuples of SystemInputs

use bevy_ecs::prelude::*;

fn add((InMut(a), In(b)): (InMut<usize>, In<usize>)) {
    *a += b;
}

Required Associated Types

type Param<'i>: SystemInput

The wrapper input type that is defined as the first argument to FunctionSystems.

type Inner<'i>

The inner input type that is passed to functions that run systems, such as System::run.

Required Methods

fn wrap(this: Self::Inner<'_>) -> Self::Param<'_>

Converts a SystemInput::Inner into a SystemInput::Param.

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.

Implementations on Foreign Types

impl SystemInput for ()

type Param<'i> = ()

type Inner<'i> = ()

fn wrap(this: Self::Inner<'_>) -> Self::Param<'_>

impl<I: SystemInput> SystemInput for (I₁, I₂, …, Iₙ)

This trait is implemented for tuples up to 9 items long.

type Param<'i> = (<I as SystemInput>::Param<'i>,)

type Inner<'i> = (<I as SystemInput>::Inner<'i>,)

fn wrap(this: Self::Inner<'_>) -> Self::Param<'_>

Implementors

impl<'a, I: SystemInput> SystemInput for StaticSystemInput<'a, I>

type Param<'i> = StaticSystemInput<'i, I>

type Inner<'i> = <I as SystemInput>::Inner<'i>

impl<E: 'static, B: Bundle> SystemInput for Trigger<'_, E, B>

Used for ObserverSystems.

type Param<'i> = Trigger<'i, E, B>

type Inner<'i> = Trigger<'i, E, B>

impl<T: 'static> SystemInput for In<T>

type Param<'i> = In<T>

type Inner<'i> = T

impl<T: ?Sized + 'static> SystemInput for InMut<'_, T>

type Param<'i> = InMut<'i, T>

type Inner<'i> = &'i mut T

impl<T: ?Sized + 'static> SystemInput for InRef<'_, T>

type Param<'i> = InRef<'i, T>

type Inner<'i> = &'i T