and for a bigger lookbehind length of 333
THE fastest way to implement any kind of decoding for Run Length Encoded data in Rust.
Writing a fast decoder that is also safe can be quite challenging, so this crate is here to save you the hassle of maintaining and testing your own implementation.
Of course, you need to depend on this crate:
toml
rle-decode-fast = "1.0.0-alpha"
There is only a single function to use, rle_decode<T>(&mut Vec<T>, lookbehind_size: usize, fill_length: usize).
It takes :
* a vector to modify,
* the number of items to copy from said vector (basically vector[(vector.len() - lookbehind)..])
* the number of items to append.
Afterwards the vector will contain an extra fill_length items.
```rust
use rledecodefast::rle_decode;
let mut decodebuffer = vec![0, 0, 1, 1, 0, 2, 3]; let lookbehindlength = 4; let outputlength = 10; rledecode(&mut decodebuffer, lookbehindlength, outputlength); asserteq!(decode_buffer, [0, 0, 1, 1, 0, 2, 3, 1, 0, 2, 3, 1, 0, 2, 3, 1, 0]); ```
There are cases where the decode functions panics * The lookbehind length is 0 * The lookbehind length is bigger than the Vec's length * The output length + Vec's length would overflow
The idea for this crate first originated from this pre-RFC. It brought to attention a weak-point in the standard library, which lead some crates writing their own unsafe by-pass.
During the exploration happening in the pre-RFC, some experimentation was conducted. For examples see here and here.
There is a benchmark comparing a naive (repeated push) implementation, a vulnerable implementation that might lead to uninitialized memory and this crate.
The results for a very small lookbehind length of 2
and for a bigger lookbehind length of 333
Licensed under either of
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.