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
/*! This is a Snappy compression algorithm library written in Rust. It is ported from [Go implementation](https://github.com/golang/snappy) with similar interface. Provide basic interfaces: - `max_encode_len(src_len)`: Get the max length of encoded data. - `encode(dst, src)`: Encode `src` to `dst`. - `decode_len(src)`: Get the exact length of decoded data. - `decode_len(dst, src)`: Decode `src` to `dst`. # Examples: Compress: ```rust use xsnappy::{max_encode_len, encode}; let src = "Jingle bell, jingle bell, jingle bell rock \ Jingle bells swing and jingle bells ring".as_bytes(); let mut dst = vec![0; max_encode_len(src.len())]; let size = encode(&mut dst, src); dst.resize(size, 0); println!("{:?}", dst); ``` Decompress: ```rust use xsnappy::{decode_len, decode}; use std::str::from_utf8; let src = vec![83, 52, 74, 105, 110, 103, 108, 101, 32, 98, 101, 108, 108, 44, 32, 106, 90, 13, 0, 20, 32, 114, 111, 99, 107, 32, 29, 43, 40, 115, 32, 115, 119, 105, 110, 103, 32, 97, 110, 100, 46, 53, 0, 20, 115, 32, 114, 105, 110, 103]; let dec_len = match decode_len(&src) { Ok(len) => len, Err(err) => panic!("{}", err) }; let mut dst = vec![0; dec_len]; match decode(&mut dst, &src) { Ok(len) => {}, Err(err) => panic!("{}", err) } println!("{}", from_utf8(&dst).unwrap()); ``` */ mod binary; mod encode; mod decode; pub mod error; use error::SnappyError; /// Encode `src` to `dst`. The `dst` must be initialized with a certain length. /// Return the exact length of encoded data. /// # Examples: /// /// ```rust /// use xsnappy::{max_encode_len, encode}; /// /// let mut src = b"hello world! hello world!"; /// let mut dst = vec![0; max_encode_len(src.len())]; /// let len = encode(&mut dst, src); /// dst.resize(len, 0); // resize to exact length /// ``` /// # Panics: /// Panics if the length of `dst` is less then `max_encode_len(src.len())` pub fn encode(dst: &mut [u8], src: &[u8]) -> usize { encode::encode(dst, src) } /// Decode `src` to `dst`. The `dst` must be initialized with a certain length. /// Return the exact length of decoded data. /// # Examples: /// /// ```rust /// use xsnappy::{decode_len, decode}; /// /// let dec_len = decode_len(src).unwrap(); /// let mut dst = vec![0; dec_len]; /// decode(&mut dst, src); /// ``` pub fn decode(dst: &mut [u8], src: &[u8]) -> Result<usize, SnappyError> { decode::decode(dst, src) } /// Return the max length of encoded data pub fn max_encode_len(src_len: usize) -> usize { encode::max_encode_len(src_len) } /// Return the exact length of decoded data. pub fn decode_len(src: &[u8]) -> Result<usize, SnappyError> { decode::decode_len(src) }