recurring 0.1.5

A recurring event series implementation based on jiff
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

//! This is the core implementation of the series which does not depend on a `DateTimeRange`.

use crate::{DateTimeRange, Event, Pattern};
use jiff::{Span, civil::DateTime};

#[derive(Debug, Clone)]
pub(crate) struct SeriesCore<P> {
    pub(crate) pattern: P,
    pub(crate) event_duration: Span,
}

impl<P> SeriesCore<P>
where
    P: Pattern,
{
    #[inline]
    pub(crate) fn new(pattern: P, event_duration: Span) -> SeriesCore<P> {
        SeriesCore {
            pattern,
            event_duration,
        }
    }

    #[inline]
    pub(crate) fn pattern(&self) -> &P {
        &self.pattern
    }

    #[inline]
    pub(crate) fn event_duration(&self) -> Span {
        self.event_duration
    }

    #[inline]
    pub(crate) fn get(&self, instant: DateTime, range: DateTimeRange) -> Option<Event> {
        self.pattern
            .closest_to(instant, range)
            .filter(|&start| start == instant)
            .and_then(|start| self.get_event_unchecked(start))
    }

    #[inline]
    pub fn get_containing(&self, instant: DateTime, range: DateTimeRange) -> Option<Event> {
        self.pattern
            .closest_to(instant, range)
            .filter(|&start| start <= instant)
            .or_else(|| self.pattern.previous_before(instant, range))
            .and_then(|start| self.get_event_unchecked(start))
            .filter(|event| event.contains(instant))
    }

    #[inline]
    pub(crate) fn get_next_after(&self, instant: DateTime, range: DateTimeRange) -> Option<Event> {
        self.pattern
            .next_after(instant, range)
            .and_then(|next| self.get_event_unchecked(next))
    }

    #[inline]
    pub(crate) fn get_previous_before(
        &self,
        instant: DateTime,
        range: DateTimeRange,
    ) -> Option<Event> {
        self.pattern
            .previous_before(instant, range)
            .and_then(|previous| self.get_event_unchecked(previous))
    }

    #[inline]
    pub(crate) fn get_closest_to(&self, instant: DateTime, range: DateTimeRange) -> Option<Event> {
        self.pattern
            .closest_to(instant, range)
            .and_then(|closest| self.get_event_unchecked(closest))
    }

    #[inline]
    fn get_event_unchecked(&self, start: DateTime) -> Option<Event> {
        if self.event_duration.is_positive() {
            let end = start.checked_add(self.event_duration).ok()?;
            Some(Event::new_unchecked(start, Some(end)))
        } else {
            Some(Event::at(start))
        }
    }
}