lz4_flex 0.14.0

//! Pure Rust, high performance implementation of LZ4 compression.
//!
//! A detailed explanation of the algorithm can be found [here](http://ticki.github.io/blog/how-lz4-works/).
//!
//! # Overview
//!
//! This crate provides two ways to use lz4. The first way is through the
//! [`frame::FrameDecoder`](frame/struct.FrameDecoder.html)
//! and
//! [`frame::FrameEncoder`](frame/struct.FrameEncoder.html)
//! types, which implement the `std::io::Read` and `std::io::Write` traits with the
//! lz4 frame format. Unless you have a specific reason to the contrary, you
//! should only use the lz4 frame format. Specifically, the lz4 frame format
//! permits streaming compression or decompression.
//!
//! The second way is through the
//! [`decompress_size_prepended`](block/fn.decompress_size_prepended.html)
//! and
//! [`compress_prepend_size`](block/fn.compress_prepend_size.html)
//! functions. These functions provide access to the lz4 block format, and
//! don't support a streaming interface directly. You should only use these types
//! if you know you specifically need the lz4 block format.
//!
//! # Example: compress data on `stdin` with frame format
//! This program reads data from `stdin`, compresses it and emits it to `stdout`.
//! This example can be found in `examples/compress.rs`:
//! ```no_run
//! use std::io;
//! let stdin = io::stdin();
//! let stdout = io::stdout();
//! let mut rdr = stdin.lock();
//! // Wrap the stdout writer in a LZ4 Frame writer.
//! let mut wtr = lz4_flex::frame::FrameEncoder::new(stdout.lock());
//! io::copy(&mut rdr, &mut wtr).expect("I/O operation failed");
//! wtr.finish().unwrap();
//! ```
//! # Example: decompress data on `stdin` with frame format
//! This program reads data from `stdin`, decompresses it and emits it to `stdout`.
//! This example can be found in `examples/decompress.rs`:
//! ```no_run
//! use std::io;
//! let stdin = io::stdin();
//! let stdout = io::stdout();
//! // Wrap the stdin reader in a LZ4 FrameDecoder.
//! let mut rdr = lz4_flex::frame::FrameDecoder::new(stdin.lock());
//! let mut wtr = stdout.lock();
//! io::copy(&mut rdr, &mut wtr).expect("I/O operation failed");
//! ```
//!
//! # Example: block format roundtrip
//! ```
//! use lz4_flex::block::{compress_prepend_size, decompress_size_prepended};
//! let input: &[u8] = b"Hello people, what's up?";
//! let compressed = compress_prepend_size(input);
//! let uncompressed = decompress_size_prepended(&compressed).unwrap();
//! assert_eq!(input, uncompressed);
//! ```
//!
//! ## Feature Flags
//!
//! - `safe-encode` uses only safe rust for encode. _enabled by default_
//! - `safe-decode` uses only safe rust for encode. _enabled by default_
//! - `frame` support for LZ4 frame format. _implies `std`, enabled by default_
//! - `std` enables dependency on the standard library. _implies `alloc`, enabled by default_
//! - `alloc` enables APIs that allocate, e.g. [`compress`](block/fn.compress.html) returning a
//!   `Vec`. _enabled by default_
//!
//! For maximum performance use `no-default-features`.
//!
//! For no_std support only the [`block format`](block/index.html) is supported.
//!
//! Without the `alloc` feature only the `_into` variants are available, e.g.
//! [`compress_into`](block/fn.compress_into.html). Compression then places its hash table
//! (8-16KB) on the stack. Alternatively
//! [`compress_into_with_table`](block/fn.compress_into_with_table.html) can be used with a
//! statically allocated [`CompressTable`](block/enum.CompressTable.html).
//!
//!
#![deny(warnings)]
#![deny(missing_docs)]
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![cfg_attr(feature = "nightly", feature(optimize_attribute))]

#[cfg(feature = "alloc")]
#[cfg_attr(test, macro_use)]
extern crate alloc;

#[cfg(test)]
#[macro_use]
extern crate more_asserts;

pub mod block;
#[cfg(feature = "frame")]
#[cfg_attr(docsrs, doc(cfg(feature = "frame")))]
pub mod frame;

#[allow(dead_code)]
mod fastcpy;

#[cfg(not(all(feature = "safe-encode", feature = "safe-decode")))]
#[allow(dead_code)]
mod fastcpy_unsafe;

#[deprecated(
    since = "0.11.0",
    note = "This re-export is deprecated as it can be confused with the frame API and is not suitable for very large data, use block:: instead"
)]
pub use block::compress_into;
#[deprecated(
    since = "0.11.0",
    note = "This re-export is deprecated as it can be confused with the frame API and is not suitable for very large data, use block:: instead"
)]
pub use block::decompress_into;
#[cfg(feature = "alloc")]
#[deprecated(
    since = "0.11.0",
    note = "This re-export is deprecated as it can be confused with the frame API and is not suitable for very large data, use block:: instead"
)]
pub use block::{compress, compress_prepend_size};
#[cfg(feature = "alloc")]
#[deprecated(
    since = "0.11.0",
    note = "This re-export is deprecated as it can be confused with the frame API and is not suitable for very large data, use block:: instead"
)]
pub use block::{decompress, decompress_size_prepended};

#[cfg_attr(
    all(feature = "safe-encode", feature = "safe-decode"),
    forbid(unsafe_code)
)]
pub(crate) mod sink;