Enum Relation

pub enum Relation<T: Domain> {
    Disjoint {
        first: GenericRange<T>,
        second: GenericRange<T>,
        self_less: bool,
    },
    Touching {
        first: GenericRange<T>,
        second: GenericRange<T>,
        self_less: bool,
    },
    Overlapping {
        first_disjoint: GenericRange<T>,
        second_disjoint: GenericRange<T>,
        overlap: GenericRange<T>,
        self_less: bool,
        overlap_is_singleton: bool,
    },
    Containing {
        first_disjoint: GenericRange<T>,
        second_disjoint: GenericRange<T>,
        overlap: GenericRange<T>,
        self_shorter: bool,
    },
    Starting {
        overlap: GenericRange<T>,
        disjoint: GenericRange<T>,
        self_shorter: bool,
        shorter_is_singleton: bool,
    },
    Ending {
        disjoint: GenericRange<T>,
        overlap: GenericRange<T>,
        self_shorter: bool,
        shorter_is_singleton: bool,
    },
    Equal(GenericRange<T>),
    Empty {
        non_empty: Option<GenericRange<T>>,
        self_empty: Option<bool>,
    },
}

This enum represents all possible arrangements of two GenericRanges. The original values were moved, possibly modified, and then stored.

Note

The following information is additionally contained if applicable:

• which of the two ranges was self and other
• if the overlap is a singleton
• if start or other is a singleton
• which of self and other is shorter

This information is the result of the comparison of the starts and ends of both ranges and is obtained “for free” and should thus be used preferably to other methods like GenericRange::is_singleton().

Variants

Disjoint

The two ranges have no overlap.

Diagram

first : |----------|
second:               |----------|

Fields

first: GenericRange<T>

The end of this range is less than the start of second.

second: GenericRange<T>

The start of this range is greater than the end of first.

self_less: bool

When GenericRange::relation(self, other) was invoked, either self or other were less.

Touching

The two ranges have no overlap but the end of the first touches the start of the second.

Diagram

first : |----------|
second:            |----------|

Fields

first: GenericRange<T>

The end of this range touches the start of second.

second: GenericRange<T>

The start of this range touches the end of first.

self_less: bool

When GenericRange::relation(self, other) was invoked, either self or other were less when sorted using Ord.

Overlapping

The two ranges have an overlap of one or more elements.

Diagram

first          : |----------|
second         :         |----------|
first disjoint : |-------|
second disjoint:            |-------|
overlap        :         |--|

Fields

first_disjoint: GenericRange<T>

Range representing the disjoint part of two ranges before the overlap.

second_disjoint: GenericRange<T>

Range representing the disjoint part of two ranges after the overlap.

overlap: GenericRange<T>

Range representing the overlapping part of two ranges.

self_less: bool

When GenericRange::relation(self, other) was invoked, either self or other was less.

overlap_is_singleton: bool

Indicates whether or not the overlap is by a single element, allowing optimization.

Containing

One range is contained in the other.

Diagram

first          : |--------------------|
second         :      |----------|
first disjoint : |----|
second disjoint:                 |----|
overlap        :      |----------|

Fields

first_disjoint: GenericRange<T>

Range representing the disjoint part of two ranges before the overlap.

second_disjoint: GenericRange<T>

Range representing the disjoint part of two ranges after the overlap.

overlap: GenericRange<T>

Range representing the overlapping part of two ranges.

self_shorter: bool

When GenericRange::relation(self, other) was invoked, either self or other was shorter.

Starting

Both ranges have the same start but varying endings.

Diagram

first   : |-----|
second  : |----------|
overlap : |-----|
disjoint:       |----|

Fields

overlap: GenericRange<T>

Range representing the overlapping part of two ranges.

disjoint: GenericRange<T>

Range representing the disjoint part of two ranges.

self_shorter: bool

Indicates if self or other in GenericRange::relation(self, other) is shorter.

shorter_is_singleton: bool

Depending on which of self or other is shorter, this boolean indicates that it is a singleton.

Ending

Both ranges have the same end but varying starts.

Diagram

first   : |----------|
second  :       |----|
disjoint: |-----|
overlap :       |----|

Fields

disjoint: GenericRange<T>

Range representing the disjoint part of two ranges.

overlap: GenericRange<T>

Range representing the overlapping part of two ranges.

self_shorter: bool

Indicates if self or other in GenericRange::relation(self, other) is shorter.

shorter_is_singleton: bool

Depending on which of self or other is shorter, this boolean indicates that it is a singleton.

Equal(GenericRange<T>)

The starts and ends of both ranges are equal.

Diagram

first : |----------|
second: |----------|
equal : |----------|

Empty

One or both ranges are empty and can therefore not be compared.

Diagram

first    :
second   :    |----|
non_empty:    |----|

Fields

non_empty: Option<GenericRange<T>>

The non empty range of the two ranges, if it exists.

self_empty: Option<bool>

Indicates which of the two inputs of GenericRange::arrangement(&self, &other) were empty. Returns None if both were empty.

Trait Implementations

impl<T: Debug + Domain> Debug for Relation<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + Domain> PartialEq for Relation<T>

fn eq(&self, other: &Relation<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: Eq + Domain> Eq for Relation<T>

impl<T: Domain> StructuralPartialEq for Relation<T>