mozilla-central/third_party/rust/flate2/src
Name Description Size
bufreader.rs 2814
crc.rs Simple CRC bindings backed by miniz.c 4247
deflate
ffi
gz
lib.rs A DEFLATE-based stream compression/decompression library This library provides support for compression and decompression of DEFLATE-based streams: * the DEFLATE format itself * the zlib format * gzip These three formats are all closely related and largely only differ in their headers/footers. This crate has three types in each submodule for dealing with these three formats. # Implementation In addition to supporting three formats, this crate supports several different backends, controlled through this crate's features: * `default`, or `rust_backend` - this implementation uses the `miniz_oxide` crate which is a port of `miniz.c` (below) to Rust. This feature does not require a C compiler and only requires Rust code. * `zlib` - this feature will enable linking against the `libz` library, typically found on most Linux systems by default. If the library isn't found to already be on the system it will be compiled from source (this is a C library). There's various tradeoffs associated with each implementation, but in general you probably won't have to tweak the defaults. The default choice is selected to avoid the need for a C compiler at build time. `zlib-ng-compat` is useful if you're using zlib for compatibility but want performance via zlib-ng's zlib-compat mode. `zlib` is useful if something else in your dependencies links the original zlib so you cannot use zlib-ng-compat. The compression ratios and performance of each of these feature should be roughly comparable, but you'll likely want to run your own tests if you're curious about the performance. # Organization This crate consists mainly of three modules, [`read`], [`write`], and [`bufread`]. Each module contains a number of types used to encode and decode various streams of data. All types in the [`write`] module work on instances of [`Write`][write], whereas all types in the [`read`] module work on instances of [`Read`][read] and [`bufread`] works with [`BufRead`][bufread]. If you are decoding directly from a `&[u8]`, use the [`bufread`] types. ``` use flate2::write::GzEncoder; use flate2::Compression; use std::io; use std::io::prelude::*; # fn main() { let _ = run(); } # fn run() -> io::Result<()> { let mut encoder = GzEncoder::new(Vec::new(), Compression::default()); encoder.write_all(b"Example")?; # Ok(()) # } ``` Other various types are provided at the top-level of the crate for management and dealing with encoders/decoders. Also note that types which operate over a specific trait often implement the mirroring trait as well. For example a `flate2::read::DeflateDecoder<T>` *also* implements the `Write` trait if `T: Write`. That is, the "dual trait" is forwarded directly to the underlying object if available. [`read`]: read/index.html [`bufread`]: bufread/index.html [`write`]: write/index.html [read]: https://doc.rust-lang.org/std/io/trait.Read.html [write]: https://doc.rust-lang.org/std/io/trait.Write.html [bufread]: https://doc.rust-lang.org/std/io/trait.BufRead.html 7518
mem.rs 27977
zio.rs 7953
zlib