qualia_core_db/specialized_libs/statistical_computing/
compression.rs1use super::*;
2
3pub struct DataCompressionEngine {
5 compression_algorithms: Vec<CompressionAlgorithm>,
6 compression_statistics: CompressionStatistics,
7}
8
9#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11pub enum CompressionAlgorithm {
12 Gzip,
13 LZ4,
14 ZSTD,
15 Snappy,
16 Custom(String),
17}
18
19#[derive(Debug, Clone)]
27pub struct CompressionStatistics {
28 pub original_size: u64,
30 pub compressed_size: u64,
32 pub compression_ratio: f64,
34 pub compression_time: u64,
36 pub decompression_time: u64,
38 pub compression_count: u64,
40 pub decompression_count: u64,
42}
43
44impl DataCompressionEngine {
45 pub fn new() -> Self {
47 Self {
48 compression_algorithms: vec![CompressionAlgorithm::LZ4, CompressionAlgorithm::ZSTD],
49 compression_statistics: CompressionStatistics::new(),
50 }
51 }
52
53 pub fn initialize(&mut self) -> Result<(), StatisticalError> {
55 Ok(())
56 }
57
58 pub fn compress(&mut self, data: &[u8]) -> Result<Vec<u8>, StatisticalError> {
61 let start = Instant::now();
62 let compressed = rle_compress(data);
63 let elapsed = start.elapsed().as_nanos() as u64;
64 self.compression_statistics.record_compression(
65 data.len() as u64,
66 compressed.len() as u64,
67 elapsed,
68 );
69 Ok(compressed)
70 }
71
72 pub fn decompress(&mut self, data: &[u8]) -> Result<Vec<u8>, StatisticalError> {
75 let start = Instant::now();
76 let decompressed = rle_decompress(data)?;
77 let elapsed = start.elapsed().as_nanos() as u64;
78 self.compression_statistics.record_decompression(elapsed);
79 Ok(decompressed)
80 }
81
82 pub fn get_statistics(&self) -> &CompressionStatistics {
84 &self.compression_statistics
85 }
86
87 pub fn reset_statistics(&mut self) {
89 self.compression_statistics = CompressionStatistics::new();
90 }
91
92 pub fn compression_algorithms(&self) -> &[CompressionAlgorithm] {
94 &self.compression_algorithms
95 }
96
97 pub fn add_compression_algorithm(&mut self, algorithm: CompressionAlgorithm) {
99 if !self.compression_algorithms.contains(&algorithm) {
100 self.compression_algorithms.push(algorithm);
101 }
102 }
103
104 pub fn supports_algorithm(&self, algorithm: &CompressionAlgorithm) -> bool {
106 self.compression_algorithms.contains(algorithm)
107 }
108}
109
110impl CompressionStatistics {
111 pub fn new() -> Self {
113 Self {
114 original_size: 0,
115 compressed_size: 0,
116 compression_ratio: 0.0,
117 compression_time: 0,
118 decompression_time: 0,
119 compression_count: 0,
120 decompression_count: 0,
121 }
122 }
123
124 pub fn record_compression(&mut self, original: u64, compressed: u64, elapsed_ns: u64) {
126 self.original_size += original;
127 self.compressed_size += compressed;
128 self.compression_time += elapsed_ns;
129 self.compression_count += 1;
130 self.compression_ratio = if original == 0 {
131 0.0
132 } else {
133 compressed as f64 / original as f64
134 };
135 }
136
137 pub fn record_decompression(&mut self, elapsed_ns: u64) {
139 self.decompression_time += elapsed_ns;
140 self.decompression_count += 1;
141 }
142
143 pub fn compression_ratio(&self) -> f64 {
147 if self.original_size == 0 {
148 0.0
149 } else {
150 self.compressed_size as f64 / self.original_size as f64
151 }
152 }
153
154 pub fn summary(&self) -> String {
156 format!(
157 "CompressionStatistics: {} compress op(s), {} decompress op(s), \
158 original={} bytes, compressed={} bytes, overall ratio={:.4}, \
159 last-op ratio={:.4}, compress_time={} ns, decompress_time={} ns",
160 self.compression_count,
161 self.decompression_count,
162 self.original_size,
163 self.compressed_size,
164 self.compression_ratio(),
165 self.compression_ratio,
166 self.compression_time,
167 self.decompression_time,
168 )
169 }
170}
171
172fn rle_compress(data: &[u8]) -> Vec<u8> {
177 let mut out = Vec::with_capacity(data.len());
178 let mut i = 0;
179 while i < data.len() {
180 let byte = data[i];
181 let mut count: usize = 1;
182 while i + count < data.len() && data[i + count] == byte && count < 255 {
183 count += 1;
184 }
185 out.push(count as u8);
186 out.push(byte);
187 i += count;
188 }
189 out
190}
191
192fn rle_decompress(data: &[u8]) -> Result<Vec<u8>, StatisticalError> {
194 if data.len() % 2 != 0 {
195 return Err(StatisticalError::InvalidData(
196 "Corrupted RLE stream (odd length)".to_string(),
197 ));
198 }
199 let mut out = Vec::with_capacity(data.len());
200 let mut i = 0;
201 while i < data.len() {
202 let count = data[i] as usize;
203 let byte = data[i + 1];
204 out.resize(out.len() + count, byte);
205 i += 2;
206 }
207 Ok(out)
208}