Struct Task 

pub struct Task<R: Runtime> {
    pub schedule: Box<dyn Schedule + Send>,
    pub run: Box<RunTaskFn<R>>,
}

Task to be scheduled

Fields

• schedule: a Schedule trait object
• run: function to create a new task in specific runtime R

Fields

schedule: Box<dyn Schedule + Send>

run: Box<RunTaskFn<R>>

Implementations

impl Task<AsyncStd>

pub fn async_std<S, F, Fut>(schedule: S, task: F) -> Self

where S: IntoSchedule, S::Output: Send + 'static, F: Fn() -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static,

Create a new task that will be executed with async_std.

Example

let task = Task::async_std(now(), || async {
   println!("Hello, world!");
});

impl Task<Tokio>

pub fn tokio<S, F, Fut>(schedule: S, task: F) -> Self

where S: IntoSchedule, S::Output: Send + 'static, F: Fn() -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static,

Create a new task that will be executed with tokio.

Example

let task = Task::tokio(now(), || async {
  println!("Hello, world!");
});

impl Task<Thread>

pub fn thread<S, F>(schedule: S, task: F) -> Self

where S: IntoSchedule, S::Output: Send + 'static, F: Fn() + Send + 'static + Clone,

impl Task<Promise>

pub fn promise<S, F, Fut>(schedule: S, task: F) -> Self

where S: IntoSchedule, S::Output: Send + 'static, F: Fn() -> Fut + Send + 'static, Fut: Future<Output = ()> + 'static,

Create a new task that will be executed with promise.

Example

async fn some_task() {

}

let task = Task::promise(now(), some_task);

impl Task<Local>

pub fn local<S, F>(schedule: S, task: F) -> Self

where S: IntoSchedule, S::Output: Send + 'static, F: Fn() + Send + 'static + Clone,

impl<R: Runtime> Task<R>

pub fn new<S, F, A>(schedule: S, run: F) -> Self

where S: IntoSchedule, F: IntoRunTaskFn<R, A>,

Create a new task.

The run function could have the following signature:

Fn(<&mut Runtime>?, ..Args)

the Args could be any type that implements TaskRunArg.

For now, these types are supported:

• TaskRun : information about this run.
• TaskUid : the task unique identifier.
• Dtu : the time when this task is scheduled to run.

For example, you can call this function like this:

let task = Task::<Local>::new(now(), |time: Dtu, id: TaskUid| {
   println!("Time: {time}, Uid: {id}");
});

impl<R: AsyncRuntime> Task<R>

pub fn new_async<S, F, A, Fut>(schedule: S, run: F) -> Self

where S: IntoSchedule, F: IntoRunTaskFn<R, Async<A, Fut>>,

This is basically the same as Task::new but with more hint for compiler that this is an async function.

Trait Implementations

impl<R: Runtime> Debug for Task<R>

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

Formats the value using the given formatter.