oxigdal-compress 0.1.5

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Compression codecs
//!
//! This module provides various compression codecs optimized for different
//! types of geospatial data.

pub mod blosc;
pub mod brotli;
pub mod deflate;
pub mod delta;
pub mod dictionary;
pub mod lz4;
pub mod pipeline;
pub mod rle;
pub mod shuffle;
pub mod snappy;
pub mod zstd;

pub use self::{
    blosc::{BloscBackend, BloscCodec, BloscFrame, Codec, ShuffleKind},
    brotli::{BrotliCodec, BrotliConfig, BrotliQuality},
    deflate::{DeflateCodec, DeflateConfig, DeflateFormat, DeflateLevel},
    delta::{DeltaCodec, DeltaConfig, DeltaDataType},
    dictionary::{DictionaryCodec, DictionaryConfig},
    lz4::{Lz4Codec, Lz4Config, Lz4Level},
    pipeline::{CodecPipeline, PipelineStage},
    rle::{RleCodec, RleConfig},
    shuffle::{byte_shuffle, byte_shuffle_in_place, byte_unshuffle, byte_unshuffle_in_place},
    snappy::{SnappyCodec, SnappyConfig},
    zstd::{ZstdCodec, ZstdConfig, ZstdLevel},
};

/// Compression codec type
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub enum CodecType {
    /// LZ4 compression
    Lz4,
    /// Zstandard compression
    Zstd,
    /// Brotli compression
    Brotli,
    /// Snappy compression
    Snappy,
    /// DEFLATE compression
    Deflate,
    /// Delta encoding
    Delta,
    /// Run-length encoding
    Rle,
    /// Dictionary encoding
    Dictionary,
}

impl CodecType {
    /// Get codec name
    pub fn name(&self) -> &'static str {
        match self {
            CodecType::Lz4 => "lz4",
            CodecType::Zstd => "zstd",
            CodecType::Brotli => "brotli",
            CodecType::Snappy => "snappy",
            CodecType::Deflate => "deflate",
            CodecType::Delta => "delta",
            CodecType::Rle => "rle",
            CodecType::Dictionary => "dictionary",
        }
    }

    /// Parse codec type from string
    pub fn from_name(name: &str) -> Option<Self> {
        match name.to_lowercase().as_str() {
            "lz4" => Some(CodecType::Lz4),
            "zstd" | "zstandard" => Some(CodecType::Zstd),
            "brotli" | "br" => Some(CodecType::Brotli),
            "snappy" | "snap" => Some(CodecType::Snappy),
            "deflate" | "gzip" | "zlib" => Some(CodecType::Deflate),
            "delta" => Some(CodecType::Delta),
            "rle" => Some(CodecType::Rle),
            "dictionary" | "dict" => Some(CodecType::Dictionary),
            _ => None,
        }
    }

    /// Check if codec is lossless
    pub fn is_lossless(&self) -> bool {
        match self {
            CodecType::Lz4
            | CodecType::Zstd
            | CodecType::Brotli
            | CodecType::Snappy
            | CodecType::Deflate
            | CodecType::Delta
            | CodecType::Rle
            | CodecType::Dictionary => true,
        }
    }

    /// Get typical compression speed (1-10, higher = faster)
    pub fn speed_score(&self) -> u8 {
        match self {
            CodecType::Snappy => 10,
            CodecType::Lz4 => 9,
            CodecType::Delta => 8,
            CodecType::Rle => 8,
            CodecType::Dictionary => 7,
            CodecType::Deflate => 5,
            CodecType::Zstd => 6,
            CodecType::Brotli => 3,
        }
    }

    /// Get typical compression ratio score (1-10, higher = better compression)
    pub fn ratio_score(&self) -> u8 {
        match self {
            CodecType::Brotli => 9,
            CodecType::Zstd => 8,
            CodecType::Deflate => 7,
            CodecType::Lz4 => 5,
            CodecType::Dictionary => 7,
            CodecType::Delta => 6,
            CodecType::Rle => 8,
            CodecType::Snappy => 4,
        }
    }
}

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

    #[test]
    fn test_codec_type_from_name() {
        assert_eq!(CodecType::from_name("lz4"), Some(CodecType::Lz4));
        assert_eq!(CodecType::from_name("zstd"), Some(CodecType::Zstd));
        assert_eq!(CodecType::from_name("zstandard"), Some(CodecType::Zstd));
        assert_eq!(CodecType::from_name("brotli"), Some(CodecType::Brotli));
        assert_eq!(CodecType::from_name("snappy"), Some(CodecType::Snappy));
        assert_eq!(CodecType::from_name("deflate"), Some(CodecType::Deflate));
        assert_eq!(CodecType::from_name("invalid"), None);
    }

    #[test]
    fn test_codec_type_is_lossless() {
        assert!(CodecType::Lz4.is_lossless());
        assert!(CodecType::Zstd.is_lossless());
        assert!(CodecType::Delta.is_lossless());
    }

    #[test]
    fn test_codec_scores() {
        assert!(CodecType::Snappy.speed_score() > CodecType::Brotli.speed_score());
        assert!(CodecType::Brotli.ratio_score() > CodecType::Snappy.ratio_score());
    }
}