Struct LiteRuntimeExecutor 

pub struct LiteRuntimeExecutor { /* private fields */ }

A light single-threaded executor with minimal dependencies.

Tasks only make progress while LiteRuntimeExecutor::block_on is running. Only one thread may drive an executor and its clones at a time.

Implementations

impl LiteRuntimeExecutor

pub fn new() -> Self

Creates a new lightweight runtime.

Trait Implementations

impl Clone for LiteRuntimeExecutor

fn clone(&self) -> LiteRuntimeExecutor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LiteRuntimeExecutor

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

Formats the value using the given formatter.

impl Default for LiteRuntimeExecutor

fn default() -> LiteRuntimeExecutor

Returns the “default value” for a type.

impl Eq for LiteRuntimeExecutor

impl Executor for LiteRuntimeExecutor

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 LiteRuntimeExecutor

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

Blocks the current thread until the provided future has completed.

impl ExecutorBlocking for LiteRuntimeExecutor

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 LiteRuntimeExecutor

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 LiteRuntimeExecutor

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

Equality operator ==.

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

Inequality operator !=.