Struct Labeled 

pub struct Labeled<S: System> { /* private fields */ }

Wraps a System with ordering constraints relative to other systems in the same stage, added via SystemOrderingExt.

Constraints only take effect within the stage the system is registered to — there’s no cross-stage ordering, since stage order is already fixed by SystemStage. App::build topologically sorts each stage’s systems by these constraints, breaking ties by registration order, and panics if constraints form a cycle.

Implementations

impl<S: System> Labeled<S>

pub fn after<F, Marker>(self, system: F) -> Self

where F: IntoSystem<Marker> + 'static,

Require that system runs before this one, within the same stage. Chainable — call multiple times to depend on multiple systems.

pub fn before<F, Marker>(self, system: F) -> Self

where F: IntoSystem<Marker> + 'static,

Require that system runs after this one, within the same stage. Chainable — call multiple times to constrain multiple systems.

Trait Implementations

impl<S: System> IntoSystem<()> for Labeled<S>

type System = Labeled<S>

fn into_system(self) -> Self::System

impl<S: System> System for Labeled<S>

fn run(&mut self, world: &World, resources: &Resources)

fn requires(&self) -> Vec<RequiredResource>

Resource types this system needs present, derived automatically from its bare Res/ResMut parameters. App checks these before running a non-convergent stage’s systems and panics with a clear message naming the missing resource(s) rather than letting a param fetch panic deep inside whichever system happens to run first.

fn name(&self) -> &'static str

Human-readable identifier for this system, used in error/trace output so a missing-resource failure can be pinned to the system that needs it instead of just the resource name. Defaults to the type name of the System impl; FunctionSystem overrides this with the name of the wrapped function/closure, which is far more legible.

fn ordering_id(&self) -> TypeId

This system’s identity for ordering purposes — the TypeId of the function/closure it wraps. Automatic: every distinct function or closure has a distinct type, so no manual labeling is needed to make a system a valid target for another system’s after/before. Defaults to Self’s own TypeId; FunctionSystem/OnceFunctionSystem override it with the wrapped function’s TypeId instead of the wrapper’s, so ordering constraints referencing the bare function match.

fn after_ids(&self) -> &[TypeId]

Other systems in the same stage that must run before this one. Set via SystemOrderingExt::after. A referenced system that isn’t registered in the same stage is silently ignored.

fn before_ids(&self) -> &[TypeId]

Other systems in the same stage that must run after this one. Set via SystemOrderingExt::before. A referenced system that isn’t registered in the same stage is silently ignored.