Enum ScheduleRule 

pub enum ScheduleRule {
    Minutely {
        every: u32,
    },
    Hourly {
        every: u32,
    },
    Daily {
        every: u32,
    },
    Weekly {
        every: u32,
        weekdays: Vec<Weekday>,
    },
    Monthly {
        every: u32,
        day: u32,
    },
    Yearly {
        every: u32,
        month: u32,
        day: u32,
    },
}

A recurrence rule evaluated in a schedule’s local timezone.

Rule families

The rule variants fall into two broad groups:

• clock-based rules:
  • ScheduleRule::Minutely
  • ScheduleRule::Hourly
• calendar-based rules:
  • ScheduleRule::Daily
  • ScheduleRule::Weekly
  • ScheduleRule::Monthly
  • ScheduleRule::Yearly

Anchoring semantics

Recurrence rules must have stable phase semantics so that querying at different times does not redefine the schedule.

This implementation uses the following anchors:

• Minutely { every }: occurrences happen at local times whose minute satisfies minute % every == 0, with seconds and subseconds taken from at.
• Hourly { every }: occurrences happen at local times whose hour satisfies hour % every == 0, with minute/second/subsecond taken from at.
• Daily { every }: anchored to the fixed local date 1970-01-01.
• Weekly { every, ... }: anchored to the Monday of the week containing 1970-01-01.
• Monthly { every, day }: anchored to January 1970.
• Yearly { every, month, day }: anchored to the calendar year 1970.

These anchors provide stable recurrence phase across calls to WindowSource::next_window and WindowSource::active_windows.

Variants

Minutely

Recur every every minutes within each hour.

For example, Minutely { every: 15 } with at = 00:00:30 produces local times such as:

• 00:00:30
• 00:15:30
• 00:30:30
• 00:45:30
• 01:00:30

and so on.

Fields

every: u32

Hourly

Recur every every hours within each day.

For example, Hourly { every: 6 } with at = 00:10:00 produces local times such as:

• 00:10:00
• 06:10:00
• 12:10:00
• 18:10:00
• next day 00:10:00

and so on.

Fields

every: u32

Daily

Recur every every days, anchored to 1970-01-01.

Fields

every: u32

Weekly

Recur every every weeks on the specified weekdays, anchored to the Monday of the week containing 1970-01-01.

Fields

every: u32

weekdays: Vec<Weekday>

Monthly

Recur every every months on a specific day-of-month.

Months that do not contain day are skipped.

Fields

every: u32

day: u32

Yearly

Recur every every years on a specific month/day.

Impossible dates such as February 30 are rejected during construction.

Fields

every: u32

month: u32

day: u32

Trait Implementations

impl Clone for ScheduleRule

fn clone(&self) -> ScheduleRule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScheduleRule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ScheduleRule

fn eq(&self, other: &ScheduleRule) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ScheduleRule

impl StructuralPartialEq for ScheduleRule