Xpress_rs

A rust implementation of the xpress compression algorithm. Defined in the MS-XCA

Work in progress, only the LZ77 algorithm is implemented.

LZ77 :

• [x] Comment
• [x] Doc
• [x] Rewrite tests
• [x] Add benchmark
• [x] logging
• [ ] optimization :
  • [x] use other hashmap implementation
  • [x] Make a custom hashmap implementation with hash function
  • [ ] Try chained hashmap, multiple hashmap and trees
  • [x] Try to avoid hashmap reallocation (use a fixed size hashmap)
  • [x] Global code optimization

Logging

The logging feature use a lot of macro, so the execution time is not optimal. I recommend to disable the logging feature in release mode, but can be useful for testing or debugging. - Use "cargo test --features logging" to enable logging in test - Future release will have more logging feature (ex: only compile log macro you need)

Error handling

The error handling is not optimal, and can be improved.

In the compression algorithm, the output buffer is a fixed size buffer, is defined to be 2 times the size of the input buffer. Im not sure if this can result in a buffer overflow. I didn't check size in the algorithm, because it will slow down the algorithm and i didn't want to use vector for avoiding reallocation. --> TODO: find a better way to implement this.

Example

```rust use xpress_rs::lz77::{LZ77Compressor,LZ77Decompressor}; use std::error::Error;

[cfg(feature = "logging")]

{ use envlogger::Env; use log::{info, LevelFilter}; envlogger::Builder::new().filter(None, LevelFilter::Info).init(); }

// data to compress let datatocompress: Vec = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.".to_vec();

// init the Compressor let compressor = LZ77Compressor::new(datatocompress);

// compress the data let result: Result,Box> = compressor.compress();

// check if the compression is successful match result { Ok(compresseddata) => { // init the Decompressor let decompressor = LZ77Decompressor::new(compresseddata);

    // decompress the data
    let result: Result<Vec<u8>,Box<dyn Error>> = decompressor.decompress();

    // check if the decompression is successful
    match result {
        Ok(decompressed_data) => {
            println!("Decompressed data: {:?}",decompressed_data);
        },
        Err(e) => {
            println!("Error: {}",e);
        }
    }
},
Err(e) => {
    println!("Error: {}",e);
}

}

```