Enum ranges::Arrangement

pub enum Arrangement {
    Disjoint {
        self_less: bool,
    },
    Touching {
        self_less: bool,
    },
    Overlapping {
        self_less: bool,
        overlap_is_singleton: bool,
    },
    Containing {
        self_shorter: bool,
    },
    Starting {
        self_shorter: bool,
        shorter_is_singleton: bool,
    },
    Ending {
        self_shorter: bool,
        shorter_is_singleton: bool,
    },
    Equal,
    Empty {
        self_empty: Option<bool>,
    },
}

This enum represents all possible arrangements of two GenericRanges.

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 of Disjoint

self_less: bool

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

Touching

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

Diagram

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

Fields of Touching

self_less: bool

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

Overlapping

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

Diagram

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

Fields of Overlapping

self_less: bool

When GenericRange::arrangement(&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 of Containing

self_shorter: bool

When GenericRange::arrangement(&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 of Starting

self_shorter: bool

Indicates whether self or other in GenericRange::arrangement(&self, &other) was 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 of Ending

self_shorter: bool

Indicates whether self or other in GenericRange::arrangement(&self, &other) was shorter.

shorter_is_singleton: bool

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

Equal

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:    |----|

Fields of Empty

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 Clone for Arrangement

fn clone(&self) -> Arrangement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Arrangement

impl Debug for Arrangement

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

Formats the value using the given formatter.

impl Eq for Arrangement

impl PartialEq<Arrangement> for Arrangement

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

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

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

This method tests for !=.

impl StructuralEq for Arrangement

impl StructuralPartialEq for Arrangement