Struct BatchProcessor 

pub struct BatchProcessor { /* private fields */ }

High-performance batch processor for HEDL files.

Orchestrates parallel or serial processing based on configuration and workload. Provides progress tracking and comprehensive error collection.

Thread Safety

BatchProcessor is thread-safe and can be shared across threads via Arc.

Examples

use hedl_cli::batch::{BatchProcessor, BatchConfig, ValidationOperation};
use std::path::PathBuf;

let processor = BatchProcessor::new(BatchConfig {
    parallel_threshold: 5,
    verbose: true,
    ..Default::default()
});

let files: Vec<PathBuf> = vec![
    "file1.hedl".into(),
    "file2.hedl".into(),
];

let results = processor.process(
    &files,
    ValidationOperation { strict: false },
    true,
)?;

if results.has_failures() {
    eprintln!("Some files failed validation");
    for failure in results.failures() {
        eprintln!("  - {}: {:?}", failure.path.display(), failure.result);
    }
}

Implementations

impl BatchProcessor

pub fn new(config: BatchConfig) -> Self

Create a new batch processor with the given configuration.

pub fn default_config() -> Self

Create a batch processor with default configuration.

pub fn process<O>( &self, files: &[PathBuf], operation: O, show_progress: bool, ) -> Result<BatchResults<O::Output>, CliError>

where O: BatchOperation,

Process multiple files with the given operation.

Automatically selects parallel or serial processing based on configuration and file count. Provides progress reporting and collects all results.

Arguments

• files - Slice of file paths to process
• operation - The operation to perform on each file
• show_progress - Whether to show progress updates

Returns

• Ok(BatchResults) - Always succeeds and collects all individual results
• Err(CliError) - Only on catastrophic failures (e.g., thread pool creation)

Performance

• Uses parallel processing if files.len() >= config.parallel_threshold
• Serial processing for small batches to avoid thread pool overhead
• Lock-free progress tracking using atomic counters

Examples

use hedl_cli::batch::{BatchProcessor, BatchConfig, FormatOperation};
use std::path::PathBuf;

let processor = BatchProcessor::default_config();
let files = vec![PathBuf::from("a.hedl"), PathBuf::from("b.hedl")];

let results = processor.process(
    &files,
    FormatOperation {
        check: false,
        ditto: true,
        with_counts: false,
    },
    true,
)?;

println!("Formatted {} files", results.success_count());

Trait Implementations

impl Clone for BatchProcessor

fn clone(&self) -> BatchProcessor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BatchProcessor

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

Formats the value using the given formatter.