Struct Timing

pub struct Timing {
    pub start: i32,
    pub end: i32,
}

A start-inclusive, end-exclusive i32 range (like Range<i32>) that is copyable, and implements several utility methods.

Fields

start: i32

The inclusive start of this interval.

end: i32

The exclusive end of this interval.

Implementations

impl Timing

pub fn len(&self) -> i32

Returns the length of this timing (self.end - self.start).

pub fn divide_into(&self, size: i32) -> Vec<Timing>

Splits this timing into sequentual pieces of a given size. Returns the resulting Vec.

let split = Timing::from(0..10).divide_into(5);
assert_eq!(split[0], Timing::from(0..5));
assert_eq!(split[1], Timing::from(5..10));

pub fn shifted_by<O>(&self, amount: O) -> Timing

where O: EndpointOffsets,

Returns a new Timing with start/end shifted by the given amount.

assert_eq!(Timing::from(0..10).shifted_by(10), Timing::from(10..20))

May also accept a (i32, i32) tuple representing different start/end shifts.

assert_eq!(Timing::from(1..10).shifted_by((-1, 1)), Timing::from(0..11))

pub fn start_shifted_by(&self, amount: i32) -> Timing

Returns a new Timing with the start shifted by the given amount.

assert_eq!(Timing::from(0..10).start_shifted_by(5), Timing::from(5..10))

pub fn end_shifted_by(&self, amount: i32) -> Timing

Returns a new Timing with the end shifted by the given amount.

assert_eq!(Timing::from(0..10).end_shifted_by(-5), Timing::from(0..5))

pub fn contains(&self, item: &i32) -> bool

Checks if a particular &i32 is contained in this Timing.

assert_eq!(Timing::from(1..10).contains(&1), true);
assert_eq!(Timing::from(1..10).contains(&10), false);

pub fn is_empty(&self) -> bool

Checks if this Timing is empty (including negative).

assert_eq!(Timing::from(1..1).is_empty(), true);
assert_eq!(Timing::from(1..0).is_empty(), true);
assert_eq!(Timing::from(1..2).is_empty(), false);

pub fn is_before(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing is before some other Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..1).is_before(&Timing::from(1..2)), true);
assert_eq!(Timing::from(1..2).is_before(&Timing::from(0..1)), false);

pub fn is_after(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing is after some other Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..1).is_after(&Timing::from(1..2)), false);
assert_eq!(Timing::from(1..2).is_after(&Timing::from(0..1)), true);

pub fn is_disjoint_from(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing does not overlap with another Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..2).is_disjoint_from(&Timing::from(2..3)), true);
assert_eq!(Timing::from(0..2).is_disjoint_from(&Timing::from(1..3)), false);

pub fn intersects(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing overlaps with another Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..2).intersects(&Timing::from(1..3)), true);
assert_eq!(Timing::from(0..2).intersects(&Timing::from(2..3)), false);

pub fn contains_range(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing contains another Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..2).contains_range(&Timing::from(0..1)), true);
assert_eq!(Timing::from(0..2).contains_range(&Timing::from(1..3)), false);

pub fn is_contained_by(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing is contained by another Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..2).is_contained_by(&Timing::from(0..3)), true);
assert_eq!(Timing::from(0..2).is_contained_by(&Timing::from(0..1)), false);

pub fn begins_within(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing begins within another Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..1).begins_within(&Timing::from(0..2)), true);
assert_eq!(Timing::from(0..1).begins_within(&Timing::from(1..2)), false);

pub fn ends_within(&self, other: &impl RangeBounds<i32>) -> bool

Checks if this Timing ends within another Timing (or other RangeBounds<i32>).

assert_eq!(Timing::from(0..2).ends_within(&Timing::from(0..2)), true);
assert_eq!(Timing::from(0..2).ends_within(&Timing::from(0..1)), false);

Trait Implementations

impl Clone for Timing

fn clone(&self) -> Timing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Timing

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Timing

fn deserialize<__D>( __deserializer: __D, ) -> Result<Timing, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Range<i32>> for Timing

fn from(value: &Range<i32>) -> Timing

Converts to this type from the input type.

impl<'a, T> From<&SegmentRef<'a, T>> for Timing

where T: Element,

fn from(value: &SegmentRef<'a, T>) -> Timing

Converts to this type from the input type.

impl From<&Subdivision> for Timing

fn from(value: &Subdivision) -> Timing

Converts to this type from the input type.

impl From<&Timing> for Timing

fn from(value: &Timing) -> Timing

Converts to this type from the input type.

impl From<Range<i32>> for Timing

fn from(value: Range<i32>) -> Timing

Converts to this type from the input type.

impl<'a, T> From<SegmentRef<'a, T>> for Timing

where T: Element,

fn from(value: SegmentRef<'a, T>) -> Timing

Converts to this type from the input type.

impl From<Subdivision> for Timing

fn from(value: Subdivision) -> Timing

Converts to this type from the input type.

impl PartialEq for Timing

fn eq(&self, other: &Timing) -> 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 RangeBounds<i32> for Timing

fn start_bound(&self) -> Bound<&i32>

Start index bound.

fn end_bound(&self) -> Bound<&i32>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

fn is_empty(&self) -> bool

where T: PartialOrd,

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

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl Serialize for Timing

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Timing

impl Eq for Timing

impl StructuralPartialEq for Timing