periodically 0.2.0

A library for running tasks on a schedule
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

use std::time::Duration;

use super::Schedule;

/// Schedules a simple interval execution.
///
/// **Danger: Does not account for clock drift when executing a task**.
/// eg; If the interval is 10s, and the task takes 3s to execute, the next
/// task will not be scheduled until 13s after the first execution started.
pub struct IntervalSchedule {
    delay: Option<Duration>,
    interval: Duration,
}

impl IntervalSchedule {
    /// Creates a [Schedule] that always returns `interval`.
    ///
    /// ```
    /// use periodically::{Schedule, IntervalSchedule};
    /// use std::time::Duration;
    ///
    /// let interval = IntervalSchedule::every(Duration::from_secs(1));
    /// # let interval = Box::new(interval) as Box<dyn Schedule<()>>;
    /// assert_eq!(interval.initial(), Some(Duration::from_secs(1)));
    /// assert_eq!(interval.next(()), Some(Duration::from_secs(1)));
    /// ```
    pub fn every(interval: Duration) -> Self {
        Self {
            delay: None,
            interval,
        }
    }

    /// Creates a [Schedule] that will first return after a delay, and then always returns `interval`.
    ///
    /// ```
    /// use periodically::{Schedule, IntervalSchedule};
    /// use std::time::Duration;
    ///
    /// let interval = IntervalSchedule::with_initial_delay(Duration::from_secs(2), Duration::from_secs(1));
    /// # let interval = Box::new(interval) as Box<dyn Schedule<()>>;
    /// assert_eq!(interval.initial(), Some(Duration::from_secs(1)));
    /// assert_eq!(interval.next(()), Some(Duration::from_secs(2)));
    /// ```
    pub fn with_initial_delay(interval: Duration, delay: Duration) -> Self {
        Self {
            delay: Some(delay),
            interval,
        }
    }
}

impl<T> Schedule<T> for IntervalSchedule {
    fn next(&self, _: T) -> Option<Duration> {
        Some(self.interval)
    }

    fn initial(&self) -> Option<Duration> {
        self.delay.or(Some(self.interval))
    }
}