Struct PipeSystem

pub struct PipeSystem<A, B> { /* private fields */ }

A System created by piping the output of the first system into the input of the second.

This can be repeated indefinitely, but system pipes cannot branch: the output is consumed by the receiving system.

Given two systems A and B, A may be piped into B as A.pipe(B) if the output type of A is equal to the input type of B.

Note that for FunctionSystems the output is the return value of the function and the input is the first SystemParam if it is tagged with In or () if the function has no designated input parameter.

Examples

use std::num::ParseIntError;

use bevy_ecs::prelude::*;

fn main() {
    let mut world = World::default();
    world.insert_resource(Message("42".to_string()));

    // pipe the `parse_message_system`'s output into the `filter_system`s input
    let mut piped_system = IntoSystem::into_system(parse_message_system.pipe(filter_system));
    piped_system.initialize(&mut world);
    assert_eq!(piped_system.run((), &mut world), Some(42));
}

#[derive(Resource)]
struct Message(String);

fn parse_message_system(message: Res<Message>) -> Result<usize, ParseIntError> {
    message.0.parse::<usize>()
}

fn filter_system(In(result): In<Result<usize, ParseIntError>>) -> Option<usize> {
    result.ok().filter(|&n| n < 100)
}

Implementations

impl<A, B> PipeSystem<A, B>

where A: System, B: System, for<'a> B::In: SystemInput<Inner<'a> = A::Out>,

pub const fn new(a: A, b: B, name: Cow<'static, str>) -> Self

Creates a new system that pipes two inner systems.

Trait Implementations

impl<A, B> ReadOnlySystem for PipeSystem<A, B>

where A: ReadOnlySystem, B: ReadOnlySystem, for<'a> B::In: SystemInput<Inner<'a> = A::Out>,

SAFETY: Both systems are read-only, so any system created by piping them 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<A, B> System for PipeSystem<A, B>

where A: System, B: System, for<'a> B::In: SystemInput<Inner<'a> = A::Out>,

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

This method uses “early out” logic: if the first system fails validation, the second system is not validated.

Because the system validation is performed upfront, this can lead to situations where later systems pass validation, but fail at runtime due to changes made earlier in the piped systems.

type In = <A as System>::In

The system’s input.

type Out = <B as System>::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.

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.