Struct TokioExecutor 

pub struct TokioExecutor;

Executes callable tasks on Tokio’s blocking task pool.

TokioExecutor is a FutureExecutor: its Executor::call and Executor::execute methods return a TokioExecution value that implements Future with Output = Result<R, E>. You obtain the callable’s result by .awaiting (or polling) that future; it is not a resolved Result at return time.

Semantics

• call schedules work immediately — Executor::call runs tokio::task::spawn_blocking synchronously before it returns. A Tokio runtime must already be active on the current thread when call runs (for example inside an async block executed under Runtime::block_on or #[tokio::main]). Calling call first and only then entering a runtime is wrong: the blocking task was submitted with no runtime at call time.
• Any normal Tokio entry point works — you are not restricted to Builder::new_current_thread; a multi-thread Runtime or an async handler in a server is fine, as long as call happens while that runtime is running.
• Await the returned future on Tokio — the TokioExecution polls a JoinHandle; complete it with .await inside the same kind of Tokio-driven async context.
• Blocking pool — the closure runs on Tokio’s blocking thread pool, not on the core async worker threads, so heavy synchronous work does not starve other async tasks on the runtime.
• Compared to ThreadPerTaskExecutor — this type reuses Tokio-managed blocking threads (bounded pool) instead of one new std::thread per task, and you await the result instead of calling a blocking TaskHandle::get.

Examples

The following uses a single-thread Runtime only to keep the snippet self-contained; #[tokio::main] or a multi-thread runtime are equally valid.

use std::io;

use qubit_tokio_executor::{
    Executor,
    TokioExecutor,
};

tokio::runtime::Builder::new_current_thread()
    .enable_all()
    .build()?
    .block_on(async {
        let executor = TokioExecutor;
        let value = executor.call(|| Ok::<i32, io::Error>(40 + 2)).await?;
        assert_eq!(value, 42);
        Ok::<(), io::Error>(())
    })?;

Trait Implementations

impl Clone for TokioExecutor

fn clone(&self) -> TokioExecutor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokioExecutor

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

Formats the value using the given formatter.

impl Default for TokioExecutor

fn default() -> TokioExecutor

Returns the “default value” for a type.

impl Executor for TokioExecutor

fn call<C, R, E>(&self, task: C) -> Self::Execution<R, E>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Display + Send + 'static,

Spawns the callable on Tokio’s blocking task pool.

This method invokes tokio::task::spawn_blocking before returning. A Tokio runtime must be active when this method runs; see TokioExecutor.

Parameters

• task - Callable to run on Tokio’s blocking task pool.

Returns

A TokioExecution that implements Future with Output = Result<R, E>. Await it to obtain the callable’s result.

type Execution<R, E> = TokioExecution<R, E> where R: Send + 'static, E: Display + Send + 'static

The result carrier returned for one execution.

fn execute<T, E>(&self, task: T) -> Self::Execution<(), E>

where T: Runnable<E> + Send + 'static, E: Display + Send + 'static,

Executes a runnable task and returns this executor’s result carrier.

impl Copy for TokioExecutor

impl FutureExecutor for TokioExecutor