allen-intervals 0.1.0

An efficient implementation of Allen's interval relations for Rust's range types.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::{
    interval::{Interval, IntervalFrom, IntervalFull, IntervalTo},
    NonEmpty,
};

/// An endpoint of an interval of time.
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
pub enum Bound<T> {
    /// A finite endpoint.
    ///
    /// Indicates that there is a bound in this direction.
    Bounded(T),
    /// An infinite endpoint.
    ///
    /// Indicates that there is no bound in this direction.
    Unbounded,
}

/// The endpoints of an interval of time.
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
pub struct Bounds<T> {
    /// Start index bound.
    ///
    /// Returns the start value as a Bound.
    pub start: Bound<T>,

    /// End index bound.
    ///
    /// Returns the end value as a Bound.
    pub end: Bound<T>,
}

/// `IntervalBounds` is implemented by the crate's built-in interval types.
pub trait IntervalBounds<T> {
    /// Start index bound.
    ///
    /// Returns the start value as a [`Bound<T>`].
    fn start_bound(&self) -> Bound<T>;

    /// End index bound.
    ///
    /// Returns the end value as a [`Bound<T>`].
    fn end_bound(&self) -> Bound<T>;

    /// Index bounds.
    ///
    /// Returns the start end end bounds as a [`Bounds<T>`].
    fn bounds(&self) -> Bounds<T> {
        Bounds {
            start: self.start_bound(),
            end: self.end_bound(),
        }
    }
}

impl<I, T> IntervalBounds<T> for NonEmpty<I>
where
    I: IntervalBounds<T>,
{
    fn start_bound(&self) -> Bound<T> {
        self.0.start_bound()
    }

    fn end_bound(&self) -> Bound<T> {
        self.0.end_bound()
    }
}

impl<T> IntervalBounds<T> for Interval<T>
where
    T: Copy,
{
    fn start_bound(&self) -> Bound<T> {
        Bound::Bounded(self.start)
    }

    fn end_bound(&self) -> Bound<T> {
        Bound::Bounded(self.end)
    }
}

impl<T> IntervalBounds<T> for IntervalFrom<T>
where
    T: Copy,
{
    fn start_bound(&self) -> Bound<T> {
        Bound::Bounded(self.start)
    }

    fn end_bound(&self) -> Bound<T> {
        Bound::Unbounded
    }
}

impl<T> IntervalBounds<T> for IntervalTo<T>
where
    T: Copy,
{
    fn start_bound(&self) -> Bound<T> {
        Bound::Unbounded
    }

    fn end_bound(&self) -> Bound<T> {
        Bound::Bounded(self.end)
    }
}

impl<T> IntervalBounds<T> for IntervalFull {
    fn start_bound(&self) -> Bound<T> {
        Bound::Unbounded
    }

    fn end_bound(&self) -> Bound<T> {
        Bound::Unbounded
    }
}