dataseries 0.1.6

dataseries support for rust
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

use super::Series;

pub struct Merge<TS>
where
    TS: Series,
{
    iterator: TS,
    current: Option<TS::Item>,
    is_done: bool,
}

impl<TS> Merge<TS>
where
    TS: Series,
{
    pub fn new(iterator: TS) -> Self {
        Self {
            iterator,
            current: None,
            is_done: false,
        }
    }
}

impl<TS> Iterator for Merge<TS>
where
    TS: Series,
    TS::Value: Copy + PartialOrd,
    TS::Point: Copy + PartialOrd,
{
    type Item = TS::Item;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if self.is_done {
                return None;
            }

            match (self.current, self.iterator.next()) {
                (None, None) => return None,
                (None, Some(c)) => self.current = Some(c),
                (Some(p), None) => {
                    self.is_done = true;
                    return Some(p);
                }
                (Some(p), Some(c)) => {
                    if p.data() == c.data() {
                        self.current = Some(if p.point() < c.point() { p } else { c });
                    } else {
                        self.current = Some(c);
                        return Some(p);
                    }
                }
            }
        }
    }
}

impl<TS> Series for Merge<TS>
where
    TS: Series,
    TS::Point: Copy + PartialOrd,
    TS::Value: Copy + PartialOrd,
{
    type Point = TS::Point;

    type Value = TS::Value;
}

#[cfg(test)]
mod tests {
    use crate::{DataPoint, Series};

    #[test]
    fn test_merge_with_empty_value() {
        let x: Vec<DataPoint<i32, Option<i32>>> = vec![];

        let expected: Vec<DataPoint<i32, Option<i32>>> = vec![];

        let actual = crate::of_iter(x).merge().collect::<Vec<_>>();
        assert_eq!(expected.as_slice(), actual.as_slice());
    }

    #[test]
    fn test_merge_with_same_value() {
        let x = vec![
            DataPoint::new(1, Some(10)),
            DataPoint::new(5, Some(10)),
            DataPoint::new(10, None),
        ];

        let expected = vec![DataPoint::new(1, Some(10)), DataPoint::new(10, None)];

        let actual = crate::of_iter(x).merge().collect::<Vec<_>>();
        assert_eq!(expected.as_slice(), actual.as_slice());
    }

    #[test]
    fn test_merge_with_different_value() {
        let x = vec![
            DataPoint::new(1, Some(10)),
            DataPoint::new(5, Some(100)),
            DataPoint::new(10, None),
        ];

        let expected = vec![
            DataPoint::new(1, Some(10)),
            DataPoint::new(5, Some(100)),
            DataPoint::new(10, None),
        ];

        let actual = crate::of_iter(x).merge().collect::<Vec<_>>();
        assert_eq!(expected.as_slice(), actual.as_slice());
    }
}