date-time-matrix 0.1.4

Date Time Matrix
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use core::iter::Iterator;

#[cfg(feature = "with-chrono")]
use chrono::{DateTime, NaiveDateTime, TimeZone};
use hour::Hour;
use weekday::Weekday;

//
#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Copy, Clone)]
pub struct WeekdayAndHour(pub Weekday, pub Hour);

#[cfg(feature = "with-chrono")]
impl From<NaiveDateTime> for WeekdayAndHour {
    fn from(dt: NaiveDateTime) -> Self {
        Self(Weekday::from(dt), Hour::from(dt))
    }
}

#[cfg(feature = "with-chrono")]
impl<Tz: TimeZone> From<DateTime<Tz>> for WeekdayAndHour {
    fn from(dt: DateTime<Tz>) -> Self {
        Self(Weekday::from(dt.clone()), Hour::from(dt))
    }
}

//
#[derive(Debug, Clone, Default)]
pub struct WeekdayAndHourIterator {
    curr: Option<WeekdayAndHour>,
}

impl WeekdayAndHourIterator {
    pub fn new() -> Self {
        Self::default()
    }
}

impl Iterator for WeekdayAndHourIterator {
    type Item = WeekdayAndHour;

    fn next(&mut self) -> Option<Self::Item> {
        let new = match &self.curr {
            Some(v) => {
                let WeekdayAndHour(w, h) = v;
                match h.next() {
                    Some(h) => Some(WeekdayAndHour(w.to_owned(), h)),
                    None => w.next().map(|w| WeekdayAndHour(w, Hour::C0)),
                }
            }
            None => Some(WeekdayAndHour(Weekday::first(), Hour::C0)),
        };
        self.curr = new.to_owned();
        new
    }
}

//
#[derive(Debug, Clone, Default)]
pub struct WeekdayFromSundayAndHourIterator {
    curr: Option<WeekdayAndHour>,
}

impl WeekdayFromSundayAndHourIterator {
    pub fn new() -> Self {
        Self::default()
    }
}

impl Iterator for WeekdayFromSundayAndHourIterator {
    type Item = WeekdayAndHour;

    fn next(&mut self) -> Option<Self::Item> {
        let new = match &self.curr {
            Some(v) => {
                let WeekdayAndHour(w, h) = v;
                match h.next() {
                    Some(h) => Some(WeekdayAndHour(w.to_owned(), h)),
                    None => w.next_from_sunday().map(|w| WeekdayAndHour(w, Hour::C0)),
                }
            }
            None => Some(WeekdayAndHour(Weekday::first_from_sunday(), Hour::C0)),
        };
        self.curr = new.to_owned();
        new
    }
}

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

    #[cfg(feature = "with-chrono")]
    #[test]
    fn test_from_chrono() {
        use chrono::Utc;

        assert_eq!(
            WeekdayAndHour::from("2021-08-01T00:00:00".parse::<NaiveDateTime>().unwrap()),
            WeekdayAndHour(Weekday::Sun, Hour::C0)
        );

        assert_eq!(
            WeekdayAndHour::from("2021-08-01T00:00:00Z".parse::<DateTime<Utc>>().unwrap()),
            WeekdayAndHour(Weekday::Sun, Hour::C0)
        );
    }

    #[test]
    fn test_iter() {
        assert_eq!(WeekdayAndHourIterator::new().count(), 7 * 24);

        assert_eq!(
            WeekdayAndHourIterator::new().next(),
            Some(WeekdayAndHour(Weekday::Mon, Hour::C0))
        );
    }

    #[test]
    fn test_from_sunday_iter() {
        assert_eq!(WeekdayFromSundayAndHourIterator::new().count(), 7 * 24);

        assert_eq!(
            WeekdayFromSundayAndHourIterator::new().next(),
            Some(WeekdayAndHour(Weekday::Sun, Hour::C0))
        );
    }
}