rustmax 0.0.11

A collection of useful crates.
Documentation 
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

Deflate, gzip, and zlib compression.

- Crate [`::flate2`].
- [docs.rs](https://docs.rs/flate2)
- [crates.io](https://crates.io/crates/flate2)
- [GitHub](https://github.com/rust-lang/flate2-rs)

---

`flate2` provides compression and decompression for the DEFLATE algorithm,
along with support for zlib and gzip formats.
The crate offers both streaming and one-shot APIs for compression,
making it suitable for a wide range of use cases.

By default, `flate2` uses the `miniz_oxide` backend,
a pure Rust implementation that requires no C compiler
and uses only safe Rust code.
For maximum performance, the `zlib-rs` backend is available,
which typically outperforms C implementations.

The crate provides separate types for reading and writing compressed data:
[`Encoder`] and [`Decoder`] for raw DEFLATE,
[`GzEncoder`] and [`GzDecoder`] for gzip format,
and [`ZlibEncoder`] and [`ZlibDecoder`] for zlib format.

## Examples

Compressing data with gzip:

```
use flate2::Compression;
use flate2::write::GzEncoder;
use std::io::Write;

let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
encoder.write_all(b"Hello, world!").unwrap();
let compressed = encoder.finish().unwrap();
```

Decompressing gzip data:

```
use flate2::read::GzDecoder;
use std::io::Read;

fn decompress_example(compressed: &[u8]) {
    let mut decoder = GzDecoder::new(compressed);
    let mut decompressed = String::new();
    decoder.read_to_string(&mut decompressed).unwrap();
}
```

Compression with the deflate algorithm:

```
use flate2::Compression;
use flate2::write::DeflateEncoder;
use std::io::Write;

let original = b"The quick brown fox jumps over the lazy dog";
let mut encoder = DeflateEncoder::new(Vec::new(), Compression::best());
encoder.write_all(original).unwrap();
let compressed = encoder.finish().unwrap();
```

[`Encoder`]: crate::flate2::write::DeflateEncoder
[`Decoder`]: crate::flate2::read::DeflateDecoder
[`GzEncoder`]: crate::flate2::write::GzEncoder
[`GzDecoder`]: crate::flate2::read::GzDecoder
[`ZlibEncoder`]: crate::flate2::write::ZlibEncoder
[`ZlibDecoder`]: crate::flate2::read::ZlibDecoder