flate

Documentation

Overview

Package flate implements the DEFLATE compressed data format, described in RFC 1951. The gzip and zlib packages implement access to DEFLATE-based file formats.

Index

• Constants
• func NewReader(r io.Reader) io.ReadCloser
• func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser
• func NewReaderOpts(r io.Reader, opts ...ReaderOpt) io.ReadCloser
• func NewStatelessWriter(dst io.Writer) io.WriteCloser
• func StatelessDeflate(out io.Writer, in []byte, eof bool, dict []byte) error
• type CorruptInputError
• type InternalError
  • func (e InternalError) Error() string
• type ReadError
• type Reader
• type ReaderOpt
  • func WithDict(dict []byte) ReaderOpt
  • func WithPartialBlock() ReaderOpt
• type Resetter
• type WriteError
• type Writer
  • func NewWriter(w io.Writer, level int) (*Writer, error)
  • func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error)
  • func NewWriterWindow(w io.Writer, windowSize int) (*Writer, error)
  • func (w *Writer) Close() error
  • func (w *Writer) Flush() error
  • func (w *Writer) Reset(dst io.Writer)
  • func (w *Writer) ResetDict(dst io.Writer, dict []byte)
  • func (w *Writer) Write(data []byte) (n int, err error)

Constants

const (
	NoCompression      = 0
	BestSpeed          = 1
	BestCompression    = 9
	DefaultCompression = -1

	// HuffmanOnly disables Lempel-Ziv match searching and only performs Huffman
	// entropy encoding. This mode is useful in compressing data that has
	// already been compressed with an LZ style algorithm (e.g. Snappy or LZ4)
	// that lacks an entropy encoder. Compression gains are achieved when
	// certain bytes in the input stream occur more frequently than others.
	//
	// Note that HuffmanOnly produces a compressed output that is
	// RFC 1951 compliant. That is, any valid DEFLATE decompressor will
	// continue to be able to decompress this output.
	HuffmanOnly         = -2
	ConstantCompression = HuffmanOnly // compatibility alias.

)

const MaxCustomWindowSize = windowSize

MaxCustomWindowSize is the maximum custom window that can be sent to NewWriterWindow.

const MinCustomWindowSize = 32

MinCustomWindowSize is the minimum window size that can be sent to NewWriterWindow.

Functions

func NewReader

func NewReader(r io.Reader) io.ReadCloser

NewReader returns a new ReadCloser that can be used to read the uncompressed version of r. If r does not also implement io.ByteReader, the decompressor may read more data than necessary from r. It is the caller's responsibility to call Close on the ReadCloser when finished reading.

The ReadCloser returned by NewReader also implements Resetter.

func NewReaderDict

func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser

NewReaderDict is like NewReader but initializes the reader with a preset dictionary. The returned Reader behaves as if the uncompressed data stream started with the given dictionary, which has already been read. NewReaderDict is typically used to read data compressed by NewWriterDict.

The ReadCloser returned by NewReader also implements Resetter.

func NewReaderOpts

func NewReaderOpts(r io.Reader, opts ...ReaderOpt) io.ReadCloser

NewReaderOpts returns new reader with provided options

func NewStatelessWriter

func NewStatelessWriter(dst io.Writer) io.WriteCloser

NewStatelessWriter will do compression but without maintaining any state between Write calls. There will be no memory kept between Write calls, but compression and speed will be suboptimal. Because of this, the size of actual Write calls will affect output size.

func StatelessDeflate

func StatelessDeflate(out io.Writer, in []byte, eof bool, dict []byte) error

StatelessDeflate allows compressing directly to a Writer without retaining state. When returning everything will be flushed. Up to 8KB of an optional dictionary can be given which is presumed to precede the block. Longer dictionaries will be truncated and will still produce valid output. Sending nil dictionary is perfectly fine.

Types

type CorruptInputError

type CorruptInputError = flate.CorruptInputError

A CorruptInputError reports the presence of corrupt input at a given offset.

type InternalError

type InternalError string

An InternalError reports an error in the flate code itself.

func (InternalError) Error

func (e InternalError) Error() string

type ReadError

type ReadError = flate.ReadError

A ReadError reports an error encountered while reading input.

Deprecated: No longer returned.

type Reader

type Reader interface {
	io.Reader
	io.ByteReader
}

Reader is the actual read interface needed by NewReader. If the passed in io.Reader does not also have ReadByte, the NewReader will introduce its own buffering.

type ReaderOpt

type ReaderOpt func(*decompressor)

func WithDict

func WithDict(dict []byte) ReaderOpt

WithDict initializes the reader with a preset dictionary

func WithPartialBlock

func WithPartialBlock() ReaderOpt

WithPartialBlock tells decompressor to return after each block, so it can read data written with partial flush

type Resetter

type Resetter interface {
	// Reset discards any buffered data and resets the Resetter as if it was
	// newly initialized with the given reader.
	Reset(r io.Reader, dict []byte) error
}

Resetter resets a ReadCloser returned by NewReader or NewReaderDict to to switch to a new underlying Reader. This permits reusing a ReadCloser instead of allocating a new one.

type WriteError

type WriteError = flate.WriteError

A WriteError reports an error encountered while writing output.

Deprecated: No longer returned.

type Writer

type Writer struct {
	// contains filtered or unexported fields
}

A Writer takes data written to it and writes the compressed form of that data to an underlying writer (see NewWriter).

func NewWriter

func NewWriter(w io.Writer, level int) (*Writer, error)

NewWriter returns a new Writer compressing data at the given level. Following zlib, levels range from 1 (BestSpeed) to 9 (BestCompression); higher levels typically run slower but compress more. Level 0 (NoCompression) does not attempt any compression; it only adds the necessary DEFLATE framing. Level -1 (DefaultCompression) uses the default compression level. Level -2 (ConstantCompression) will use Huffman compression only, giving a very fast compression for all types of input, but sacrificing considerable compression efficiency.

If level is in the range [-2, 9] then the error returned will be nil. Otherwise the error returned will be non-nil.

func NewWriterDict

func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error)

NewWriterDict is like NewWriter but initializes the new Writer with a preset dictionary. The returned Writer behaves as if the dictionary had been written to it without producing any compressed output. The compressed data written to w can only be decompressed by a Reader initialized with the same dictionary.

func NewWriterWindow

func NewWriterWindow(w io.Writer, windowSize int) (*Writer, error)

NewWriterWindow returns a new Writer compressing data with a custom window size. windowSize must be from MinCustomWindowSize to MaxCustomWindowSize.

func (*Writer) Close

func (w *Writer) Close() error

Close flushes and closes the writer.

func (*Writer) Flush

func (w *Writer) Flush() error

Flush flushes any pending data to the underlying writer. It is useful mainly in compressed network protocols, to ensure that a remote reader has enough data to reconstruct a packet. Flush does not return until the data has been written. Calling Flush when there is no pending data still causes the Writer to emit a sync marker of at least 4 bytes. If the underlying writer returns an error, Flush returns that error.

In the terminology of the zlib library, Flush is equivalent to Z_SYNC_FLUSH.

func (*Writer) Reset

func (w *Writer) Reset(dst io.Writer)

Reset discards the writer's state and makes it equivalent to the result of NewWriter or NewWriterDict called with dst and w's level and dictionary.

func (*Writer) ResetDict

func (w *Writer) ResetDict(dst io.Writer, dict []byte)

ResetDict discards the writer's state and makes it equivalent to the result of NewWriter or NewWriterDict called with dst and w's level, but sets a specific dictionary.

func (*Writer) Write

func (w *Writer) Write(data []byte) (n int, err error)

Write writes data to w, which will eventually write the compressed form of data to its underlying writer.