Struct ExecutorDrain 

pub struct ExecutorDrain { /* private fields */ }

A future that completes when all tasks in an executor have finished.

ExecutorDrain is returned by Executor::drain_async() and implements Future<Output = ()>. It polls the executor’s internal state to determine when all tasks have completed execution.

Examples

use some_global_executor::Executor;
use some_executor::SomeExecutor;
use some_executor::task::{Task, Configuration};

let mut executor = Executor::new("async-drain".to_string(), 2);

// Spawn some work
let task = Task::without_notifications(
    "work".to_string(),
    Configuration::default(),
    async {
        // Simulate some work
        42
    }
);
executor.spawn(task);

// In async context, you would use:
// executor.drain_async().await;
// Here we use synchronous drain for the example
executor.drain();

Trait Implementations

impl AsMut<Executor> for ExecutorDrain

Provides mutable access to the underlying Executor from an ExecutorDrain.

This allows operations like resizing the thread pool even while draining.

Examples

use some_global_executor::{Executor, ExecutorDrain};

let executor = Executor::new("test".to_string(), 2);
let mut drain = executor.drain_async();
drain.as_mut().resize(4);  // Resize while draining

fn as_mut(&mut self) -> &mut Executor

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Executor> for ExecutorDrain

Provides immutable access to the underlying Executor from an ExecutorDrain.

Examples

use some_global_executor::{Executor, ExecutorDrain};

let executor = Executor::new("test".to_string(), 2);
let drain = executor.drain_async();
let name = drain.as_ref().name();
assert_eq!(name, "test");

fn as_ref(&self) -> &Executor

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for ExecutorDrain

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

Formats the value using the given formatter.

impl From<Executor> for ExecutorDrain

Converts an Executor into an ExecutorDrain future.

This conversion is equivalent to calling Executor::drain_async().

Examples

use some_global_executor::{Executor, ExecutorDrain};

let executor = Executor::new("test".to_string(), 2);
let drain: ExecutorDrain = executor.into();
// In async context: drain.await;
// For this example, convert back and drain:
let executor: Executor = drain.into();
executor.drain();

fn from(executor: Executor) -> Self

Converts to this type from the input type.

impl From<ExecutorDrain> for Executor

Converts an ExecutorDrain back to its underlying Executor.

This is useful when you need to access the executor after initiating a drain operation but before it completes.

Examples

use some_global_executor::{Executor, ExecutorDrain};

let executor = Executor::new("test".to_string(), 2);
let drain: ExecutorDrain = executor.into();
let executor: Executor = drain.into();
executor.drain();

fn from(drain: ExecutorDrain) -> Self

Converts to this type from the input type.

impl Future for ExecutorDrain

type Output = ()

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.