Struct IntoPipeSystem 

pub struct IntoPipeSystem<A, B, N: PipeSystemName = ()> { /* private fields */ }

An IntoSystem creating an instance of PipeSystem.

This struct is created by IntoSystem::pipe(). See its documentation for more.

Implementations

impl<A, B> IntoPipeSystem<A, B>

pub const fn new(a: A, b: B) -> Self

Creates a new IntoSystem that pipes two inner systems.

Unless changed, the name of the system will be set to a combination of the names of the inner systems.

pub fn with_name_fn( self, name: impl FnOnce(DebugName, DebugName) -> DebugName, ) -> IntoPipeSystem<A, B, impl PipeSystemName>

Set the name of the output PipeSystem to the output of a function.

The parameters to the function are the names of the two systems. The first system is the one passed as self to IntoSystem::pipe, and the second system is the one passed as a parameter.

Note that when piping multiple systems, they may themselves be PipeSystems!

pub fn with_name( self, name: impl Into<DebugName>, ) -> IntoPipeSystem<A, B, impl PipeSystemName>

Set the name of the output PipeSystem to the given string.

pub fn with_first_name(self) -> IntoPipeSystem<A, B, impl PipeSystemName>

Set the name of the output PipeSystem to the name of the first system.

Note that the “first” system is the one passed as self to IntoSystem::pipe. When piping multiple systems, that may itself by another PipeSystem!

let system = a.pipe(b).pipe(c).with_first_name();
assert_eq!("Pipe(a, b)", &*IntoSystem::into_system(system).name());
let system = a.pipe(b.pipe(c)).with_first_name();
assert_eq!("a", &*IntoSystem::into_system(system).name());

pub fn with_second_name(self) -> IntoPipeSystem<A, B, impl PipeSystemName>

Set the name of the output PipeSystem to the name of the second system.

Note that the “second” system is the one passed as a parameter to IntoSystem::pipe. When piping multiple systems, that may itself by another PipeSystem!

let system = a.pipe(b).pipe(c).with_second_name();
assert_eq!("c", &*IntoSystem::into_system(system).name());
let system = a.pipe(b.pipe(c)).with_second_name();
assert_eq!("Pipe(b, c)", &*IntoSystem::into_system(system).name());

Trait Implementations

impl<A: Clone, B: Clone, N: Clone + PipeSystemName> Clone for IntoPipeSystem<A, B, N>

fn clone(&self) -> IntoPipeSystem<A, B, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, B, N, IA, OA, IB, OB, MA, MB> IntoSystem<IA, OB, (IsPipeSystemMarker, OA, IB, MA, MB)> for IntoPipeSystem<A, B, N>

where IA: SystemInput, A: IntoSystem<IA, OA, MA>, B: IntoSystem<IB, OB, MB>, N: PipeSystemName, for<'a> IB: SystemInput<Inner<'a> = OA>,

type System = PipeSystem<<A as IntoSystem<IA, OA, MA>>::System, <B as IntoSystem<IB, OB, MB>>::System>

The type of System that this instance converts into.

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

Turns this value into its corresponding System.

fn pipe<B, BIn, BOut, MarkerB>(self, system: B) -> IntoPipeSystem<Self, B>

where Out: 'static, B: IntoSystem<BIn, BOut, MarkerB>, for<'a> BIn: SystemInput<Inner<'a> = Out>,

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

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

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.

fn with_input<T>(self, value: T) -> WithInputWrapper<Self::System, T>

where for<'i> In: SystemInput<Inner<'i> = &'i mut T>, T: Send + Sync + 'static,

Passes a mutable reference to value as input to the system each run, turning it into a system that takes no input.

fn with_input_from<T>(self) -> WithInputFromWrapper<Self::System, T>

where for<'i> In: SystemInput<Inner<'i> = &'i mut T>, T: FromWorld + Send + Sync + 'static,

Passes a mutable reference to a value of type T created via FromWorld as input to the system each run, turning it into a system that takes no input.

fn system_type_id(&self) -> TypeId

Get the TypeId of the System produced after calling into_system.