chronologic 0.7.12

Time constraint reasoning (scheduling...)
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

use std::ops::*;
use crate::*;
use crate::iter::*;

// Convenient implementation to use range notation in Rust code

impl<T:TimePoint> TimeBounds for Range<T>
{
    type TimePoint = T;
    #[inline] fn is_empty(&self) -> bool { Range::is_empty(self) }
    #[inline] fn is_bounded(&self) -> bool { !self.is_empty() && self.lower_bound().is_finite() && self.upper_bound().is_finite() }
    #[inline] fn is_low_bounded(&self) -> bool { !self.is_empty() && self.lower_bound().is_finite() }
    #[inline] fn is_up_bounded(&self) -> bool { !self.is_empty() && self.upper_bound().is_finite()  }
    #[inline] fn lower_bound(&self) -> Self::TimePoint { if self.is_empty() { T::INFINITE } else { self.start } }
    #[inline] fn upper_bound(&self) -> Self::TimePoint { if self.is_empty() { -T::INFINITE} else { self.end.just_before() } }// not inclusive
}

impl<T:TimePoint> TimeBounds for RangeFrom<T>
{
    type TimePoint = T;
    #[inline] fn is_empty(&self) -> bool { false }
    #[inline] fn is_bounded(&self) -> bool { false }
    #[inline] fn is_low_bounded(&self) -> bool { self.lower_bound().is_finite() }
    #[inline] fn is_up_bounded(&self) -> bool { false }
    #[inline] fn lower_bound(&self) -> Self::TimePoint { self.start }
    #[inline] fn upper_bound(&self) -> Self::TimePoint { Self::TimePoint::INFINITE }
}

impl<T:TimePoint> TimeBounds for RangeInclusive<T>
{
    type TimePoint = T;
    #[inline] fn is_empty(&self) -> bool { RangeInclusive::is_empty(self) }
    #[inline] fn is_bounded(&self) -> bool { !self.is_empty() && self.lower_bound().is_finite() && self.upper_bound().is_finite() }
    #[inline] fn is_low_bounded(&self) -> bool { !self.is_empty() && self.lower_bound().is_finite() }
    #[inline] fn is_up_bounded(&self) -> bool { !self.is_empty() && self.upper_bound().is_finite()  }
    #[inline] fn lower_bound(&self) -> Self::TimePoint { if self.is_empty() { T::INFINITE} else { *self.start() } }
    #[inline] fn upper_bound(&self) -> Self::TimePoint { if self.is_empty() { -T::INFINITE } else { *self.end() } } // inclusive
}

impl<T:TimePoint> TimeBounds for RangeTo<T>
{
    type TimePoint = T;
    #[inline] fn is_empty(&self) -> bool { false }
    #[inline] fn is_bounded(&self) -> bool { false }
    #[inline] fn is_low_bounded(&self) -> bool { false }
    #[inline] fn is_up_bounded(&self) -> bool { self.upper_bound().is_finite()  }
    #[inline] fn lower_bound(&self) -> Self::TimePoint { - Self::TimePoint::INFINITE }
    #[inline] fn upper_bound(&self) -> Self::TimePoint { self.end.just_before() } // not inclusive
}

impl<T:TimePoint> TimeBounds for RangeToInclusive<T>
{
    type TimePoint = T;
    #[inline] fn is_empty(&self) -> bool { false }
    #[inline] fn is_bounded(&self) -> bool { false }
    #[inline] fn is_low_bounded(&self) -> bool { false }
    #[inline] fn is_up_bounded(&self) -> bool { self.upper_bound().is_finite()  }
    #[inline] fn lower_bound(&self) -> Self::TimePoint { - Self::TimePoint::INFINITE }
    #[inline] fn upper_bound(&self) -> Self::TimePoint { self.end } // inclusive
}

// not really useful, just for fun...
impl<T:TimePoint> From<RangeFull> for TimeInterval<T> {
    #[inline] fn from(_: RangeFull) -> Self { TimeInterval::all() }
}


macro_rules! timerange {
    ($range:ident) => {
        impl<T:TimePoint> TimeConvex for $range<T> { }
        impl<TW:TimeConvexIterator> TimeUnion<$range<TW::TimePoint>> for TW {
            type Output = $crate::iter::IterUnion<Self,<TimeInterval<TW::TimePoint> as IntoIterator>::IntoIter>;
            #[inline] fn union(self, tw: $range<TW::TimePoint>) -> Self::Output {
                self.union(Into::<TimeInterval<_>>::into(tw).into_iter())
            }
        }
        impl<TW:TimeConvexIterator> TimeIntersection<$range<TW::TimePoint>> for TW {
            type Output = $crate::iter::IterIntersection<Self,<TimeInterval<TW::TimePoint> as IntoIterator>::IntoIter>;
            #[inline] fn intersection(self, tw: $range<TW::TimePoint>) -> Self::Output {
                self.intersection(Into::<TimeInterval<_>>::into(tw).into_iter())
            }
        }
        impl<T:TimePoint> From<$range<T>> for TimeInterval<T> {
            #[inline]
            fn from(range: $range<T>) -> Self {
                TimeInterval { lower: range.lower_bound(), upper: range.upper_bound() }
            }
        }
    }
}

timerange!(Range);
timerange!(RangeFrom);
timerange!(RangeInclusive);
timerange!(RangeTo);
timerange!(RangeToInclusive);