Struct Step 

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

Associates a value with a non-empty, half-open time range.

A Step pairs a value with the range [start, end), where start < end. The type T must implement Ord and typically represents time.

Steps are used as building blocks for schedules like super::StepSchedule, which assign values to non-overlapping intervals.

Examples

use twine_models::support::schedule::step_schedule::Step;

let step = Step::new(0..10, "active").unwrap();
assert!(step.contains(&5));
assert_eq!(step.value(), &"active");

assert!(Step::new(2..2, "empty").is_err());

Implementations

impl<T: Debug + Ord, V> Step<T, V>

pub fn new(range: Range<T>, value: V) -> Result<Self, EmptyRangeError<T>>

Creates a new Step with the given range and value.

Errors

Returns an EmptyRangeError if the provided range is empty.

Examples

use twine_models::support::schedule::step_schedule::Step;

let step = Step::new(0..10, 42.0).unwrap();
assert_eq!(step.start(), &0);
assert_eq!(step.end(), &10);
assert_eq!(step.value(), &42.0);

assert!(Step::new(5..1, "invalid range").is_err());

pub fn range(&self) -> &Range<T>

Returns a reference to the range covered by this step.

pub fn value(&self) -> &V

Returns a reference to the value associated with this step.

pub fn start(&self) -> &T

Returns a reference to the inclusive start bound of the range.

pub fn end(&self) -> &T

Returns a reference to the exclusive end bound of the range.

pub fn contains(&self, time: &T) -> bool

Returns true if time falls within the range of this step.

Equivalent to self.range.contains(time).

pub fn overlaps(&self, other: &Self) -> bool

Returns true if this step’s range overlaps with other’s range.

Two steps overlap if their ranges share any values.

Examples

use twine_models::support::schedule::step_schedule::Step;

let a = Step::new(0..5, "a").unwrap();
let b = Step::new(4..8, "b").unwrap();
let c = Step::new(8..10, "c").unwrap();

assert!(a.overlaps(&b));
assert!(!b.overlaps(&c));

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

Returns a reference to the value if time is within this step’s range.

Returns None if time is outside the range.

pub fn cmp_to_time(&self, time: &T) -> Ordering

Returns how this step’s range relates to a given time value.

• Ordering::Less if the step ends at or before time
• Ordering::Greater if the step starts after time
• Ordering::Equal if time is within the step’s range

Useful for efficient searching (e.g., with binary_search_by).

Trait Implementations

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

fn clone(&self) -> Step<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 Step<T, V>

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

Formats the value using the given formatter.

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

fn eq(&self, other: &Step<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: Debug + Ord, V> TryFrom<(Range<T>, V)> for Step<T, V>

type Error = EmptyRangeError<T>

The type returned in the event of a conversion error.

fn try_from((range, value): (Range<T>, V)) -> Result<Self, Self::Error>

Performs the conversion.

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

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