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
98
99
100

use std::iter::{Fuse, FusedIterator};
use crate::*;
use crate::iter::*;

/// # The complementary iterator of a time set
pub trait TimeComplementary: TimeConvexIterator {
    type Output:TimeConvexIterator<TimePoint=Self::TimePoint>;
    fn complementary(self) -> Self::Output;
}


impl<TW> TimeComplementary for TW
    where
        TW: TimeConvexIterator
{
    type Output = IterComplementary<Self>;

    #[inline]
    fn complementary(self) -> Self::Output {
        IterComplementary::new(self)
    }
}


pub struct IterComplementary<I:TimeConvexIterator>
{
    iter: Fuse<I>,
    lower: I::TimePoint
}

impl<I:TimeConvexIterator> IterComplementary<I>
{
    fn new(iter: I) -> Self {
        Self {
            iter: iter.fuse(),
            lower: -I::TimePoint::INFINITE
        }
    }
}

impl<I:TimeConvexIterator> TimeConvexIterator for IterComplementary<I> {
    type TimePoint = I::TimePoint;
}

impl<I:TimeConvexIterator> FusedIterator for IterComplementary<I> { }


impl<I:TimeConvexIterator> Iterator for IterComplementary<I>
{
    type Item = TimeInterval<I::TimePoint>;

    fn next(&mut self) -> Option<Self::Item>
    {
        if self.lower.is_past_infinite() {
            // just starting the iteration
            let start = self.iter.next()
                .and_then(|next| {
                    let upper = next.lower_bound().just_before();
                    self.lower = next.upper_bound().just_after();
                    if upper == -I::TimePoint::INFINITE {
                        None
                    } else {
                        Some(TimeInterval { lower: -I::TimePoint::INFINITE, upper})
                    }
                });
            if start.is_some() { return start; }
        }
        for next in self.iter.by_ref()
        {
            if self.lower < next.lower_bound() {
                let result = TimeInterval {
                    lower: self.lower,
                    upper: next.lower_bound().just_before()
                };
                self.lower = next.upper_bound().just_after();
                return Some(result);
            }
        }
        if self.lower.is_future_infinite() {
            None
        } else {
            let result = TimeInterval {
                lower: self.lower,
                upper: I::TimePoint::INFINITE
            };
            self.lower = I::TimePoint::INFINITE;
            Some(result)
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>)
    {
        let (min,max) = self.iter.size_hint();
        if self.lower.is_finite() {
            (min.saturating_sub(1), max)
        } else {
            (min.saturating_sub(1), max.map(|i| i + 1))
        }
    }
}