forked from vieter-v/libvieter
120 lines
4.1 KiB
C
120 lines
4.1 KiB
C
#include "vieter_cron.h"
|
|
#include <time.h>
|
|
|
|
const uint8_t month_days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
|
|
|
vieter_cron_expression *vieter_cron_expr_init() {
|
|
return malloc(sizeof(vieter_cron_expression));
|
|
}
|
|
|
|
void vieter_cron_expr_free(vieter_cron_expression *ce) {
|
|
free(ce->months);
|
|
free(ce->days);
|
|
free(ce->hours);
|
|
free(ce->minutes);
|
|
free(ce);
|
|
}
|
|
|
|
void vieter_cron_expr_next(vieter_cron_simple_time *out,
|
|
vieter_cron_expression *ce,
|
|
vieter_cron_simple_time *ref) {
|
|
// For all of these values, the rule is the following: if their value is
|
|
// the length of their respective array in the CronExpression object, that
|
|
// means we've looped back around. This means that the "bigger" value has
|
|
// to be incremented by one. For example, if the minutes have looped
|
|
// around, that means that the hour has to be incremented as well.
|
|
uint8_t month_index = 0;
|
|
uint8_t day_index = 0;
|
|
uint8_t hour_index = 0;
|
|
uint8_t minute_index = 0;
|
|
|
|
// This chain is the same logic multiple times, namely that if a "bigger"
|
|
// value loops around, then the smaller value will always reset as well.
|
|
// For example, if we're going to a new day, the hour & minute will always
|
|
// be their smallest value again.
|
|
while (month_index < ce->month_count &&
|
|
ref->month > ce->months[month_index]) {
|
|
month_index++;
|
|
}
|
|
|
|
if (month_index < ce->month_count && ref->month == ce->months[month_index]) {
|
|
while (day_index < ce->day_count && ref->day > ce->days[day_index]) {
|
|
day_index++;
|
|
}
|
|
|
|
if (day_index < ce->day_count && ref->day == ce->days[day_index]) {
|
|
while (hour_index < ce->hour_count && ref->hour > ce->hours[hour_index]) {
|
|
hour_index++;
|
|
}
|
|
|
|
if (hour_index < ce->hour_count && ref->hour == ce->hours[hour_index]) {
|
|
// Minute is the only value where we explicitely make sure we
|
|
// can't match sref's value exactly. This is to ensure we only
|
|
// return values in the future.
|
|
while (minute_index < ce->minute_count &&
|
|
ref->minute >= ce->minutes[minute_index]) {
|
|
minute_index++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Here, we increment the "bigger" values by one if the smaller ones loop
|
|
// around. The order is important, as it allows a sort-of waterfall effect
|
|
// to occur which updates all values if required.
|
|
if (minute_index == ce->minute_count && hour_index < ce->hour_count) {
|
|
hour_index++;
|
|
}
|
|
|
|
if (hour_index == ce->hour_count && day_index < ce->day_count) {
|
|
day_index++;
|
|
}
|
|
|
|
if (day_index == ce->day_count && month_index < ce->month_count) {
|
|
month_index++;
|
|
}
|
|
|
|
out->minute = ce->minutes[minute_index % ce->minute_count];
|
|
out->hour = ce->hours[hour_index % ce->hour_count];
|
|
out->day = ce->days[day_index % ce->day_count];
|
|
|
|
// Sometimes, we end up with a day that does not exist within the selected
|
|
// month, e.g. day 30 in February. When this occurs, we reset day back to
|
|
// the smallest value & loop over to the next month that does have this
|
|
// day.
|
|
if (out->day > month_days[ce->months[month_index % ce->month_count] - 1]) {
|
|
out->day = ce->days[0];
|
|
month_index++;
|
|
|
|
while (out->day >
|
|
month_days[ce->months[month_index % ce->month_count] - 1]) {
|
|
month_index++;
|
|
}
|
|
}
|
|
|
|
out->month = ce->months[month_index % ce->month_count];
|
|
|
|
if (month_index >= ce->month_count) {
|
|
out->year = ref->year + 1;
|
|
} else {
|
|
out->year = ref->year;
|
|
}
|
|
}
|
|
|
|
void vieter_cron_expr_next_from_now(vieter_cron_simple_time *out,
|
|
vieter_cron_expression *ce) {
|
|
time_t t = time(NULL);
|
|
struct tm gm;
|
|
gmtime_r(&t, &gm);
|
|
|
|
vieter_cron_simple_time ref = {// tm_year contains years since 1900
|
|
.year = 1900 + gm.tm_year,
|
|
// tm_mon goes from 0 to 11
|
|
.month = gm.tm_mon + 1,
|
|
.day = gm.tm_mday,
|
|
.hour = gm.tm_hour,
|
|
.minute = gm.tm_min};
|
|
|
|
vieter_cron_expr_next(out, ce, &ref);
|
|
}
|