Enum inari::Overlap

pub enum Overlap {
    BothEmpty,
    FirstEmpty,
    SecondEmpty,
    Before,
    Meets,
    Overlaps,
    Starts,
    ContainedBy,
    Finishes,
    Equals,
    FinishedBy,
    Contains,
    StartedBy,
    OverlappedBy,
    MetBy,
    After,
}

The overlapping state between intervals, returned by Interval::overlap.

Quick Reference

self relative to rhs:

                     rhs
                  c       d
                  •———————•
     ┌─    a   b  :       :
     │   B •———•  :       :
     │      M •———•       :                              rhs
     │        O •———•     :                              c=d
     │          S •———•   :                               •
     │          S •       :                  ┌─    a   b  :
     │         Cb : •———• :                  │   B •———•  :
     │            :   •———• F                │            • E
self │            :       • F           self │        •———• Fb
     │            •———————• E                │          •———• C
     │          •—————————• Fb               │            •———• Sb
     │          •———————————• C              │            :  •———• A
     │            •—————————• Sb             └─           :  a   b
     │            :     •———• Ob                          •
     │            :       •———• Mb                       c=d
     │            :       :  •———• A
     └─           :       :  a   b
                  •———————•
                  c       d

rhs relative to self:

                    self
                  a       b
                  •———————•
     ┌─           :       :  c   d
     │            :       :  •———• B
     │            :       •———• M                       self
     │            :     •———• O                          a=b
     │            •—————————• S                           •
     │          •———————————• Cb             ┌─           :  c   d
     │          •—————————• F                │            :  •———• B
     │            •———————• E                │            •———• S
 rhs │            :   •———• Fb           rhs │          •———• Cb
     │            :       • Fb               │        •———• F
     │          C : •———• :                  │            • E
     │         Sb •———•   :                  │   A •———•  :
     │         Sb •       :                  └─    c   d  :
     │       Ob •———•     :                               •
     │     Mb •———•       :                              a=b
     │   A •———•  :       :
     └─    c   d  :       :
                  •———————•
                  a       b

Variants

BothEmpty

Both self and rhs are empty.

Equivalently, $\self = \rhs = ∅$.

FirstEmpty

self is empty while rhs is not.

Equivalently, $\self = ∅ ∧ \rhs ≠ ∅$.

SecondEmpty

rhs is empty while self is not.

Equivalently, $\self ≠ ∅ ∧ \rhs = ∅$.

Before

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $b < c$.

Equivalently,

$$ \self ≠ ∅ ∧ \rhs ≠ ∅ ∧ ∀x ∈ \self, ∀y ∈ \rhs : x < y. $$

       a      b
self:  •——————•
 rhs:             •——————•
                  c      d

Inverse: Overlap::After.

Meets

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $a < b ∧ b = c ∧ c < d$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∀x ∈ \self, ∀y ∈ \rhs : x ≤ y \\ &∧ ∃x ∈ \self, ∀y ∈ \rhs : x < y \\ &∧ ∃x ∈ \self, ∃y ∈ \rhs : x = y. \end{align*} $$

       a      b
self:  •——————•
 rhs:         •——————•
              c      d

Inverse: Overlap::MetBy.

Overlaps

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $a < c ∧ c < b ∧ b < d$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∃x ∈ \self, ∀y ∈ \rhs : x < y \\ &∧ ∃y ∈ \rhs, ∀x ∈ \self : x < y \\ &∧ ∃x ∈ \self, ∃y ∈ \rhs : y < x. \end{align*} $$

       a      b
self:  •——————•
 rhs:      •——————•
           c      d

Inverse: Overlap::OverlappedBy.

Starts

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $a = c ∧ b < d$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∀y ∈ \rhs, ∃x ∈ \self : x ≤ y \\ &∧ ∀x ∈ \self, ∃y ∈ \rhs : y ≤ x \\ &∧ ∃y ∈ \rhs, ∀x ∈ \self : x < y. \end{align*} $$

       a    b        :          a=b
self:  •————•        :    self:  •
 rhs:  •————————•    :     rhs:  •——————•
       c        d    :           c      d

Inverse: Overlap::StartedBy.

ContainedBy

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $c < a ∧ b < d$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∃y ∈ \rhs, ∀x ∈ \self : y < x \\ &∧ ∃y ∈ \rhs, ∀x ∈ \self : x < y. \end{align*} $$

         a    b
self:    •————•
 rhs:  •————————•
       c        d

Inverse: Overlap::Contains.

Finishes

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $c < a ∧ b = d$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∃y ∈ \rhs, ∀x ∈ \self : y < x \\ &∧ ∀y ∈ \rhs, ∃x ∈ \self : y ≤ x \\ &∧ ∀x ∈ \self, ∃y ∈ \rhs : x ≤ y. \end{align*} $$

           a    b    :                 a=b
self:      •————•    :    self:         •
 rhs:  •————————•    :     rhs:  •——————•
       c        d    :           c      d

Inverse: Overlap::FinishedBy.

Equals

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $a = c ∧ b = d$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∀x ∈ \self, ∃y ∈ \rhs : x = y \\ &∧ ∀y ∈ \rhs, ∃x ∈ \self : y = x. \end{align*} $$

       a      b    :          a=b
self:  •——————•    :    self:  •
 rhs:  •——————•    :     rhs:  •
       c      d    :          c=d

FinishedBy

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $a < c ∧ b = d$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∃x ∈ \self, ∀y ∈ \rhs : x < y \\ &∧ ∀x ∈ \self, ∃y ∈ \rhs : x ≤ y \\ &∧ ∀y ∈ \rhs, ∃x ∈ \self : y ≤ x. \end{align*} $$

       a        b    :           a      b
self:  •————————•    :    self:  •——————•
 rhs:      •————•    :     rhs:         •
           c    d    :                 c=d

Inverse: Overlap::Finishes.

Contains

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $a < c ∧ d < b$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∃x ∈ \self, ∀y ∈ \rhs : x < y \\ &∧ ∃x ∈ \self, ∀y ∈ \rhs : y < x. \end{align*} $$

       a        b
self:  •————————•
 rhs:    •————•
         c    d

Inverse: Overlap::ContainedBy.

StartedBy

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $a = c ∧ d < b$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∀x ∈ \self, ∃y ∈ \rhs : y ≤ x \\ &∧ ∀y ∈ \rhs, ∃x ∈ \self : x ≤ y \\ &∧ ∃x ∈ \self, ∀y ∈ \rhs : y < x. \end{align*} $$

       a        b    :           a      b
self:  •————————•    :    self:  •——————•
 rhs:  •————•        :     rhs:  •
       c    d        :          c=d

Inverse: Overlap::Starts.

OverlappedBy

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $c < a ∧ a < d ∧ d < b$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∃y ∈ \rhs, ∀x ∈ \self : y < x \\ &∧ ∃x ∈ \self, ∀y ∈ \rhs : y < x \\ &∧ ∃y ∈ \rhs, ∃x ∈ \self : x < y. \end{align*} $$

           a      b
self:      •——————•
 rhs:  •——————•
       c      d

Inverse: Overlap::Overlaps.

MetBy

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $c < d ∧ a = d ∧ a < b$.

Equivalently,

$$ \begin{align*} \self ≠ ∅ ∧ \rhs ≠ ∅ &∧ ∀y ∈ \rhs, ∀x ∈ \self : y ≤ x \\ &∧ ∃y ∈ \rhs, ∃x ∈ \self : y = x \\ &∧ ∃y ∈ \rhs, ∀x ∈ \self : y < x. \end{align*} $$

              a      b
self:         •——————•
 rhs:  •——————•
       c      d

Inverse: Overlap::Meets.

After

Both $\self = [a, b]$ and $rhs = [c, d]$ are nonempty and $d < a$.

Equivalently,

$$ \self ≠ ∅ ∧ \rhs ≠ ∅ ∧ ∀y ∈ \rhs, ∀x ∈ \self : y < x. $$

                  a      b
self:             •——————•
 rhs:  •——————•
       c      d

Inverse: Overlap::Before.

Trait Implementations

impl Clone for Overlap

fn clone(&self) -> Overlap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Overlap

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

Formats the value using the given formatter.

impl Hash for Overlap

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 PartialEq<Overlap> for Overlap

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

impl Eq for Overlap

impl StructuralEq for Overlap

impl StructuralPartialEq for Overlap