Enum RangeIntersect

pub enum RangeIntersect {
    EqualTo,
    OverlapsLeft,
    OverlapsRight,
    ContainsFirst,
    ContainsProper,
    ContainsLast,
    ContainedByFirst,
    ContainedByProper,
    ContainedByLast,
}

Ways in which a pair of ranges (A,B) can intersect

Variants

EqualTo

[ A=B ]

OverlapsLeft

[ A [ ] B ]

OverlapsRight

[ B [ ] A ]

ContainsFirst

[ B ] A ]

ContainsProper

[ A [ B ] ]

ContainsLast

[ A [ B ]

ContainedByFirst

[ A ] B ]

ContainedByProper

[ [ A ] B ]

ContainedByLast

[ B [ A ]

Implementations

impl RangeIntersect

pub fn compare<T: PrimInt>( left: &RangeInclusive<T>, right: &RangeInclusive<T>, ) -> Option<Self>

Test two inclusive ranges for intersection, returning None if the ranges are disjoint.

assert_eq!(RangeIntersect::compare (&(0..=1), &(4..=5)), None);
assert_eq!(
  RangeIntersect::compare (&(0..=5), &(0..=5)),
  Some (RangeIntersect::EqualTo));
assert_eq!(
  RangeIntersect::compare (&(0..=5), &(1..=4)),
  Some (RangeIntersect::ContainsProper));
assert_eq!(
  RangeIntersect::compare (&(1..=4), &(0..=5)),
  Some (RangeIntersect::ContainedByProper));
assert_eq!(
  RangeIntersect::compare (&(0..=5), &(0..=3)),
  Some (RangeIntersect::ContainsFirst));
assert_eq!(
  RangeIntersect::compare (&(0..=5), &(4..=5)),
  Some (RangeIntersect::ContainsLast));
assert_eq!(
  RangeIntersect::compare (&(0..=2), &(0..=5)),
  Some (RangeIntersect::ContainedByFirst));
assert_eq!(
  RangeIntersect::compare (&(4..=5), &(0..=5)),
  Some (RangeIntersect::ContainedByLast));
assert_eq!(
  RangeIntersect::compare (&(0..=3), &(3..=5)),
  Some (RangeIntersect::OverlapsLeft));
assert_eq!(
  RangeIntersect::compare (&(3..=5), &(0..=3)),
  Some (RangeIntersect::OverlapsRight));

Trait Implementations

impl Debug for RangeIntersect

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

Formats the value using the given formatter.

impl From<RangeIntersect> for RangeCompare

fn from(intersect: RangeIntersect) -> Self

Converts to this type from the input type.

impl PartialEq for RangeIntersect

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

impl StructuralPartialEq for RangeIntersect