lognplot 0.1.0

Log and plot data
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

use super::TimeStamp;

/// A timespan is a period between two moments in time.
/// It differs from a duration, in the sense that a duration
/// is not fixed on the global time scale.
#[derive(Debug, PartialEq, Clone)]
pub struct TimeSpan {
    pub start: TimeStamp,
    pub end: TimeStamp,
}

impl TimeSpan {
    pub fn new(start: TimeStamp, end: TimeStamp) -> Self {
        TimeSpan { start, end }
    }

    pub fn from_seconds(start: isize, end: isize) -> Self {
        Self::new(TimeStamp::from_seconds(start), TimeStamp::from_seconds(end))
    }

    pub fn extend_to_include(&mut self, time_point: &TimeStamp) {
        if time_point < &self.start {
            self.start = time_point.clone();
        }

        if time_point > &self.end {
            self.end = time_point.clone();
        }
    }

    /// Adjust this timespan to include the given span.
    pub fn extend_to_include_span(&mut self, span: &Self) {
        if &span.start < &self.start {
            self.start = span.start.clone();
        }

        if &span.end > &self.end {
            self.end = span.end.clone();
        }
    }

    pub fn contains(&self, timestamp: &TimeStamp) -> bool {
        (&self.start <= timestamp) && (timestamp <= &self.end)
    }

    /// Test if those two timespans overlap.
    pub fn overlap(&self, other: &Self) -> bool {
        assert!(self.start <= self.end);
        assert!(other.start <= other.end);

        (self.start <= other.end) && (other.start <= self.end)
    }
}

#[cfg(test)]
mod tests {
    use super::TimeSpan;

    #[test]
    fn no_overlap1() {
        // Create test samples:
        let span1 = TimeSpan::from_seconds(1, 3);
        let span2 = TimeSpan::from_seconds(6, 7);
        assert!(!span1.overlap(&span2));
        assert!(!span2.overlap(&span1));
    }

    #[test]
    fn no_overlap2() {
        let span1 = TimeSpan::from_seconds(10, 13);
        let span2 = TimeSpan::from_seconds(6, 7);
        assert!(!span1.overlap(&span2));
        assert!(!span2.overlap(&span1));
    }

    #[test]
    fn overlap1() {
        let span1 = TimeSpan::from_seconds(1, 8);
        let span2 = TimeSpan::from_seconds(6, 17);
        assert!(span1.overlap(&span2));
        assert!(span2.overlap(&span1));
    }

    #[test]
    fn overlap2() {
        let span1 = TimeSpan::from_seconds(1, 19);
        let span2 = TimeSpan::from_seconds(6, 17);
        assert!(span1.overlap(&span2));
        assert!(span2.overlap(&span1));
    }

    #[test]
    fn overlap3() {
        let span1 = TimeSpan::from_seconds(8, 19);
        let span2 = TimeSpan::from_seconds(6, 17);
        assert!(span1.overlap(&span2));
        assert!(span2.overlap(&span1));
    }
}