Struct maplibre::schedule::Schedule

pub struct Schedule {
    stages: HashMap<Box<dyn StageLabel>, Box<dyn Stage>>,
    stage_order: Vec<Box<dyn StageLabel>>,
}

A container of Stages set to be run in a linear order.

Since Schedule implements the Stage trait, it can be inserted into another schedule. In this way, the properties of the child schedule can be set differently from the parent. For example, it can be set to run only once during app execution, while the parent schedule runs indefinitely.

Fields

stages: HashMap<Box<dyn StageLabel>, Box<dyn Stage>>

stage_order: Vec<Box<dyn StageLabel>>

Implementations

impl Schedule

pub fn add_stage<S: Stage>( &mut self, label: impl StageLabel, stage: S ) -> &mut Self

Adds the given stage at the last position of the schedule.

Example

schedule.add_stage("my_stage", NopStage);

pub fn remove_stage(&mut self, label: impl StageLabel) -> &mut Self

pub fn add_stage_after<S: Stage>( &mut self, target: impl StageLabel, label: impl StageLabel, stage: S ) -> &mut Self

Adds the given stage immediately after the target stage.

Example

schedule.add_stage_after("target_stage", "my_stage", NopStage);

pub fn add_stage_before<S: Stage>( &mut self, target: impl StageLabel, label: impl StageLabel, stage: S ) -> &mut Self

Adds the given stage immediately before the target stage.

Example

schedule.add_stage_before("target_stage", "my_stage", NopStage);

pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>( &mut self, label: impl StageLabel, func: F ) -> &mut Self

Fetches the Stage of type T marked with label, then executes the provided func passing the fetched stage to it as an argument.

The func argument should be a function or a closure that accepts a mutable reference to a struct implementing Stage and returns the same type. That means that it should also assume that the stage has already been fetched successfully.

Example

schedule.stage("my_stage", |stage: &mut NopStage| {
    // modify stage
    stage
});

Panics

Panics if label refers to a non-existing stage, or if it’s not of type T.

pub fn get_stage<T: Stage>(&self, label: &dyn StageLabel) -> Option<&T>

Returns a shared reference to the stage identified by label, if it exists.

If the requested stage does not exist, None is returned instead.

Example

let stage = schedule.get_stage::<NopStage>(&"my_stage").unwrap();

pub fn get_stage_mut<T: Stage>( &mut self, label: &dyn StageLabel ) -> Option<&mut T>

Returns a unique, mutable reference to the stage identified by label, if it exists.

If the requested stage does not exist, None is returned instead.

Example

let stage = schedule.get_stage_mut::<NopStage>(&"my_stage").unwrap();

pub fn run_once(&mut self, context: &mut MapContext)

Executes each Stage contained in the schedule, one at a time.

pub fn clear(&mut self)

pub fn iter_stages(&self) -> impl Iterator<Item = (&dyn StageLabel, &dyn Stage)>

Iterates over all of schedule’s stages and their labels, in execution order.

pub fn add_system_to_stage( &mut self, stage_label: impl StageLabel, system: impl IntoSystemContainer ) -> &mut Self

Adds a system to the Stage identified by stage_label.

Examples

schedule.add_system_to_stage("my_stage", my_system);

Trait Implementations

impl Default for Schedule

fn default() -> Schedule

Returns the “default value” for a type.

impl Stage for Schedule

fn run(&mut self, context: &mut MapContext)

Runs the stage; this happens once per update. Implementors must initialize all of their state before running the first time.