Struct BatchProcessor 

pub struct BatchProcessor<R, I, O> { /* private fields */ }

Explicit batch processor for a single inner runnable.

Differences from inner.batch(...):

• Honors per-instance BatchOptions.
• Has [process_with_results] returning a Vec<Result<O>> so partial failures don’t lose data.

Implementations

impl<R, I, O> BatchProcessor<R, I, O>

where R: Runnable<I, O>, I: Send + 'static, O: Send + 'static,

pub fn new(inner: R) -> Self

Wrap with default options.

pub fn with_options(inner: R, options: BatchOptions) -> Self

Wrap with explicit options.

pub fn inner(&self) -> &R

Borrow the inner runnable.

pub fn options_mut(&mut self) -> &mut BatchOptions

Mutably borrow options (e.g. to flip return_exceptions mid-life).

impl<R, I, O> BatchProcessor<R, I, O>

where R: Runnable<I, O> + Sync, I: Send + 'static, O: Send + 'static,

pub async fn process( &self, inputs: Vec<I>, config: RunnableConfig, ) -> Result<Vec<O>>

Run a batch and short-circuit on the first error. Equivalent to inner.batch(...) but honors BatchOptions::max_concurrency and wave_delay.

pub async fn process_with_results( &self, inputs: Vec<I>, config: RunnableConfig, ) -> Vec<Result<O>>

Run a batch and always return per-input results — failures surface as Err(CognisError) entries, successful invocations as Ok(O). Order matches the input order.