Enum Schedule 

#[non_exhaustive]
pub enum Schedule {
    Once(SystemTime),
    Periodic(Duration),
    Cron(SmolStr),
    Manual,
}

When a background job runs.

Implements Serialize/Deserialize so durable persistence backends (e.g. SystemLabelSchedulerPersistence) can round-trip the schedule across restart. SystemTime, Duration, and SmolStr are all serde-compatible out of the box.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Once(SystemTime)

Fire once at the absolute instant given.

Periodic(Duration)

Repeat every period (uniform spacing).

Cron(SmolStr)

Cron-style schedule ("0 */15 * * * *").

Manual

Only via explicit uni.plugin.runJob('id').

Implementations

impl Schedule

pub fn next_after(&self, from: SystemTime) -> Option<SystemTime>

Compute the next instant at or after from that this schedule fires, or None if the schedule is exhausted (a Once whose instant has already passed) or the cron expression cannot be parsed.

Used by the host scheduler driver (crate::scheduler::Scheduler::tick_at) to time-gate dispatch.

Examples

use std::time::{Duration, SystemTime};
use uni_plugin::traits::background::Schedule;

let now = SystemTime::now();
let s = Schedule::Periodic(Duration::from_secs(10));
let next = s.next_after(now).unwrap();
assert!(next >= now + Duration::from_secs(10));

// A Once whose instant has passed is exhausted.
let past = now - Duration::from_secs(60);
assert!(Schedule::Once(past).next_after(now).is_none());

Trait Implementations

impl Clone for Schedule

fn clone(&self) -> Schedule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Schedule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Schedule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Schedule

impl PartialEq for Schedule

fn eq(&self, other: &Schedule) -> 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 Serialize for Schedule

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Schedule