snappy

README

snappy

The Snappy compression format in the Go programming language.

This is a drop-in replacement for github.com/golang/snappy.

It provides a full, compatible replacement of the Snappy package by simply changing imports.

See Snappy Compatibility in the S2 documentation.

"Better" compression mode is used. For buffered streams concurrent compression is used.

For more options use the s2 package.

usage

Replace imports github.com/golang/snappy with github.com/klauspost/compress/snappy.

Documentation

Overview

Package snappy implements the Snappy compression format. It aims for very high speeds and reasonable compression.

There are actually two Snappy formats: block and stream. They are related, but different: trying to decompress block-compressed data as a Snappy stream will fail, and vice versa. The block format is the Decode and Encode functions and the stream format is the Reader and Writer types.

The block format, the more common case, is used when the complete size (the number of bytes) of the original data is known upfront, at the time compression starts. The stream format, also known as the framing format, is for when that isn't always true.

The canonical, C++ implementation is at https://github.com/google/snappy and it only implements the block format.

Index

• Variables
• func Decode(dst, src []byte) ([]byte, error)
• func DecodedLen(src []byte) (int, error)
• func Encode(dst, src []byte) []byte
• func MaxEncodedLen(srcLen int) int
• type Reader
  • func NewReader(r io.Reader) *Reader
• type Writer
  • func NewBufferedWriter(w io.Writer) *Writer
  • func NewWriter(w io.Writer) *Writer

Variables

var (
	// ErrCorrupt reports that the input is invalid.
	ErrCorrupt = s2.ErrCorrupt
	// ErrTooLarge reports that the uncompressed length is too large.
	ErrTooLarge = s2.ErrTooLarge
	// ErrUnsupported reports that the input isn't supported.
	ErrUnsupported = s2.ErrUnsupported
)

Functions

func Decode

func Decode(dst, src []byte) ([]byte, error)

Decode returns the decoded form of src. The returned slice may be a sub- slice of dst if dst was large enough to hold the entire decoded block. Otherwise, a newly allocated slice will be returned.

The dst and src must not overlap. It is valid to pass a nil dst.

Decode handles the Snappy block format, not the Snappy stream format.

func DecodedLen

func DecodedLen(src []byte) (int, error)

DecodedLen returns the length of the decoded block.

func Encode

func Encode(dst, src []byte) []byte

Encode returns the encoded form of src. The returned slice may be a sub- slice of dst if dst was large enough to hold the entire encoded block. Otherwise, a newly allocated slice will be returned.

The dst and src must not overlap. It is valid to pass a nil dst.

Encode handles the Snappy block format, not the Snappy stream format.

func MaxEncodedLen

func MaxEncodedLen(srcLen int) int

MaxEncodedLen returns the maximum length of a snappy block, given its uncompressed length.

It will return a negative value if srcLen is too large to encode.

Types

type Reader

type Reader = s2.Reader

Reader is an io.Reader that can read Snappy-compressed bytes.

Reader handles the Snappy stream format, not the Snappy block format.

func NewReader

func NewReader(r io.Reader) *Reader

NewReader returns a new Reader that decompresses from r, using the framing format described at https://github.com/google/snappy/blob/master/framing_format.txt

type Writer

type Writer = s2.Writer

Writer is an io.Writer that can write Snappy-compressed bytes.

Writer handles the Snappy stream format, not the Snappy block format.

func NewBufferedWriter

func NewBufferedWriter(w io.Writer) *Writer

NewBufferedWriter returns a new Writer that compresses to w, using the framing format described at https://github.com/google/snappy/blob/master/framing_format.txt

The Writer returned buffers writes. Users must call Close to guarantee all data has been forwarded to the underlying io.Writer. They may also call Flush zero or more times before calling Close.

func NewWriter

func NewWriter(w io.Writer) *Writer

NewWriter returns a new Writer that compresses to w.

The Writer returned does not buffer writes. There is no need to Flush or Close such a Writer.

Deprecated: the Writer returned is not suitable for many small writes, only for few large writes. Use NewBufferedWriter instead, which is efficient regardless of the frequency and shape of the writes, and remember to Close that Writer when done.