rrules 0.2.3

A library for working with recurrence rules
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

use crate::frequencies::errors::InvalidFrequency;
use crate::frequencies::{MonthlyDate, NthWeekday, Time};
use chrono::Weekday;
use std::collections::HashSet;

pub fn validate_secondly(interval: &i32) -> Result<(), InvalidFrequency> {
    if *interval > 0 {
        Ok(())
    } else {
        Err(InvalidFrequency::Interval {
            message: "Interval must be greater than 0".to_string(),
        })
    }
}

pub fn validate_minutely(interval: &i32) -> Result<(), InvalidFrequency> {
    if *interval > 0 {
        Ok(())
    } else {
        Err(InvalidFrequency::Interval {
            message: "Interval must be greater than 0".to_string(),
        })
    }
}

pub fn validate_hourly(interval: &i32) -> Result<(), InvalidFrequency> {
    if *interval > 0 {
        Ok(())
    } else {
        Err(InvalidFrequency::Interval {
            message: "Interval must be greater than 0".to_string(),
        })
    }
}

pub fn validate_daily(interval: &i32, by_time: &[Time]) -> Result<(), InvalidFrequency> {
    if *interval <= 0 {
        return Err(InvalidFrequency::Interval {
            message: "Interval must be greater than 0".to_string(),
        });
    }
    let mut unique_times: HashSet<Time> = HashSet::new();
    for time in by_time {
        let t = Time {
            hour: time.hour,
            minute: time.minute,
        };
        if !unique_times.insert(t) {
            return Err(InvalidFrequency::Time {
                message: "Repeated time".to_string(),
            });
        }
    }
    Ok(())
}

pub fn validate_weekly(interval: &i32, by_day: &[Weekday]) -> Result<(), InvalidFrequency> {
    if *interval <= 0 {
        return Err(InvalidFrequency::Interval {
            message: "Interval must be greater than 0".to_string(),
        });
    }
    let mut unique_days: HashSet<Weekday> = HashSet::new();
    for day in by_day {
        if !unique_days.insert(*day) {
            return Err(InvalidFrequency::Day {
                message: "Repeated day".to_string(),
            });
        }
    }
    Ok(())
}

pub fn validate_monthly(
    interval: &i32,
    by_month_day: &[i32],
    nth_weekdays: &[NthWeekday],
) -> Result<(), InvalidFrequency> {
    if *interval <= 0 {
        return Err(InvalidFrequency::Interval {
            message: "Interval must be greater than 0".to_string(),
        });
    }
    let mut unique_month_days: HashSet<i32> = HashSet::new();
    for day in by_month_day {
        if !unique_month_days.insert(*day) {
            return Err(InvalidFrequency::Day {
                message: "Repeated day".to_string(),
            });
        }
    }

    let mut unique_nth_weekdays: HashSet<NthWeekday> = HashSet::new();
    for nth_weekday in nth_weekdays {
        let nth_weekday = NthWeekday {
            week_number: nth_weekday.week_number,
            weekday: nth_weekday.weekday,
        };
        if !unique_nth_weekdays.insert(nth_weekday) {
            return Err(InvalidFrequency::Day {
                message: "Repeated day".to_string(),
            });
        }
    }

    Ok(())
}

pub fn validate_yearly(
    _interval: &i32,
    _by_monthly_date: &Option<MonthlyDate>,
) -> Result<(), InvalidFrequency> {
    // Todo: Implement
    Ok(())
}