Struct IntervalSet 

pub struct IntervalSet<T> {
    pub intervals: Vec<AtomicInterval<T>>,
}

Fields

intervals: Vec<AtomicInterval<T>>

A vector of AtomicIntervals that make up the IntervalSet

Implementations

impl<T: Clone> IntervalSet<T>

pub fn is_empty(&self) -> bool

Returns true if this interval set has no intervals or is empty.

Examples

use timekeep_rs::IntervalSet;

// Suppose `interval` is an `Interval` with no intervals.
let interval = IntervalSet::<i32> { intervals: vec![] };

assert!(interval.is_empty());

pub fn new() -> IntervalSet<T>

Returns an empty IntervalSet.

Examples

use timekeep_rs::IntervalSet;

// Suppose `interval` is an `Interval` with no intervals.
let interval = IntervalSet::<i32>::new();

assert!(interval.is_empty());

impl<T: PartialOrd + Clone> IntervalSet<T>

A trait implementation for IntervalSet<T> where T implements PartialOrd and Clone. Provides set operations for interval sets.

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

Computes the union of two interval sets.

The union of two interval sets is a new interval set that contains all the intervals from both input sets, merging any overlapping or adjacent intervals.

Arguments

• other - Another interval set to compute the union with

Returns

A new IntervalSet<T> representing the union of both interval sets

Examples

use timekeep_rs::AtomicInterval;
use timekeep_rs::IntervalSet;

// Create two interval sets
let interval1 = IntervalSet::from(AtomicInterval::closed(1, 5));
let interval2 = IntervalSet::from(AtomicInterval::closed(3, 7));

// Compute union (results in [1, 7])
let union = interval1.union(&interval2);

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

Computes the intersection of two interval sets.

The intersection of two interval sets is a new interval set that contains all the intervals that are common to both input sets.

Arguments

• other - Another interval set to compute the intersection with

Returns

• Some(IntervalSet<T>) if the interval sets intersect
• None if the interval sets are disjoint

Examples

use timekeep_rs::AtomicInterval;
use timekeep_rs::IntervalSet;

// Create two interval sets
let interval1 = IntervalSet::from(AtomicInterval::closed(1, 5));
let interval2 = IntervalSet::from(AtomicInterval::closed(3, 7));

// Compute intersection (results in [3, 5])
let intersection = interval1.intersection(&interval2);

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

Computes the difference between two interval sets.

The difference A - B contains all points that are in A but not in B.

Arguments

• other - Another interval set to subtract from this interval set

Returns

A new IntervalSet<T> representing the difference between the interval sets

Examples

use timekeep_rs::AtomicInterval;
use timekeep_rs::IntervalSet;

// Create two interval sets
let interval1 = IntervalSet::from(AtomicInterval::closed(1, 5));
let interval2 = IntervalSet::from(AtomicInterval::closed(3, 7));

// Compute difference (results in [1, 3))
let difference = interval1.difference(&interval2);

Trait Implementations

impl<T: Clone> Clone for IntervalSet<T>

fn clone(&self) -> IntervalSet<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for IntervalSet<T>

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

Formats the value using the given formatter.

impl<T: Clone> From<AtomicInterval<T>> for IntervalSet<T>

fn from(interval: AtomicInterval<T>) -> Self

Creates a new IntervalSet<T> from an AtomicInterval<T>.

This implementation allows converting a single atomic interval into an IntervalSet<T> collection by wrapping it in a vector.

Examples

use timekeep_rs::AtomicInterval;
use timekeep_rs::IntervalSet;

let atomic = AtomicInterval::closed(1, 5);
let interval: IntervalSet<i32> = atomic.into();

impl<T: PartialEq> PartialEq for IntervalSet<T>

fn eq(&self, other: &IntervalSet<T>) -> 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: ToString> ToString for IntervalSet<T>

fn to_string(&self) -> String

Converts the interval set to a string representation.

Examples

use timekeep_rs::AtomicInterval;
use timekeep_rs::IntervalSet;

let interval = IntervalSet::from(AtomicInterval::closed(1, 5));
assert_eq!(interval.to_string(), "[[1, 5]]");

impl<T> StructuralPartialEq for IntervalSet<T>