Struct async_task::WithInfo

pub struct WithInfo<F>(pub F);

Pass a scheduling function with more scheduling information - a.k.a. ScheduleInfo.

Sometimes, it’s useful to pass the runnable’s state directly to the scheduling function, such as whether it’s woken up while running. The scheduler can thus use the information to determine its scheduling strategy.

The data source of ScheduleInfo is directly from the actual implementation of the crate itself, different from Runnable’s metadata, which is managed by the caller.

Examples

use async_task::{ScheduleInfo, WithInfo};
use std::sync::{Arc, Mutex};

// The future inside the task.
let future = async {
    println!("Hello, world!");
};

// If the task gets woken up while running, it will be sent into this channel.
let (s, r) = flume::unbounded();
// Otherwise, it will be placed into this slot.
let lifo_slot = Arc::new(Mutex::new(None));
let schedule = move |runnable, info: ScheduleInfo| {
    if info.woken_while_running {
        s.send(runnable).unwrap()
    } else {
        let last = lifo_slot.lock().unwrap().replace(runnable);
        if let Some(last) = last {
            s.send(last).unwrap()
        }
    }
};

// Create a task with the future and the schedule function.
let (runnable, task) = async_task::spawn(future, WithInfo(schedule));

Tuple Fields

0: F

Trait Implementations

impl<F: Debug> Debug for WithInfo<F>

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

Formats the value using the given formatter.

impl<F> From<F> for WithInfo<F>

fn from(value: F) -> Self

Converts to this type from the input type.

impl<M, F> Schedule<M> for WithInfo<F>

where F: Fn(Runnable<M>, ScheduleInfo),

fn schedule(&self, runnable: Runnable<M>, info: ScheduleInfo)

The actual scheduling procedure.