[][src]Crate snap

This crate provides an implementation of the Snappy compression format, as well as the framing format. The goal of Snappy is to provide reasonable compression at high speed. On a modern CPU, Snappy can compress data at about 300 MB/sec or more and can decompress data at about 800 MB/sec or more.

Install

To use this crate with Cargo, simply add it as a dependency to your Cargo.toml:

This example is not tested
[dependencies]
snap = "0.2"

and add extern crate snap; to your crate root.

Overview

This crate provides two ways to use Snappy. The first way is through the Reader and Writer types, which implement the std::io::Read and std::io::Write traits with the Snappy frame format. Unless you have a specific reason to the contrary, you should only need to use these types. Specifically, the Snappy frame format permits streaming compression or decompression.

The second way is through the Decoder and Encoder types. These types provide lower level control to the raw Snappy format, and don't support a streaming interface directly. You should only use these types if you know you specifically need the Snappy raw format.

Finally, the Error type in this crate provides an exhaustive list of error conditions that are probably useless in most circumstances. Therefore, From<snap::Error> for io::Error is implemented in this crate, which will let you automatically convert a Snappy error to an std::io::Error (when using try!) with an appropriate error message to display to an end user.

Example: compress data on stdin

This program reads data from stdin, compresses it and emits it to stdout. This example can be found in examples/compress.rs:

This example is not tested
extern crate snap;

use std::io;

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();

    let mut rdr = stdin.lock();
    // Wrap the stdout writer in a Snappy writer.
    let mut wtr = snap::Writer::new(stdout.lock());
    io::copy(&mut rdr, &mut wtr).expect("I/O operation failed");
}

Example: decompress data on stdin

This program reads data from stdin, decompresses it and emits it to stdout. This example can be found in examples/decompress.rs:

This example is not tested
extern crate snap;

use std::io;

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();

    // Wrap the stdin reader in a Snappy reader.
    let mut rdr = snap::Reader::new(stdin.lock());
    let mut wtr = stdout.lock();
    io::copy(&mut rdr, &mut wtr).expect("I/O operation failed");
}

Structs

Decoder

Decoder is a raw decoder for decompressing bytes in the Snappy format.

Encoder

Encoder is a raw encoder for compressing bytes in the Snappy format.

IntoInnerError

IntoInnerError occurs when consuming a Writer fails.

Reader

A reader for decompressing a Snappy stream.

Writer

A writer for compressing a Snappy stream.

Enums

Error

Error describes all the possible errors that may occur during Snappy compression or decompression.

Functions

decompress_len

Returns the decompressed size (in bytes) of the compressed bytes given.

max_compress_len

Returns the maximum compressed size given the uncompressed size.

Type Definitions

Result

A convenient type alias for Result<T, snap::Error>.