Struct rudac::util::Interval

pub struct Interval<T: Ord> { /* fields omitted */ }

A utility data structure to represent intervals. It supports open, close and unbounded intervals

Examples

use rudac::util::Interval;
use std::ops::Bound::*;

// initialize interval [2,4]
let interval1 = Interval::new(Included(2), Included(4));

// initialize interval [2,4)
let interval2 = Interval::new(Included(2), Excluded(4));

// initialize point [4,4]
let point1 = Interval::point(4);

// compare intervals
// first, lower bounds are compared. if they're equal, higher bounds will be compared
assert!(interval2 < interval1);

// check if two intervals overlap
assert!(Interval::overlaps(&interval1, &interval2));

// check if one point and an interval overlap
assert!(Interval::overlaps(&interval1, &point1));
assert!(!Interval::overlaps(&interval2, &point1));

// check if one interval contains another interval
assert!(Interval::contains(&interval1, &interval2));

// get overlapped interval between two intervals
assert!(Interval::get_overlap(&interval1, &interval2).unwrap() == interval2);

Implementations

impl<T: Ord> Interval<T>

pub fn new(low: Bound<T>, high: Bound<T>) -> Interval<T>

Creates a new interval

Arguments

• low: lower bound of the interval
• high: higher bound of the interval

Panics

• panics if low > high. low == high is acceptable if interval is closed at both sides: [low, high]

Example

use rudac::util::Interval;
use std::ops::Bound::*;

// create the interval [2,4)
let interval1 = Interval::new(Included(2), Excluded(4));

// create the interval (-inf,4)
let interval2 = Interval::new(Unbounded, Excluded(4));


// create the interval (1,+inf)
let interval3 = Interval::new(Excluded(1), Unbounded);

pub fn point(value: T) -> Interval<T>

Creates a point.

Arguments

• value: value of the point

Examples

use rudac::util::Interval;
use std::ops::Bound::*;

// create point (2) or equivalently interval [2,2]
let point1 = Interval::point(2);

pub fn duplicate(&self) -> Interval<T>

Creates a duplicate of the interval

Examples

use rudac::util::Interval;
use std::ops::Bound::*;

let interval = Interval::new(Included(2), Unbounded);
let duplicate = interval.duplicate();

assert!(interval == duplicate);

pub fn low(&self) -> &Bound<T>

Get reference to lower bound of the interval

pub fn get_low(&self) -> Rc<Bound<T>>

Get a duplicate of lower bound of the interval

pub fn high(&self) -> &Bound<T>

Get reference to higher bound of the interval

pub fn get_high(&self) -> Rc<Bound<T>>

Get a duplicate of higher bound of the interval

pub fn overlaps(first: &Interval<T>, second: &Interval<T>) -> bool

Returns true if first and second intervals overlap, false otherwise

Examples

use rudac::util::Interval;
use std::ops::Bound::*;

let interval1 = Interval::new(Included(2), Included(4));
let interval2 = Interval::new(Included(2), Excluded(4));
let point1 = Interval::point(4);

assert!(Interval::overlaps(&interval1, &interval2));
assert!(Interval::overlaps(&interval1, &point1));
assert!(!Interval::overlaps(&interval2, &point1));

pub fn contains(first: &Interval<T>, second: &Interval<T>) -> bool

Returns true if second is a sub-interval of first, false otherwise

Examples

use rudac::util::Interval;
use std::ops::Bound::*;

let interval1 = Interval::new(Included(2), Included(4));
let interval2 = Interval::new(Included(2), Excluded(4));

assert!(Interval::contains(&interval1, &interval2));

pub fn get_overlap(
    first: &Interval<T>,
    second: &Interval<T>
) -> Option<Interval<T>>

Get overlapped interval of first and second, None otherwise

Examples

use rudac::util::Interval;
use std::ops::Bound::*;

// initialize intervals
let interval1 = Interval::new(Included(2), Included(4));
let interval2 = Interval::new(Included(2), Excluded(4));

assert!(Interval::get_overlap(&interval1, &interval2).unwrap() == interval2);

Trait Implementations

impl<T: Debug + Ord> Debug for Interval<T>

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

Formats the value using the given formatter.

impl<T: Ord + Display> Display for Interval<T>

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

Formats the value using the given formatter.

impl<T: Hash + Ord> Hash for Interval<T>

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, 

Feeds a slice of this type into the given Hasher.

impl<T: Ord> Ord for Interval<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: Ord> PartialEq<Interval<T>> for Interval<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T: Ord> PartialOrd<Interval<T>> for Interval<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Ord> Eq for Interval<T>