Struct RawTask 

pub(crate) struct RawTask<F, T, S, M> {
    pub(crate) header: *const Header<M>,
    pub(crate) schedule: *const S,
    pub(crate) future: *mut F,
    pub(crate) output: *mut Result<T, Box<dyn Any + Send + 'static>>,
}

Raw pointers to the fields inside a task.

Fields

header: *const Header<M>

The task header.

schedule: *const S

The schedule function.

future: *mut F

The future.

output: *mut Result<T, Box<dyn Any + Send + 'static>>

The output of the future.

Implementations

impl<F, T, S, M> RawTask<F, T, S, M>

const TASK_LAYOUT: TaskLayout

const fn eval_task_layout() -> TaskLayout

Computes the memory layout for a task.

impl<F, T, S, M> RawTask<F, T, S, M>

where F: Future<Output = T>, S: Schedule<M>,

const RAW_WAKER_VTABLE: RawWakerVTable

pub(crate) fn allocate<'a, Gen: FnOnce(&'a M) -> F>( future: Gen, schedule: S, builder: Builder<M>, ) -> NonNull<()>

where F: 'a, M: 'a,

Allocates a task with the given future and schedule function.

It is assumed that initially only the Runnable and the Task exist.

pub(crate) fn from_ptr(ptr: *const ()) -> Self

Creates a RawTask from a raw task pointer.

fn task_layout() -> TaskLayout

Returns the layout of the task.

unsafe fn wake(ptr: *const ())

Wakes a waker.

unsafe fn wake_by_ref(ptr: *const ())

Wakes a waker by reference.

unsafe fn clone_waker(ptr: *const ()) -> RawWaker

Clones a waker.

unsafe fn drop_waker(ptr: *const ())

Drops a waker.

This function will decrement the reference count. If it drops down to zero, the associated Task has been dropped too, and the task has not been completed, then it will get scheduled one more time so that its future gets dropped by the executor.

unsafe fn drop_ref(ptr: *const ())

Drops a task reference (Runnable or Waker).

This function will decrement the reference count. If it drops down to zero and the associated Task handle has been dropped too, then the task gets destroyed.

unsafe fn schedule(ptr: *const (), info: ScheduleInfo)

Schedules a task for running.

This function doesn’t modify the state of the task. It only passes the task reference to its schedule function.

unsafe fn drop_future(ptr: *const ())

Drops the future inside a task.

unsafe fn get_output(ptr: *const ()) -> *const ()

Returns a pointer to the output inside a task.

unsafe fn destroy(ptr: *const ())

Cleans up task’s resources and deallocates it.

The schedule function will be dropped, and the task will then get deallocated. The task must be closed before this function is called.

unsafe fn run(ptr: *const ()) -> bool

Runs a task.

If polling its future panics, the task will be closed and the panic will be propagated into the caller.

Trait Implementations

impl<F, T, S, M> Clone for RawTask<F, T, S, M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F, T, S, M> Copy for RawTask<F, T, S, M>