Struct Executor

pub struct Executor<'tasks> { /* private fields */ }

The main executor type.

The lifetime parameter 'tasks is the lifetime of the tasks that are spawned on this executor, that is the lifetime of any data they may borrow, in case they are spawned with a reference to that data.

Implementations

impl<'tasks> Executor<'tasks>

pub fn new() -> Self

Creates a new executor.

pub fn do_some(&mut self)

Runs the executor until there is no more immediate work to be performed.

It is intended ot be called in a loop with Self::park_if_needed.

pub fn park_if_needed(&mut self)

Parks the thread if there are no tasks to be performed, until tasks are ready to be performed again.

pub fn drain(self)

Drains the executor. After this call, the executor can no longer be used.

This function will return when all spawned tasks complete.

pub fn has_unfinished_tasks(&self) -> bool

Returns true if there are tasks that are not yet complete.

Trait Implementations

impl<'tasks> Debug for Executor<'tasks>

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

Formats the value using the given formatter.

impl Default for Executor<'_>

fn default() -> Self

Returns the “default value” for a type.

impl From<&mut Executor<'_>> for SomeExecutorAdapter

fn from(executor: &mut Executor<'_>) -> Self

Converts to this type from the input type.

impl<'future> SomeLocalExecutor<'future> for Executor<'future>

Implementation of the SomeLocalExecutor trait from the some_executor project.

This is the main interface to spawn tasks onto the executor.

For details on this trait, see SomeLocalExecutor.

type ExecutorNotifier = Infallible

fn spawn_local<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> Observer<F::Output, Self::ExecutorNotifier>

where Self: Sized, F: 'future + Future, <F as Future>::Output: Unpin,

Spawns a future onto the runtime.

fn spawn_local_async<F, Notifier: ObserverNotified<F::Output>>( &mut self, task: Task<F, Notifier>, ) -> impl Future<Output = Observer<F::Output, Self::ExecutorNotifier>>

where Self: Sized, F: 'future + Future,

Spawns a future onto the runtime.

fn spawn_local_objsafe( &mut self, task: Task<Pin<Box<dyn Future<Output = Box<dyn Any>>>>, Box<dyn ObserverNotified<dyn Any + 'static>>>, ) -> Observer<Box<dyn Any>, Box<dyn ExecutorNotified>>

Spawns a future onto the runtime.

fn spawn_local_objsafe_async<'executor>( &'executor mut self, task: Task<Pin<Box<dyn Future<Output = Box<dyn Any>>>>, Box<dyn ObserverNotified<dyn Any + 'static>>>, ) -> Box<dyn Future<Output = Observer<Box<dyn Any>, Box<dyn ExecutorNotified>>> + 'executor>

fn executor_notifier(&mut self) -> Option<Self::ExecutorNotifier>

impl<'tasks> LocalExecutorExt<'tasks> for Executor<'tasks>