Struct clokwerk::AsyncJob

pub struct AsyncJob<Tz = Local, Tp = ChronoTimeProvider>where
    Tz: TimeZone,
    Tp: TimeProvider,{ /* private fields */ }

An asynchronous job to run on the scheduler. Create these by calling AsyncScheduler::every().

Methods for scheduling the job live in the Job trait.

Implementations

impl<Tz, Tp> AsyncJob<Tz, Tp>where
    Tz: TimeZone + Sync + Send,
    Tp: TimeProvider,

pub fn run<F, T>(&mut self, f: F) -> &mut Selfwhere
    F: 'static + FnMut() -> T + Send,
    T: 'static + Future<Output = ()> + Send,

Specify a task to run, and schedule its next run

The function passed into this method should return a value implementing Future<Output = ()>.

pub fn execute(
    &mut self,
    now: &DateTime<Tz>
) -> Option<Pin<Box<dyn Future<Output = ()> + Send + 'static>>>

Run a task and re-schedule it. This is usually only called by AsyncScheduler::run_pending().

Trait Implementations

impl<Tz, Tp> Debug for AsyncJob<Tz, Tp>where
    Tz: TimeZone,
    Tp: TimeProvider,

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

Formats the value using the given formatter.

impl<Tz, Tp> Job<Tz, Tp> for AsyncJob<Tz, Tp>where
    Tz: TimeZone + Sync + Send,
    Tp: TimeProvider,

fn at(&mut self, time: &str) -> &mut Self

Specify the time of day when a task should run, e.g.

fn try_at(&mut self, time: &str) -> Result<&mut Self, ParseError>

Identical to Job::at except that it returns a Result instead of panicking if the conversion failed.

fn at_time(&mut self, time: NaiveTime) -> &mut Self

Similar to Job::at, but it takes a chrono::NaiveTime instead of a &str. Because it doesn’t need to parse a string, this method will always succeed.

fn plus(&mut self, ival: Interval) -> &mut Self

Specifies an offset to when a task should run, e.g.

fn and_every(&mut self, ival: Interval) -> &mut Self

Add an additional scheduling to the task. All schedules will be considered when determining when the task should next run.

fn once(&mut self) -> &mut Self

Execute the job only once. Equivalent to _.count(1).

fn forever(&mut self) -> &mut Self

Execute the job forever. This is the default behaviour.

fn count(&mut self, count: usize) -> &mut Self

Execute the job only count times.

fn repeating_every(&mut self, interval: Interval) -> Repeating<'_, Self, Tz, Tp>

After running once, run again with the specified interval.

fn is_pending(&self, now: &DateTime<Tz>) -> bool

Test whether a job is scheduled to run again. This is usually only called by Scheduler::run_pending().