Struct stakker::task::Task

pub struct Task { /* private fields */ }

An asynchronous task reference

Stakker provides only a very thin wrapping to enable tasks. Full support is provided in a separate crate (stakker_async_await). A task is represented as an implementation of the TaskTrait trait which is called when the task needs to be resumed. It is expected that even if the task cannot advance, it will accept a spurious call gracefully. Spurious calls may be generated for example if the task is woken from another thread.

It is guaranteed that the task is resumed directly from the main loop, not within any actor call nor any deeper down the stack. This may be important in order to avoid RefCell panics, or to allow the use of UnsafeCell. Internally this is statically guaranteed by using an ActorCell to wrap the closure. This code also handles the pinning required for running futures.

Deeper down the stack whilst the task is running, it is possible to get a reference to the running task by using Task::from_context. This may be used to implement efficient same-thread wakers.

Implementations

impl Task

pub fn new(core: &mut Core, inner: impl TaskTrait + 'static) -> Self

Create a new task from an implementation of the TaskTrait, and return a reference to it. (Task is like an Rc reference to the task.) The resume method will be called each time the task needs to be resumed.

pub fn resume(&mut self, s: &mut Stakker)

Resume execution of the task. The task will advance its state as much as possible, and then return. It’s intended that whatever poll-handler caused the task to yield will have saved a reference to this task to keep it alive until it can be woken again.

pub fn from_context(deferrer: &Deferrer) -> Option<Self>

Obtain the Task reference of the currently-running task from the provided Deferrer, if a task is currently running.

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a copy of the value.

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

Performs copy-assignment from source.