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).unwrap(), 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 fn new(a: A, b: B, name: DebugName) -> 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, ) -> Result<Self::Out, RunSystemError>

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>,

type In = <A as System>::In

The system’s input.

type Out = <B as System>::Out

The system’s output.

fn name(&self) -> DebugName

Returns the system’s name.

fn flags(&self) -> SystemStateFlags

Returns the SystemStateFlags of the system.

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

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) -> FilteredAccessSet

Initialize the system.

fn check_change_tick(&mut self, check: CheckChangeTicks)

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 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.

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

Runs the system with the given input in the world.

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

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.