Struct tokio_compat::runtime::TaskExecutor

pub struct TaskExecutor { /* fields omitted */ }

This is supported on (feature="rt-current-thread" or feature="rt-full") and feature="rt-full" only.

Executes futures on the runtime

All futures spawned using this executor will be submitted to the associated Runtime's executor. This executor is usually a thread pool.

For more details, see the module level documentation.

Methods

impl TaskExecutor

pub fn spawn<F>(&self, future: F) where
    F: Future01<Item = (), Error = ()> + Send + 'static, 

This is supported on feature="rt-current-thread" or feature="rt-full" only.

Spawn a futures 0.1 future onto the Tokio runtime.

This spawns the given future onto the runtime's executor, usually a thread pool. The thread pool is then responsible for polling the future until it completes.

See module level documentation for more details.

Examples

use tokio_compat::runtime::Runtime;
// Create the runtime
let rt = Runtime::new().unwrap();
let executor = rt.executor();

// Spawn a `futures` 0.1 future onto the runtime
executor.spawn(futures_01::future::lazy(|| {
    println!("now running on a worker thread");
    Ok(())
}));

pub fn spawn_std<F>(&self, future: F) where
    F: Future<Output = ()> + Send + 'static, 

This is supported on feature="rt-current-thread" or feature="rt-full" only.

Spawn a std::future future onto the Tokio runtime.

This spawns the given future onto the runtime's executor, usually a thread pool. The thread pool is then responsible for polling the future until it completes.

See module level documentation for more details.

Examples

use tokio_compat::runtime::Runtime;

// Create the runtime
let rt = Runtime::new().unwrap();
let executor = rt.executor();

// Spawn a `std::future` future onto the runtime
executor.spawn_std(async {
    println!("now running on a worker thread");
});

pub fn spawn_handle<F>(
    &self,
    future: F
) -> JoinHandle<Result<F::Item, F::Error>> where
    F: Future01 + Send + 'static,
    F::Item: Send + 'static,
    F::Error: Send + 'static, 

This is supported on feature="rt-current-thread" or feature="rt-full" only.

Spawn a futures 0.1 future onto the Tokio runtime, returning a JoinHandle that can be used to await its result.

This spawns the given future onto the runtime's executor, usually a thread pool. The thread pool is then responsible for polling the future until it completes.

Note that futures spawned in this manner do not "count" towards keeping the runtime active for shutdown_on_idle, since they are paired with a JoinHandle for awaiting their completion. See here for details on shutting down the compatibility runtime.

Examples

use tokio_compat::runtime::Runtime;
// Create the runtime
let rt = Runtime::new().unwrap();
let executor = rt.executor();

// Spawn a `futures` 0.1 future onto the runtime
executor.spawn(futures_01::future::lazy(|| {
    println!("now running on a worker thread");
    Ok(())
}));

pub fn spawn_handle_std<F>(&self, future: F) -> JoinHandle<F::Output> where
    F: Future + Send + 'static,
    F::Output: Send + 'static, 

This is supported on feature="rt-current-thread" or feature="rt-full" only.

Spawn a std::future future onto the Tokio runtime, returning a JoinHandle that can be used to await its result.

This spawns the given future onto the runtime's executor, usually a thread pool. The thread pool is then responsible for polling the future until it completes.

See module level documentation for more details.

Note that futures spawned in this manner do not "count" towards keeping the runtime active for shutdown_on_idle, since they are paired with a JoinHandle for awaiting their completion. See here for details on shutting down the compatibility runtime.

Examples

use tokio_compat::runtime::Runtime;

// Create the runtime
let rt = Runtime::new().unwrap();
let executor = rt.executor();

// Spawn a `std::future` future onto the runtime
executor.spawn_std(async {
    println!("now running on a worker thread");
});

Panics

This function panics if the spawn fails. Failure occurs if the executor is currently at capacity and is unable to spawn a new future.

Trait Implementations

impl Clone for TaskExecutor

fn clone(&self) -> TaskExecutor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TaskExecutor

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

Formats the value using the given formatter.

impl<T> Executor<T> for TaskExecutor where
    T: Future01<Item = (), Error = ()> + Send + 'static, 

fn execute(&self, future: T) -> Result<(), ExecuteError<T>>

Spawns a future to run on this Executor, typically in the "background".

impl Executor for TaskExecutor

fn spawn(
    &mut self,
    future: Box<dyn Future01<Item = (), Error = ()> + Send>
) -> Result<(), SpawnError>

Spawns a future object to run on this executor.

fn status(&self) -> Result<(), SpawnError>

Provides a best effort hint to whether or not spawn will succeed.

impl<T> TypedExecutor<T> for TaskExecutor where
    T: Future01<Item = (), Error = ()> + Send + 'static, 

fn spawn(&mut self, future: T) -> Result<(), SpawnError>

Spawns a future to run on this executor.

fn status(&self) -> Result<(), SpawnError>

Provides a best effort hint to whether or not spawn will succeed.