Struct DummyExecutor 

pub struct DummyExecutor;

Placeholder executor that does not provide task execution.

All execution methods panic when called.

Trait Implementations

impl Clone for DummyExecutor

fn clone(&self) -> DummyExecutor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DummyExecutor

impl Debug for DummyExecutor

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

Formats the value using the given formatter.

impl Default for DummyExecutor

fn default() -> DummyExecutor

Returns the “default value” for a type.

impl Eq for DummyExecutor

impl Executor for DummyExecutor

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

Returns an optional runtime name of the executor.

fn spawn<F>(&self, _: 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 DummyExecutor

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

Blocks the current thread until the provided future has completed.

impl ExecutorBlocking for DummyExecutor

fn spawn_blocking<F, R>(&self, _: 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 DummyExecutor

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 DummyExecutor

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for DummyExecutor

fn partial_cmp(&self, other: &DummyExecutor) -> 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 DummyExecutor