# Schedule in maplibre::schedule - Rust
A container of [`Stage`]s set to be run in a linear order.
Keywords: rust, rustlang, rust-lang, Schedule

# Struct maplibre::schedule::Schedule

source · [−]

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

Expand description

A container of `Stage`s 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

source

### impl Schedule

source

#### 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);

source

#### 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);

source

#### 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);

source

#### 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`.

source

#### 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();

source

#### 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();

source

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

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

source

#### 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.

## Trait Implementations

source

### impl Default for Schedule

source

#### fn default() -> Schedule

Returns the “default value” for a type. Read more

source

### impl Stage for Schedule

source

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

## Auto Trait Implementations

### impl !RefUnwindSafe for Schedule

### impl !Send for Schedule

### impl !Sync for Schedule

### impl Unpin for Schedule

### impl !UnwindSafe for Schedule

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### pub fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

### impl<T> Downcast for T where
T: Any,

#### pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert `Box<dyn Trait>` (where `Trait: Downcast`) to `Box<dyn Any>`. `Box<dyn Any>` can then be further `downcast` into `Box<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

#### pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`. `Rc<Any>` can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

#### pub fn as_any(&self) -> &(dyn Any + 'static)

Convert `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s. Read more

#### pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s. Read more

### impl<T> Downcast<T> for T

#### pub fn downcast(&self) -> &T

source

### impl<T> From<T> for T

const: unstable · source

#### pub fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T> Instrument for T

source

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more

source

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### pub fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> Same<T> for T

#### type Output = T

Should always be `Self`

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

### impl<T> Upcast<T> for T

#### pub fn upcast(&self) -> Option<&T>

source

### impl<T> WithSubscriber for T

source

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more

source

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more