Struct TrackerExecutor

pub struct TrackerExecutor<E> { /* private fields */ }

Track running tasks.

Note that there is no guarantee that the runtime would drop the future after it is done, therefore this should only be used for purely approx statistics and not actual numbers. Additionally, it does not track any tasks spawned directly by the runtime but only by Executor::spawn through this struct.

Implementations

impl<E: Executor> TrackerExecutor<E>

pub fn new(executor: E) -> Self

pub fn count(&self) -> usize

Number of active tasks.

Trait Implementations

impl<E> Debug for TrackerExecutor<E>

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

Formats the value using the given formatter.

impl<E: Executor> Executor for TrackerExecutor<E>

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 an 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(Receiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task that accepts messages to the task using channels. This function returns an 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, 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 an 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(UnboundedReceiver<T>) -> Fut, Fut: Future<Output = ()> + Send + 'static,

Spawns a new asynchronous task that accepts messages to the task using channels. This function returns an 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, 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 an 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.