Struct Task

#[repr(C)]
pub struct Task<S, F: Future, STO> { /* private fields */ }

A task.

This type contains the various components of a task: the future itself, the task’s header, and a reference to the task’s scheduler. When a task is spawned, the Task type is placed on the heap (or wherever spawned tasks are stored), and a type-erased TaskRef that points to that Task is returned. Once a task is spawned, it is primarily interacted with via TaskRefs.

Vtables and Type Erasure

The Task struct, once spawned, is rarely interacted with directly. Because a system may spawn any number of different Future types as tasks, and may potentially also contain multiple types of scheduler and/or task storage, the scheduler and other parts of the system generally interact with tasks via type-erased TaskRefs.

However, in order to actually poll a task’s Future, or perform other operations such as deallocating a task, it is necessary to know the type of the the task’s Future (and potentially, that of the scheduler and/or storage). Therefore, operations that are specific to the task’s S-typed scheduler, F-typed Future, and STO-typed Storage are performed via dynamic dispatch.

Implementations

impl<S, F, STO> Task<S, F, STO>

where S: Schedule + 'static, F: Future, STO: Storage<S, F>,

pub fn new(future: F) -> Self

Create a new (non-heap-allocated) Task.

This needs to be heap allocated using an implementor of the Storage trait to be used with the scheduler.

pub fn id(&self) -> TaskId

Returns a TaskId that uniquely identifies this task.

The returned ID does not increment the task’s reference count, and may persist even after the task it identifies has completed and been deallocated.

Trait Implementations

impl<S, F, STO> Debug for Task<S, F, STO>

where F: Future,

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

Formats the value using the given formatter.

impl<S, F, STO> Drop for Task<S, F, STO>

where F: Future,

fn drop(&mut self)

Executes the destructor for this type.

impl<S, F, STO> Send for Task<S, F, STO>

where S: Send, F: Future + Send,

impl<S, F, STO> Sync for Task<S, F, STO>

where S: Sync, F: Future + Sync,