Function huff_coding::comp::compress

pub fn compress<L: HuffLetter>(letters: &[L]) -> CompressData<L>

Compress the provided slice of letters (types implementing HuffLetter), using binary codes generated with a HuffTree struct, into a byte slice (returned with additional data in the form of CompressData).

The letters are counted into a Weights collection to create a HuffTree using the build_weights_map function, which can be optimized a lot for certain letter types. Because of this fact, it’s generally faster to use the compress_with_tree function, providing a HuffTree built with our own Weights collection (an example of such collection is implemented in the crate on u8 in the form of ByteWeights).

The returned CompressData can be decompressed into the original letter slice with the decompress function.

How it works

---

It just reads every letter’s code in the created HuffTree and inserts them into a Vec<u8>. The codes themselves are mostly not a multiple of 8 bits long, so some of them can be used as padding in the last byte. The padding information, as well as the tree used to compress the slice are included in the returned CompressData.

Example

---

use huff_coding::prelude::{
    compress,
    decompress
};
 
let bytes = b"abbccc";
let nums = &[-97, -98, -98, -99, -99, -99];
let chars = &['a', 'b', 'b', 'c', 'c', 'c'];
let strs = &["ay", "bee", "bee", "cee", "cee", "cee"];
 
let comp_bytes = compress(bytes);
let comp_nums = compress(nums);
let comp_chars = compress(chars);
let comp_strs = compress(strs);
 
assert_eq!(bytes.to_vec(), decompress(&comp_bytes));
assert_eq!(nums.to_vec(), decompress(&comp_nums));
assert_eq!(chars.to_vec(), decompress(&comp_chars));
assert_eq!(strs.to_vec(), decompress(&comp_strs));