Struct DelayExecutor 

pub struct DelayExecutor { /* private fields */ }

Executor that starts each task after a fixed delay.

DelayExecutor is a small non-blocking submission strategy for cases where one task should run later while the caller must return immediately. It models delayed start, not minimum execution duration.

Each accepted task gets its own helper OS thread. The helper thread sleeps for the configured delay and then runs the task. This keeps the submitting thread unblocked without requiring a shared timer, queue, runtime, or scheduler worker. It is intentionally not a general-purpose delayed task scheduler and does not coalesce timers across tasks.

The returned TrackedTask is created immediately. Dropping the handle does not cancel the helper thread; use TrackedTask::cancel before the helper thread starts the task when pre-start cancellation is needed.

Implementations

impl DelayExecutor

pub fn new(delay: Duration) -> Self

Creates an executor that delays task start by the supplied duration.

Parameters

• delay - Duration to wait before running each task.

Returns

A delay executor using the supplied delay.

pub fn with_hook(self, hook: Arc<dyn TaskHook>) -> Self

Returns a copy of this executor using the supplied task hook.

Parameters

• hook - Hook notified about accepted task lifecycle events.

Returns

This executor configured with hook.

pub fn with_stack_size(self, stack_size: usize) -> Self

Returns a copy of this executor using the supplied helper thread stack size.

Parameters

• stack_size - Stack size in bytes for each helper thread.

Returns

This executor configured with stack_size.

pub const fn delay(&self) -> Duration

Returns the configured delay.

Returns

The duration waited before each task starts.

Trait Implementations

impl Clone for DelayExecutor

fn clone(&self) -> DelayExecutor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Executor for DelayExecutor

fn call<C, R, E>(&self, task: C) -> Result<TrackedTask<R, E>, SubmissionError>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Starts a helper thread that waits and then runs the callable.

This method returns after the helper thread has been spawned; it does not wait for the configured delay or for task completion.

Parameters

• task - Callable to run after the configured delay.

Returns

A TrackedTask for the delayed task.

Errors

Returns SubmissionError::WorkerSpawnFailed if the helper thread cannot be created.

fn execute<T, E>(&self, task: T) -> Result<TrackedTask<(), E>, SubmissionError>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Submits a runnable task and returns a tracked task handle.