Struct TokioBlockingTaskHandle 

pub struct TokioBlockingTaskHandle<R, E> { /* private fields */ }

Tracked handle for tasks submitted to Tokio’s blocking task pool.

This handle wraps the standard TrackedTask result/status endpoint and additionally keeps Tokio’s AbortHandle so pre-start cancellation can remove queued spawn_blocking work from the Tokio runtime.

Tokio cannot abort blocking work after the closure has started. In that case Self::cancel reports CancelResult::AlreadyRunning through the underlying tracked task state.

Implementations

impl<R, E> TokioBlockingTaskHandle<R, E>

pub fn get(self) -> Result<R, TaskExecutionError<E>>

where R: Send, E: Send,

Waits for the task to finish and returns its final result.

This method blocks the current thread until a result is available.

Returns

The final task result.

pub fn try_get(self) -> TryGet<TokioBlockingTaskHandle<R, E>, R, E>

where R: Send, E: Send,

Attempts to retrieve the final result without blocking.

Returns

A ready result or the pending handle.

pub fn is_done(&self) -> bool

where R: Send, E: Send,

Returns whether the task has installed a terminal state.

Returns

true after the task succeeds, fails, panics, is cancelled, or loses its runner endpoint.

pub fn status(&self) -> TaskStatus

Returns the currently observed task status.

Returns

The current task status.

pub fn cancel(&self) -> CancelResult

Attempts to cancel this task before its blocking closure starts.

When cancellation wins the pending-state race, this method also aborts the Tokio spawn_blocking task so queued work is dropped without waiting for an available blocking thread.

Returns

The observed cancellation outcome.

Trait Implementations

impl<R, E> IntoFuture for TokioBlockingTaskHandle<R, E>

fn into_future( self, ) -> <TokioBlockingTaskHandle<R, E> as IntoFuture>::IntoFuture

Converts this tracked handle into a future resolving to the task result.

type Output = Result<R, TaskExecutionError<E>>

The output that the future will produce on completion.

type IntoFuture = TaskHandleFuture<R, E>

Which kind of future are we turning this into?

impl<R, E> TaskResultHandle<R, E> for TokioBlockingTaskHandle<R, E>

where R: Send, E: Send,

fn is_done(&self) -> bool

Returns whether the tracked state is terminal.

fn get(self) -> Result<R, TaskExecutionError<E>>

Blocks until the underlying result handle yields a result.

fn try_get(self) -> TryGet<TokioBlockingTaskHandle<R, E>, R, E>

Attempts to retrieve the underlying result without blocking.

impl<R, E> TrackedTaskHandle<R, E> for TokioBlockingTaskHandle<R, E>

where R: Send, E: Send,

fn status(&self) -> TaskStatus

Returns the currently observed task status.

fn cancel(&self) -> CancelResult

Attempts to cancel the task before it starts.