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

//! dataseries
//!
//! functions for dataseries :
//! - __union__ : combines 2 data-series to one.
//!
//! examples :
//! - __simple__ : a basic usage of data-series union.
//! - __merge__ : a merge example to remove duplicates.
//! - __intersection__ : a simple intersection implementation based on union.
//! - __crdt__ : conflict-free replicated data type implementation of time-series updates to merge.
//!
//! # Quick Start
//! ```rust
//! use dataseries::{DataPoint, Series};
//!
//! fn test<T>(test_name: &str, expected: T, actual: T)
//! where
//!     T: PartialEq + std::fmt::Debug,
//! {
//!     if expected == actual {
//!         println!("expected: {expected:?}");
//!         println!("actual: {actual:?}");
//!         println!("{test_name} ok!");
//!
//!         println!("---------------------------------")
//!     } else {
//!         panic!("{test_name} failed!\nexpected '{expected:?}'\n  actual '{actual:?}'")
//!     }
//! }
//!
//! fn main() {
//!     let s1 = dataseries::of_iter(vec![DataPoint::new(3, 50)]);
//!
//!     let s2 = dataseries::of_iter(vec![DataPoint::new(4, 100), DataPoint::new(7, 110)]);
//!
//!     let actual = s1
//!         .union(s2, |x| match x {
//!             dataseries::UnionResult::LeftOnly(left) => (Some(left), None),
//!             dataseries::UnionResult::RightOnly(right) => (None, Some(right)),
//!             dataseries::UnionResult::Both { left, right } => (Some(left), Some(right)),
//!         })
//!         .collect::<Vec<_>>();
//!
//!     let expected = vec![
//!         DataPoint::new(3, (Some(50), None)),
//!         DataPoint::new(4, (Some(50), Some(100))),
//!         DataPoint::new(7, (Some(50), Some(110))),
//!     ];
//!
//!     test(
//!         "simple union example using option",
//!         expected.as_slice(),
//!         actual.as_slice(),
//!     );
//!     println!("done")
//! }
mod datapoint;
mod merge;
mod union;

pub use datapoint::DataPoint;
pub use merge::Merge;
pub use union::{Union, UnionResult};

pub struct FromIteratorSeries<T> {
    iterator: T,
}

impl<IT, T> Iterator for FromIteratorSeries<IT>
where
    IT: Iterator<Item = T>,
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.iterator.next()
    }
}

impl<IT, Point, Value> Series for FromIteratorSeries<IT>
where
    IT: Iterator<Item = DataPoint<Point, Value>>,
{
    type Point = Point;

    type Value = Value;
}

pub trait Series: Iterator<Item = DataPoint<Self::Point, Self::Value>> + Sized {
    type Point;
    type Value;

    fn merge(self) -> Merge<Self> {
        Merge::new(self)
    }

    fn union<R, F, T>(self, other: R, f: F) -> Union<Self::Point, Self, R, F>
    where
        R: Series<Point = Self::Point>,
        F: Fn(UnionResult<Self::Value, R::Value>) -> T,
    {
        Union::new(self, other, f)
    }
}

pub fn of_iter<T, IT>(into_iter: T) -> FromIteratorSeries<IT>
where
    IT: Iterator,
    T: IntoIterator<IntoIter = IT>,
{
    let iterator = into_iter.into_iter();
    FromIteratorSeries { iterator }
}