Struct shipyard::WorkloadSystem

pub struct WorkloadSystem {

    pub type_id: TypeId,
    pub display_name: Box<dyn Label>,
    pub system_fn: Box<dyn Fn(&World) -> Result<(), Run> + Send + Sync + 'static>,
    pub borrow_constraints: Vec<TypeInfo>,
    pub tracking_to_enable: Vec<fn(_: &AllStorages) -> Result<(), GetStorage>>,
    pub generator: Box<dyn Fn(&mut Vec<TypeInfo>) -> TypeId + Send + Sync + 'static>,
    pub run_if: Option<Box<dyn Fn(&World) -> Result<bool, Run> + Send + Sync + 'static>>,
    pub tags: Vec<Box<dyn Label>>,
    pub before_all: DedupedLabels,
    pub after_all: DedupedLabels,
    pub require_in_workload: DedupedLabels,
    pub require_before: DedupedLabels,
    pub require_after: DedupedLabels,
}

Self contained system that may be inserted into a Workload.

Example:

use shipyard::{Component, IntoWorkloadSystem, View, Workload, WorkloadSystem, World};

#[derive(Component)]
struct U32(u32);

#[derive(Component)]
struct USIZE(usize);

fn sys1(u32s: View<U32>) {}
fn sys2(usizes: View<USIZE>) {}

let workload_sys1: WorkloadSystem = sys1.into_workload_system().unwrap();

let mut workload = Workload::new("my_workload")
    .with_system(workload_sys1)
    .with_system(sys2);

Fields

type_id: TypeId

display_name: Box<dyn Label>

system_fn: Box<dyn Fn(&World) -> Result<(), Run> + Send + Sync + 'static>

borrow_constraints: Vec<TypeInfo>

access information

tracking_to_enable: Vec<fn(_: &AllStorages) -> Result<(), GetStorage>>

Generates the tracking to enable for this system’s views

generator: Box<dyn Fn(&mut Vec<TypeInfo>) -> TypeId + Send + Sync + 'static>

Generates constraints and system type id

run_if: Option<Box<dyn Fn(&World) -> Result<bool, Run> + Send + Sync + 'static>>

tags: Vec<Box<dyn Label>>

before_all: DedupedLabels

after_all: DedupedLabels

require_in_workload: DedupedLabels

require_before: DedupedLabels

require_after: DedupedLabels

Trait Implementations

impl Extend<WorkloadSystem> for Workload

fn extend<T: IntoIterator<Item = WorkloadSystem>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl IntoWorkloadSystem<WorkloadSystem, ()> for WorkloadSystem

fn into_workload_system(self) -> Result<WorkloadSystem, InvalidSystem>

Wraps a function in a struct containing all information required by a workload.

impl IntoWorkloadTrySystem<WorkloadSystem, Result<(), InvalidSystem>> for WorkloadSystem

fn into_workload_try_system<Ok, Err: Into<Box<dyn Error + Send + Sync>>>( self, ) -> Result<WorkloadSystem, InvalidSystem>

Wraps a fallible function in a struct containing all information required by a workload.
The workload will stop if an error is returned.

impl SystemModificator<WorkloadSystem, ()> for WorkloadSystem

fn run_if<RunB, Run: IntoRunIf<RunB>>(self, run_if: Run) -> WorkloadSystem

Only run the system if the function evaluates to true.

fn skip_if<RunB, Run: IntoRunIf<RunB>>(self, run_if: Run) -> WorkloadSystem

Do not run the system if the function evaluates to true.

fn before_all<T>(self, other: impl AsLabel<T>) -> WorkloadSystem

When building a workload, this system will be placed before all invocation of the other system or workload.

fn after_all<T>(self, other: impl AsLabel<T>) -> WorkloadSystem

When building a workload, this system will be placed after all invocation of the other system or workload.

fn display_name<T>(self, name: impl AsLabel<T>) -> WorkloadSystem

System name used in error and gui built for shipyard.
Defaults to the system function name.

fn tag<T>(self, tag: impl AsLabel<T>) -> WorkloadSystem

Adds a tag to this system. Tags can be used to control system ordering when running workloads.

fn require_in_workload<T>(self, other: impl AsLabel<T>) -> WorkloadSystem

When building a workload, this system will assert that at least one of the other system is present in the workload.

fn require_before<T>(self, other: impl AsLabel<T>) -> WorkloadSystem

When building a workload, this system will assert that at least one of the other system is present before itself in the workload.

fn require_after<T>(self, other: impl AsLabel<T>) -> WorkloadSystem

When building a workload, this system will assert that at least one of the other system is present after itself in the workload.

fn run_if_storage_empty<T: Component>(self) -> WorkloadSystem

where Self: Sized,

Only run the system if the T storage is empty.

fn run_if_missing_unique<T: Unique>(self) -> WorkloadSystem

where Self: Sized,

Only run the system if the T unique storage is not present in the World.

fn run_if_storage_empty_by_id(self, storage_id: StorageId) -> WorkloadSystem

where Self: Sized,

Only run the system if the storage is empty.

fn skip_if_storage_empty<T: Component>(self) -> WorkloadSystem

where Self: Sized,

Do not run the system if the T storage is empty.

fn skip_if_missing_unique<T: Unique>(self) -> WorkloadSystem

where Self: Sized,

Do not run the system if the T unique storage is not present in the World.

fn skip_if_storage_empty_by_id(self, storage_id: StorageId) -> WorkloadSystem

where Self: Sized,

Do not run the system if the storage is empty.