Enum BuiltinExecutor 

pub enum BuiltinExecutor {
    Tokio,
    Lite,
    Dummy,
}

Built-in executor types.

Variants

Tokio

Lite

Dummy

Trait Implementations

impl Clone for BuiltinExecutor

fn clone(&self) -> BuiltinExecutor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BuiltinExecutor

impl Debug for BuiltinExecutor

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

Formats the value using the given formatter.

impl Default for BuiltinExecutor

fn default() -> Self

Returns the “default value” for a type.

impl Eq for BuiltinExecutor

impl Executor for BuiltinExecutor

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 BuiltinExecutor

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

Blocks the current thread until the provided future has completed.

impl ExecutorBlocking for BuiltinExecutor

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 BuiltinExecutor

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 BuiltinExecutor

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BuiltinExecutor