Struct shipyard::Workload

source · [−]

pub struct Workload { /* private fields */ }

Expand description

Keeps information to create a workload.

A workload is a collection of systems. They will execute as much in parallel as possible.
They are evaluated first to last when they can’t be parallelized.
The default workload will automatically be set to the first workload added.

Implementations

source

impl Workload

source

pub fn new<T>(label: impl AsLabel<T>) -> Self

Creates a new empty Workload.

Example

use shipyard::{Component, IntoIter, View, ViewMut, Workload, World};

#[derive(Component, Clone, Copy)]
struct U32(u32);

#[derive(Component, Debug, PartialEq, Eq)]
struct USIZE(usize);

fn add(mut usizes: ViewMut<USIZE>, u32s: View<U32>) {
    for (mut x, &y) in (&mut usizes, &u32s).iter() {
        x.0 += y.0 as usize;
    }
}

fn check(usizes: View<USIZE>) {
    let mut iter = usizes.iter();
    assert_eq!(iter.next(), Some(&USIZE(1)));
    assert_eq!(iter.next(), Some(&USIZE(5)));
    assert_eq!(iter.next(), Some(&USIZE(9)));
}

let mut world = World::new();

world.add_entity((USIZE(0), U32(1)));
world.add_entity((USIZE(2), U32(3)));
world.add_entity((USIZE(4), U32(5)));

Workload::new("Add & Check")
    .with_system(add)
    .with_system(check)
    .add_to_world(&world)
    .unwrap();

world.run_default();

source

pub fn append(self, other: &mut Self) -> Self

Moves all systems of other into Self, leaving other empty.
This allows us to collect systems in different builders before joining them together.

source

pub fn merge(self, other: &mut Workload) -> Workload

Propagates all information from self and other into their respective systems before merging their systems.
This includes run_if/skip_if, tags, before/after requirements.

source

pub fn with_system<B, S: IntoWorkloadSystem<B, ()>>(self, system: S) -> Workload

Adds a system to the workload being created.

Example:

use shipyard::{Component, EntitiesViewMut, IntoIter, View, ViewMut, Workload, World};

#[derive(Component, Clone, Copy)]
struct U32(u32);

#[derive(Component, Debug, PartialEq, Eq)]
struct USIZE(usize);

fn add(mut usizes: ViewMut<USIZE>, u32s: View<U32>) {
    for (mut x, &y) in (&mut usizes, &u32s).iter() {
        x.0 += y.0 as usize;
    }
}

fn check(usizes: View<USIZE>) {
    let mut iter = usizes.iter();
    assert_eq!(iter.next(), Some(&USIZE(1)));
    assert_eq!(iter.next(), Some(&USIZE(5)));
    assert_eq!(iter.next(), Some(&USIZE(9)));
}

let mut world = World::new();

world.add_entity((USIZE(0), U32(1)));
world.add_entity((USIZE(2), U32(3)));
world.add_entity((USIZE(4), U32(5)));

Workload::new("Add & Check")
    .with_system(add)
    .with_system(check)
    .add_to_world(&world)
    .unwrap();

world.run_default();

source

pub fn with_try_system<B, Ok, Err: 'static + Into<Box<dyn Error + Send + Sync>>, R: Into<Result<Ok, Err>>, S: IntoWorkloadTrySystem<B, R>>(
self,
system: S
) -> Self

Adds a fallible system to the workload being created.
The workload’s execution will stop if any error is encountered.

Example:

use shipyard::{Component, EntitiesViewMut, Get, IntoIter, IntoWithId, View, ViewMut, Workload, World};
use shipyard::error::MissingComponent;

#[derive(Component, Clone, Copy)]
struct U32(u32);

#[derive(Component, Debug, PartialEq, Eq)]
struct USIZE(usize);

fn add(mut usizes: ViewMut<USIZE>, u32s: View<U32>) {
    for (mut x, &y) in (&mut usizes, &u32s).iter() {
        x.0 += y.0 as usize;
    }
}

fn check(usizes: View<USIZE>) -> Result<(), MissingComponent> {
    for (id, i) in usizes.iter().with_id() {
        assert!(usizes.get(id)? == i);
    }

    Ok(())
}

let mut world = World::new();

world.add_entity((USIZE(0), U32(1)));
world.add_entity((USIZE(2), U32(3)));
world.add_entity((USIZE(4), U32(5)));

Workload::new("Add & Check")
    .with_system(add)
    .with_try_system(check)
    .add_to_world(&world)
    .unwrap();

world.run_default();

source

pub fn add_to_world(self, world: &World) -> Result<WorkloadInfo, AddWorkload>

Finishes the workload creation and stores it in the World.
Returns a struct with describing how the workload has been split in batches.

Borrows

Scheduler (exclusive)

Errors

Scheduler borrow failed.
Workload with an identical name already present.
Nested workload is not present in world.

source

pub fn are_all_uniques_present_in_world(
&self,
world: &World
) -> Result<(), UniquePresence>

Returns the first Unique storage borrowed by this workload that is not present in world.
If the workload contains nested workloads they have to be present in the World.

Borrows

AllStorages (shared)

source

pub fn build(self) -> Result<(ScheduledWorkload, WorkloadInfo), AddWorkload>

Build the Workload from the Workload.

Trait Implementations

source

impl Extend<WorkloadSystem> for Workload

source

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

Extends a collection with the contents of an iterator. Read more

source

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

source

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

source

impl IntoWorkload<Workload, Workload> for Workload

source

fn into_workload(self) -> Workload

Converts to a collection of systems. Read more

source

fn into_sequential_workload(self) -> Workload

Converts to a collection of systems.
All systems will run one after the other. Does not propagate into nested Workload but they will run sequentially between them. Read more

source