Struct StepSchedule 

pub struct StepSchedule<T, V> { /* private fields */ }

Associates values with distinct, non-overlapping time ranges.

A StepSchedule is a collection of Steps, each mapping a value to a non-empty, non-overlapping half-open range [start, end).

The range type T must implement Ord, and usually represents time, though any ordered type (e.g., numbers or indices) is supported.

Examples

use twine_components::schedule::step_schedule::{Step, StepSchedule};

let schedule = StepSchedule::new([
    Step::new(0..10, "low").unwrap(),
    Step::new(10..20, "medium").unwrap(),
    Step::new(20..30, "high").unwrap(),
]).unwrap();

assert_eq!(schedule.value_at(&-1), None);
assert_eq!(schedule.value_at(&0), Some(&"low"));
assert_eq!(schedule.value_at(&15), Some(&"medium"));
assert_eq!(schedule.value_at(&25), Some(&"high"));
assert_eq!(schedule.value_at(&30), None);

Implementations

impl<T: Debug + Clone + Ord, V> StepSchedule<T, V>

pub fn new<I>(steps: I) -> Result<Self, OverlappingStepsError<T>>

where I: IntoIterator<Item = Step<T, V>>,

Creates a new StepSchedule from an iterator over Steps.

Accepts any type convertible into an iterator, such as a vector or array. The resulting schedule is ordered by increasing start time.

Errors

Returns an OverlappingStepsError if any steps have overlapping ranges. Steps are sorted by start time before validation, so the existing step will always have an earlier start than the incoming one in the error.

pub fn try_push( &mut self, step: Step<T, V>, ) -> Result<(), OverlappingStepsError<T>>

Attempts to add a step to the schedule.

Errors

Returns an OverlappingStepsError if the new step’s range overlaps with any existing steps in the schedule.

pub fn steps(&self) -> &[Step<T, V>]

Returns a slice of the steps in this schedule.

pub fn value_at(&self, time: &T) -> Option<&V>

Returns the value associated with the given time, if any.

Searches for the Step whose range contains time and returns a reference to its associated value. Returns None if no such step exists.

For schedules with fewer than [LINEAR_SEARCH_THRESHOLD] steps, a linear scan is used. Otherwise, binary search is performed.

Examples

use twine_components::schedule::step_schedule::{Step, StepSchedule};

let schedule = StepSchedule::new(vec![
    Step::new(0..10, 1).unwrap(),
    Step::new(10..20, 2).unwrap(),
]).unwrap();

assert_eq!(schedule.value_at(&5), Some(&1));
assert_eq!(schedule.value_at(&15), Some(&2));
assert_eq!(schedule.value_at(&20), None);

Trait Implementations

impl<T: Clone, V: Clone> Clone for StepSchedule<T, V>

fn clone(&self) -> StepSchedule<T, V>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, V: Debug> Debug for StepSchedule<T, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, V: Default> Default for StepSchedule<T, V>

fn default() -> StepSchedule<T, V>

Returns the “default value” for a type.

impl<T: PartialEq, V: PartialEq> PartialEq for StepSchedule<T, V>

fn eq(&self, other: &StepSchedule<T, V>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq, V: Eq> Eq for StepSchedule<T, V>

impl<T, V> StructuralPartialEq for StepSchedule<T, V>