Struct ParallelConfig 

pub struct ParallelConfig { /* private fields */ }

Configuration for parallel processing behavior.

Controls thread pool size, chunking thresholds, resource limits, and performance tuning parameters.

Security Limits

To prevent denial-of-service attacks and resource exhaustion, the following limits are enforced:

• Maximum threads: 128
• Maximum input size: 100MB (configurable)
• Maximum document count: 100,000 (configurable)

Examples

use fast_yaml_parallel::ParallelConfig;

let config = ParallelConfig::new()
    .with_thread_count(Some(8))
    .with_min_chunk_size(2048);

Implementations

impl ParallelConfig

pub fn new() -> Self

Creates default configuration (auto thread count).

Examples

use fast_yaml_parallel::ParallelConfig;

let config = ParallelConfig::new();

pub const fn with_thread_count(self, count: Option<usize>) -> Self

Sets thread pool size.

• None: Use all available CPU cores (default, capped at 128)
• Some(0): Sequential processing (no parallelism)
• Some(n): Use exactly n threads (max 128)

Security

Thread count is capped at 128 to prevent resource exhaustion. Values exceeding this limit will be clamped at runtime.

Examples

use fast_yaml_parallel::ParallelConfig;

let config = ParallelConfig::new().with_thread_count(Some(4));

pub const fn with_max_input_size(self, size: usize) -> Self

Sets maximum total input size in bytes.

Input exceeding this size will be rejected with ConfigError. Default: 100MB

Security

This limit prevents denial-of-service attacks via extremely large inputs.

Examples

use fast_yaml_parallel::ParallelConfig;

// Allow up to 200MB
let config = ParallelConfig::new()
    .with_max_input_size(200 * 1024 * 1024);

pub const fn with_max_documents(self, count: usize) -> Self

Sets maximum number of documents allowed.

Input with more documents than this will be rejected with ConfigError. Default: 100,000

Security

This limit prevents denial-of-service attacks via excessive document counts.

Examples

use fast_yaml_parallel::ParallelConfig;

// Allow up to 1 million documents
let config = ParallelConfig::new()
    .with_max_documents(1_000_000);

pub const fn with_min_chunk_size(self, size: usize) -> Self

Sets minimum total size in bytes for parallel processing.

If total input size is below this threshold AND fewer than 4 documents, sequential processing will be used to avoid parallelism overhead. Default: 4KB

Examples

use fast_yaml_parallel::ParallelConfig;

let config = ParallelConfig::new().with_min_chunk_size(2048);

pub const fn with_max_chunk_size(self, size: usize) -> Self

Sets maximum chunk size in bytes.

Large documents exceeding this will be processed sequentially. Default: 10MB (prevents memory spikes)

Examples

use fast_yaml_parallel::ParallelConfig;

let config = ParallelConfig::new().with_max_chunk_size(5 * 1024 * 1024);

impl ParallelConfig

pub const fn thread_count(&self) -> Option<usize>

Returns thread count setting.

• None: Auto-detect (use CPU count, capped at 128)
• Some(0): Sequential processing
• Some(n): Use exactly n threads (capped at 128)

pub const fn max_input_size(&self) -> usize

Returns maximum input size limit.

pub const fn max_documents(&self) -> usize

Returns maximum document count limit.

Trait Implementations

impl Clone for ParallelConfig

fn clone(&self) -> ParallelConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParallelConfig

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

Formats the value using the given formatter.

impl Default for ParallelConfig

fn default() -> Self

Returns the “default value” for a type.