Struct SequentialBatchExecutor 

pub struct SequentialBatchExecutor { /* private fields */ }

Executes a whole batch sequentially on the caller thread.

Progress updates are emitted only between tasks. A long-running single task therefore does not produce intermediate sequential progress callbacks.

use qubit_batch::{
    BatchExecutor,
    SequentialBatchExecutor,
};

let outcome = SequentialBatchExecutor::new()
    .for_each(["a", "b", "c"], |item| {
        assert!(!item.is_empty());
        Ok::<(), &'static str>(())
    })
    .expect("array length should be exact");

assert!(outcome.is_success());

Implementations

impl SequentialBatchExecutor

pub const DEFAULT_REPORT_INTERVAL: Duration

Default interval between progress callbacks.

pub fn new() -> Self

Creates a sequential batch executor with default configuration.

Returns

A sequential batch executor using no-op progress reporting.

pub fn builder() -> SequentialBatchExecutorBuilder

Creates a builder for configuring a sequential batch executor.

Returns

A builder initialized with default settings.

pub const fn report_interval(&self) -> Duration

Returns the configured progress-report interval.

Returns

The minimum time between due-based running progress callbacks.

pub fn reporter(&self) -> &Arc<dyn ProgressReporter>

Returns the progress reporter used by this executor.

Returns

A shared reference to the configured progress reporter.

Trait Implementations

impl BatchExecutor for SequentialBatchExecutor

fn execute_with_count<T, E, I>( &self, tasks: I, count: usize, ) -> Result<BatchOutcome<E>, BatchExecutionError<E>>

where I: IntoIterator<Item = T>, T: Runnable<E> + Send, E: Send,

Executes the batch sequentially on the caller thread.

Parameters

• tasks - Task source for the batch.
• count - Declared task count expected from tasks.

Returns

A structured batch result when the declared task count matches, or a batch-count mismatch error with the attached partial result.

Errors

Returns BatchExecutionError when tasks yields fewer or more tasks than count.

Panics

Panics from tasks are captured in the result. Panics from the configured progress reporter are propagated to the caller.

fn execute<T, E, I>( &self, tasks: I, ) -> Result<BatchOutcome<E>, BatchExecutionError<E>>

where I: IntoIterator<Item = T>, I::IntoIter: ExactSizeIterator, T: Runnable<E> + Send, E: Send,

Executes a batch of runnable tasks whose iterator exposes an exact length.

fn call<C, R, E, I>( &self, tasks: I, ) -> Result<BatchCallResult<R, E>, BatchExecutionError<E>>

where I: IntoIterator<Item = C>, I::IntoIter: ExactSizeIterator, C: Callable<R, E> + Send, R: Send, E: Send,

Executes callable tasks whose iterator exposes an exact length.

fn call_with_count<C, R, E, I>( &self, tasks: I, count: usize, ) -> Result<BatchCallResult<R, E>, BatchExecutionError<E>>

where I: IntoIterator<Item = C>, C: Callable<R, E> + Send, R: Send, E: Send,

Executes callable tasks with an explicit declared count and collects success values by index.

fn for_each<Item, E, I, F>( &self, items: I, action: F, ) -> Result<BatchOutcome<E>, BatchExecutionError<E>>

where I: IntoIterator<Item = Item>, I::IntoIter: ExactSizeIterator, Item: Send, F: Fn(Item) -> Result<(), E> + Send + Sync, E: Send,

Applies action to every item whose iterator exposes an exact length.

fn for_each_with_count<Item, E, I, F>( &self, items: I, count: usize, action: F, ) -> Result<BatchOutcome<E>, BatchExecutionError<E>>

where I: IntoIterator<Item = Item>, Item: Send, F: Fn(Item) -> Result<(), E> + Send + Sync, E: Send,

Applies action to every item using an explicit declared count.

impl Clone for SequentialBatchExecutor

fn clone(&self) -> SequentialBatchExecutor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for SequentialBatchExecutor

fn default() -> Self

Creates a sequential batch executor with default configuration.

Returns

A sequential batch executor using no-op progress reporting.