oxigdal-compress 0.1.7

Advanced compression codecs and auto-selection for geospatial data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! OxiGDAL Compression Library
//!
//! Advanced compression codecs and auto-selection for geospatial data.
//!
//! # Features
//!
//! - **Standard Codecs**: LZ4, Zstandard, Brotli, Snappy, DEFLATE
//! - **Geospatial Codecs**: Delta encoding, RLE, Dictionary compression
//! - **Floating-Point**: ZFP and SZ-style compression with error bounds
//! - **Auto-Selection**: Intelligent codec selection based on data characteristics
//! - **Parallel Processing**: Multi-threaded compression/decompression
//! - **Benchmarking**: Built-in performance measurement
//!
//! # Examples
//!
//! ```rust
//! use oxigdal_compress::{
//!     codecs::{Lz4Codec, ZstdCodec},
//!     auto_select::{AutoSelector, CompressionGoal, DataType, DataCharacteristics},
//! };
//!
//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
//! // Basic compression with LZ4
//! let codec = Lz4Codec::new();
//! let data = b"Hello, world!".repeat(1000);
//! let compressed = codec.compress(&data)?;
//! let decompressed = codec.decompress(&compressed, Some(data.len()))?;
//! assert_eq!(decompressed, data);
//!
//! // Auto-selection
//! let selector = AutoSelector::new(CompressionGoal::Balanced);
//! let characteristics = DataCharacteristics {
//!     data_type: DataType::Categorical,
//!     size: 10000,
//!     entropy: 0.3,
//!     unique_count: Some(10),
//!     value_range: None,
//!     run_length_ratio: Some(50.0),
//! };
//! let recommendations = selector.recommend(&characteristics);
//! println!("Recommended codec: {:?}", recommendations[0].codec);
//! # Ok(())
//! # }
//! ```

#![deny(missing_docs)]
#![warn(clippy::unwrap_used, clippy::panic)]

pub mod auto_select;
pub mod benchmark;
pub mod codecs;
pub mod error;
pub mod floating_point;
pub mod metadata;
pub mod parallel;

pub use error::{CompressionError, Result};

/// Prelude module for common imports
pub mod prelude {
    pub use crate::{
        auto_select::{AutoSelector, CompressionGoal, DataCharacteristics, DataType},
        codecs::{
            BloscCodec, BrotliCodec, CodecType, DeflateCodec, DeltaCodec, DictionaryCodec,
            Lz4Codec, RleCodec, SnappyCodec, ZstdCodec,
        },
        error::{CompressionError, Result},
        metadata::CompressionMetadata,
        parallel::ParallelCompressor,
    };
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_lz4_roundtrip() {
        use codecs::Lz4Codec;

        let codec = Lz4Codec::new();
        let data = b"Test data".repeat(100);

        let compressed = codec.compress(&data).expect("Compression failed");
        let decompressed = codec
            .decompress(&compressed, Some(data.len()))
            .expect("Decompression failed");

        assert_eq!(decompressed, data);
    }

    #[test]
    fn test_zstd_roundtrip() {
        use codecs::ZstdCodec;

        let codec = ZstdCodec::new();
        let data = b"Test data".repeat(100);

        let compressed = codec.compress(&data).expect("Compression failed");
        let decompressed = codec
            .decompress(&compressed, Some(data.len() * 2))
            .expect("Decompression failed");

        assert_eq!(decompressed, data);
    }
}