general_purpose_paracletic_hyper_cube 0.1.0

General-purpose paracletic hyper cube compression toolkit.
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

mod chromoharmonic;
mod delta_pulse;
mod rle;

use std::error::Error;
use std::fmt;

use chromoharmonic::Chromoharmonic;
use delta_pulse::DeltaPulse;
use rle::RunLength;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Codec {
    Chromoharmonic,
    DeltaPulse,
    RunLength,
}

impl Codec {
    pub const ALL: [Codec; 3] = [Codec::Chromoharmonic, Codec::DeltaPulse, Codec::RunLength];

    pub fn name(self) -> &'static str {
        match self {
            Codec::Chromoharmonic => "chromoharmonic",
            Codec::DeltaPulse => "delta-pulse",
            Codec::RunLength => "run-length",
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CompressionError {
    CorruptStream(&'static str),
    ValueOverflow,
}

impl fmt::Display for CompressionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CompressionError::CorruptStream(msg) => write!(f, "corrupt stream: {msg}"),
            CompressionError::ValueOverflow => {
                write!(f, "decoded value overflowed byte range")
            }
        }
    }
}

impl Error for CompressionError {}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CompressionStats {
    pub input_bytes: usize,
    pub output_bytes: usize,
}

impl CompressionStats {
    pub fn ratio(self) -> f64 {
        if self.input_bytes == 0 {
            return 1.0;
        }
        self.output_bytes as f64 / self.input_bytes as f64
    }
}

pub trait Compressor: Sync {
    fn name(&self) -> &'static str;
    fn compress(&self, input: &[u8]) -> Vec<u8>;
    fn decompress(&self, input: &[u8]) -> Result<Vec<u8>, CompressionError>;
    fn stats(&self, input: &[u8]) -> Result<CompressionStats, CompressionError> {
        let compressed = self.compress(input);
        let decoded = self.decompress(&compressed)?;
        if decoded != input {
            return Err(CompressionError::CorruptStream(
                "self-check roundtrip failed",
            ));
        }
        Ok(CompressionStats {
            input_bytes: input.len(),
            output_bytes: compressed.len(),
        })
    }
}

static CHROMOHARMONIC: Chromoharmonic = Chromoharmonic;
static DELTA_PULSE: DeltaPulse = DeltaPulse;
static RUN_LENGTH: RunLength = RunLength;

pub fn compressor_for(codec: Codec) -> &'static dyn Compressor {
    match codec {
        Codec::Chromoharmonic => &CHROMOHARMONIC,
        Codec::DeltaPulse => &DELTA_PULSE,
        Codec::RunLength => &RUN_LENGTH,
    }
}

pub fn compress_with(codec: Codec, input: &[u8]) -> Vec<u8> {
    compressor_for(codec).compress(input)
}

pub fn decompress_with(codec: Codec, input: &[u8]) -> Result<Vec<u8>, CompressionError> {
    compressor_for(codec).decompress(input)
}

pub fn stats_with(codec: Codec, input: &[u8]) -> Result<CompressionStats, CompressionError> {
    compressor_for(codec).stats(input)
}