Struct TimeSpan

pub struct TimeSpan {
    pub start: TimePoint,
    pub end: TimePoint,
}

Represents a time span from “start” (included) to “end” (excluded).

The constructors will ensure “start <= end”, this condition will hold at any given time.

Fields

start: TimePoint

The first time point of the time span (inclusive)

end: TimePoint

The last time point of the time span (excluded)

Implementations

impl TimeSpan

pub fn new(start: TimePoint, end: TimePoint) -> TimeSpan

Create a new TimeSpan with start and end.

Examples

use alass_core::{TimeSpan, TimePoint};

let t0 = TimePoint::from(0);
let t10 = TimePoint::from(10);

let ts = TimeSpan::new(t0, t10);

Panics

This function asserts that start is less or equal end.

use alass_core::{TimeSpan, TimePoint};

let t0 = TimePoint::from(0);
let t10 = TimePoint::from(10);

// this will case a panic
let ts = TimeSpan::new(t10, t0);

pub fn new_safe(start: TimePoint, end: TimePoint) -> TimeSpan

Create a new TimeSpan with start and end. This function will not panic on end < start, but swap the values before calling TimeSpan::new().

Examples

use alass_core::{TimeSpan, TimePoint};

let t0 = TimePoint::from(0);
let t10 = TimePoint::from(10);

let ts = TimeSpan::new_safe(t10, t0);
assert!(ts.start() == t0 && ts.end() == t10);

pub fn new_copy_with_end(self, new_end: TimePoint) -> TimeSpan

Mutates a TimeSpans end.

Panics

Will panic if new_end is less than current start.

pub fn len(self) -> TimeDelta

Returns the length of the TimeSpan.

len() is zero, if and only if start is end.

pub fn is_empty(self) -> bool

Returns true if start == end.

pub fn start(self) -> TimePoint

Returns the start point of the TimeSpan.

pub fn end(self) -> TimePoint

Returns the end point of the TimeSpan.

pub fn half(self) -> TimePoint

Returns one (of the possibly two) points in the center of the TimeSpan.

pub fn contains(self, other: TimeSpan) -> bool

Returns true if self contains TimeSpan other.

Examples

use alass_core::{TimeSpan, TimePoint};

pub fn fast_distance_to(self, other: TimeSpan) -> TimeDelta

Returns the smallest difference between two TimeSpans.

use alass_core::{TimeSpan, TimePoint, TimeDelta};

let p = TimePoint::from(0);
let d = TimeDelta::one();

let ts1 = TimeSpan::new(p, p + 10 * d);
let ts4 = TimeSpan::new(p + 20 * d, p + 100 * d);

assert!(TimeSpan::fast_distance_to(ts1, ts1) == 0 * d);
assert!(TimeSpan::fast_distance_to(ts1, ts4) == 10 * d);
assert!(TimeSpan::fast_distance_to(ts4, ts1) == 10 * d);
assert!(TimeSpan::fast_distance_to(ts4, ts4) == 0 * d);

pub fn get_overlapping_length(self, other: TimeSpan) -> TimeDelta

Returns the smallest difference between two TimeSpans.

pub fn scaled(self, scaling_factor: f64) -> TimeSpan

Scale start and end time point to zero by scaling_factor.

pub fn cmp_start(self, other: TimeSpan) -> Ordering

Compares two TimeSpans by their start timepoint.

pub fn cmp_end(self, other: TimeSpan) -> Ordering

Compares two TimeSpans by their end timepoint.

Trait Implementations

impl Add<TimeDelta> for TimeSpan

type Output = TimeSpan

The resulting type after applying the + operator.

fn add(self, rhs: TimeDelta) -> TimeSpan

Performs the + operation.

impl Clone for TimeSpan

fn clone(&self) -> TimeSpan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TimeSpan

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

Formats the value using the given formatter.

impl Hash for TimeSpan

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TimeSpan

fn eq(&self, other: &TimeSpan) -> 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 Copy for TimeSpan

impl Eq for TimeSpan

impl StructuralPartialEq for TimeSpan