Struct TaskHandle 

pub struct TaskHandle<T> { /* private fields */ }

A task handle that allows to get task result when the task is completed or cancel it if necessary.

Implementations

impl<T> TaskHandle<T>

pub fn abort(&self)

Aborts the task associated with the handle.

pub fn cancel(&mut self)

Cancels the task associated with the handle. Whether the task handles cancellation event (using crate::try_await macro) or not depends on task itself. If the task doesn’t implement cancellation handling it continue to execute until it finishes or being aborted.

Examples found in repository

examples/cancelation.rs (line 31)

async fn main() {
    let mut task_handles = Vec::new();
    for i in 0..5 {
        let duration = i as u64;
        task_handles.push(cm::spawn(outer_func(i, duration)));
    }

    let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
    for (i, mut handle) in task_handles.into_iter().enumerate() {
        if tokio::time::timeout_at(deadline, &mut handle).await.is_ok() {
            println!("task-{} completed", i);
        } else {
            handle.cancel();
            match handle.await {
                Result::Err(TaskError::Canceled) => println!("task-{} canceled", i),
                Result::Err(TaskError::Aborted) => println!("task-{} aborted", i),
                Result::Err(TaskError::Panicked(_)) => println!("task-{} panicked", i),
                Result::Ok(_) => unreachable!(),
            }
        }
    }
}

Trait Implementations

impl<T> Future for TaskHandle<T>

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Polls for the task completion. The task could be completed successfully returning Ok or exited with an Err<TaskError> error. In the last case the actual reason (cancellation, abortion or panicking) could be fetched from the error.

type Output = Result<T, TaskError>

The type of value produced on completion.