Struct TokioExecutor 

pub struct TokioExecutor;

Tokio executor

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 Copy for TokioExecutor

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 Eq for TokioExecutor

impl Executor for TokioExecutor

fn runtime_type(&self) -> Option<&'static str>

Returns an optional runtime name of the executor.

fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a new asynchronous task in the background, returning a Future JoinHandle for it.

fn spawn_abortable<F>(&self, future: F) -> AbortableJoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a new asynchronous task in the background, returning an abortable handle that will cancel the task once the handle is dropped.

fn dispatch<F>(&self, future: F)

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a new asynchronous task in the background without an handle. Basically the same as Executor::spawn.

fn spawn_coroutine<T, F, Fut>(&self, f: F) -> CommunicationTask<T>

where F: FnMut(T) -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static, T: Send + 'static,

Spawns a new asynchronous task that accepts messages to the task. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_coroutine_with_buffer<T, F, Fut>( &self, buffer: usize, f: F, ) -> CommunicationTask<T>

where F: FnMut(T) -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static, T: Send + 'static,

Spawns a new asynchronous task that accepts messages to the task with a set buffer. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_unbounded_coroutine<T, F, Fut>( &self, f: F, ) -> UnboundedCommunicationTask<T>

where F: FnMut(T) -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static, T: Send + 'static,

Spawns a new asynchronous task that accepts unbounded messages to the task. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_coroutine_with_context<T, C, F, Fut>( &self, context: C, f: F, ) -> CommunicationTask<T>

where F: FnMut(&mut C, T) -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static, C: Send + 'static, T: Send + 'static,

Spawns a new asynchronous task with provided context that accepts messages to the task. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_coroutine_with_buffer_and_context<T, C, F, Fut>( &self, context: C, buffer: usize, f: F, ) -> CommunicationTask<T>

where F: FnMut(&mut C, T) -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static, C: Send + 'static, T: Send + 'static,

Spawns a new asynchronous task with provided context that accepts messages to the task with a set buffer. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_unbounded_coroutine_with_context<T, C, F, Fut>( &self, context: C, f: F, ) -> UnboundedCommunicationTask<T>

where F: FnMut(&mut C, T) -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static, C: Send + 'static, T: Send + 'static,

Spawns a new asynchronous task with provided context that accepts unbounded messages to the task. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_coroutine_with_receiver<T, F, Fut>(&self, f: F) -> CommunicationTask<T>

where F: FnMut(Receiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task that accepts messages to the task using channels. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_coroutine_with_receiver_and_buffer<T, F, Fut>( &self, buffer: usize, f: F, ) -> CommunicationTask<T>

where F: FnMut(Receiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task with a set channel buffer that accepts messages to the task using channels. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_coroutine_with_receiver_and_context<T, F, C, Fut>( &self, context: C, f: F, ) -> CommunicationTask<T>

where F: FnMut(C, Receiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task with provided context that accepts messages to the task using channels. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_coroutine_with_receiver_buffer_and_context<T, F, C, Fut>( &self, context: C, buffer: usize, f: F, ) -> CommunicationTask<T>

where F: FnMut(C, Receiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task with a set channel buffer and provided context that accepts messages to the task using channels. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_unbounded_coroutine_with_receiver<T, F, Fut>( &self, f: F, ) -> UnboundedCommunicationTask<T>

where F: FnMut(UnboundedReceiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task that accepts messages to the task using channels. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn spawn_unbounded_coroutine_with_receiver_and_context<T, F, C, Fut>( &self, context: C, f: F, ) -> UnboundedCommunicationTask<T>

where F: FnMut(C, UnboundedReceiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task with provided context that accepts messages to the task using channels. This function returns a handle that allows sending a message, or if there is no reference to the handle at all (in other words, all handles are dropped), the task would be aborted.

fn scope<'env, F, T>(&self, f: F) -> impl Future<Output = T>

where F: for<'scope> AsyncFnOnce(&'scope Scope<'scope, 'env>) -> T,

Create a structured-concurrency scope in which tasks may be spawned that borrow from the enclosing stack frame.

fn executor_scope<'scope, F, T>(&'scope self, f: F) -> impl Future<Output = T>

where Self: Sized, F: AsyncFnOnce(&ScopeExecutor<'scope, Self>) -> T,

Run an async closure with a scoped Executor wrapper that forwards spawns to this executor, waits for all spawned tasks to finish when the closure returns, and aborts any outstanding tasks if the scope future itself is cancelled.

impl ExecutorBlockOn for TokioExecutor

fn block_on<F: Future>(&self, f: F) -> F::Output

Blocks the current thread until the provided future has completed. Note that this should not run inside a tokio runtime context.

impl ExecutorBlocking for TokioExecutor

fn spawn_blocking<F, R>(&self, f: F) -> JoinHandle<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Spawn a thread in the background with the ability to concurrently await on the results without blocking the executor.

fn spawn_blocking_abortable<F, R>(&self, f: F) -> AbortableJoinHandle<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Spawns a thread in the background, returning an abortable handle that will cancel it once the handle is dropped.

impl ExecutorTimeout for TokioExecutor

fn spawn_timeout<F>( &self, duration: Duration, f: F, ) -> JoinHandle<Result<F::Output, TimeoutError>>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a new asynchronous task in the background that must complete within duration, returning a JoinHandle.

fn spawn_delay<F>(&self, duration: Duration, f: F) -> JoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a task after waiting for a duration before the task is polled.

fn spawn_abortable_timeout<F>( &self, duration: Duration, f: F, ) -> AbortableJoinHandle<Result<F::Output, TimeoutError>>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns a new asynchronous task in the background that must complete within duration, returning an abortable handle that will cancel the task once the handle is dropped.

fn spawn_abortable_delay<F>( &self, duration: Duration, f: F, ) -> AbortableJoinHandle<F::Output>

where F: Future + Send + 'static, F::Output: Send + 'static,

Spawns an abortable task after waiting for duration before the task is polled.

impl PartialEq for TokioExecutor

fn eq(&self, other: &TokioExecutor) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for TokioExecutor

fn partial_cmp(&self, other: &TokioExecutor) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for TokioExecutor