Struct CompressionConfig 

pub struct CompressionConfig {
    pub algorithm: CompressionAlgorithm,
    pub level: CompressionLevel,
    pub dictionary: Option<Vec<u8>>,
    pub window_size: Option<u32>,
    pub parallel_processing: bool,
}

Compression configuration that encapsulates all parameters for compression operations

This configuration struct provides comprehensive control over compression behavior, allowing fine-tuning of compression parameters for optimal performance in different scenarios. The configuration is immutable and thread-safe.

Configuration Parameters

• Algorithm: The compression algorithm to use
• Level: Compression level balancing speed vs. ratio
• Dictionary: Optional pre-trained dictionary for better compression
• Window Size: Sliding window size for compression algorithms
• Parallel Processing: Enable multi-threaded compression when supported

Examples

Performance Considerations

• Dictionary: Pre-trained dictionaries can significantly improve compression ratios for similar data patterns but require additional memory
• Window Size: Larger windows generally improve compression but use more memory
• Parallel Processing: Can improve throughput on multi-core systems but may increase memory usage and complexity

Fields

algorithm: CompressionAlgorithm

The compression algorithm to use for processing

level: CompressionLevel

Compression level balancing speed vs. compression ratio

dictionary: Option<Vec<u8>>

Optional pre-trained dictionary for improved compression of similar data

window_size: Option<u32>

Optional sliding window size for compression algorithms (algorithm-specific)

parallel_processing: bool

Enable parallel processing for supported algorithms

Implementations

impl CompressionConfig

pub fn new(algorithm: CompressionAlgorithm) -> Self

Creates a new compression configuration

pub fn with_level(self, level: CompressionLevel) -> Self

Sets compression level

pub fn with_dictionary(self, dictionary: Vec<u8>) -> Self

Sets dictionary

pub fn with_window_size(self, size: u32) -> Self

Sets window size

pub fn with_parallel_processing(self, enabled: bool) -> Self

Sets parallel processing

pub fn for_speed(algorithm: CompressionAlgorithm) -> Self

Creates a speed-optimized configuration

pub fn for_ratio(algorithm: CompressionAlgorithm) -> Self

Creates a ratio-optimized configuration

Trait Implementations

impl Clone for CompressionConfig

fn clone(&self) -> CompressionConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompressionConfig

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

Formats the value using the given formatter.

impl Default for CompressionConfig

fn default() -> Self

Returns the “default value” for a type.

impl FromParameters for CompressionConfig

Implementation of FromParameters for type-safe config extraction.

This implementation converts StageConfiguration.parameters HashMap into a typed CompressionConfig object.

Expected Parameters

• algorithm (required): Compression algorithm name

  • Valid values: “brotli”, “gzip”, “zstd”, “lz4”
  • Example: "algorithm" => "brotli"

• level (optional): Compression level (1-19 depending on algorithm)

  • Default: 6 (balanced)
  • Example: "level" => "9"

• parallel_processing (optional): Enable parallel compression

  • Valid values: “true”, “false”
  • Default: false
  • Example: "parallel_processing" => "true"

Usage Example

use adaptive_pipeline_domain::services::{CompressionConfig, FromParameters};
use std::collections::HashMap;

let mut params = HashMap::new();
params.insert("algorithm".to_string(), "brotli".to_string());
params.insert("level".to_string(), "9".to_string());

let config = CompressionConfig::from_parameters(&params).unwrap();

fn from_parameters( params: &HashMap<String, String>, ) -> Result<Self, PipelineError>

Converts HashMap parameters to typed configuration.