gzip

Imports

Imports # 

"bufio"
"compress/flate"
"encoding/binary"
"errors"
"hash/crc32"
"io"
"time"
"compress/flate"
"errors"
"fmt"
"hash/crc32"
"io"
"time"

Constants & Variables

BestCompression const #

These constants are copied from the flate package, so that code that imports "compress/gzip" does not also have to import "compress/flate".

const BestCompression = flate.BestCompression

BestSpeed const #

These constants are copied from the flate package, so that code that imports "compress/gzip" does not also have to import "compress/flate".

const BestSpeed = flate.BestSpeed

DefaultCompression const #

These constants are copied from the flate package, so that code that imports "compress/gzip" does not also have to import "compress/flate".

const DefaultCompression = flate.DefaultCompression

ErrChecksum var #

ErrChecksum is returned when reading GZIP data that has an invalid checksum.

var ErrChecksum = *ast.CallExpr

ErrHeader var #

ErrHeader is returned when reading GZIP data that has an invalid header.

var ErrHeader = *ast.CallExpr

HuffmanOnly const #

These constants are copied from the flate package, so that code that imports "compress/gzip" does not also have to import "compress/flate".

const HuffmanOnly = flate.HuffmanOnly

NoCompression const #

These constants are copied from the flate package, so that code that imports "compress/gzip" does not also have to import "compress/flate".

const NoCompression = flate.NoCompression

flagComment const # 

const flagComment = *ast.BinaryExpr

flagExtra const # 

const flagExtra = *ast.BinaryExpr

flagHdrCrc const # 

const flagHdrCrc = *ast.BinaryExpr

flagName const # 

const flagName = *ast.BinaryExpr

flagText const # 

const flagText = *ast.BinaryExpr

gzipDeflate const # 

const gzipDeflate = 8

gzipID1 const # 

const gzipID1 = 0x1f

gzipID2 const # 

const gzipID2 = 0x8b

le var # 

var le = binary.LittleEndian

Structs

Reader struct #

A Reader is an [io.Reader] that can be read to retrieve uncompressed data from a gzip-format compressed file. In general, a gzip file can be a concatenation of gzip files, each with its own header. Reads from the Reader return the concatenation of the uncompressed data of each. Only the first header is recorded in the Reader fields. Gzip files store a length and checksum of the uncompressed data. The Reader will return an [ErrChecksum] when [Reader.Read] reaches the end of the uncompressed data if it does not have the expected length or checksum. Clients should treat data returned by [Reader.Read] as tentative until they receive the [io.EOF] marking the end of the data.

type Reader struct {
Header
r flate.Reader
decompressor io.ReadCloser
digest uint32
size uint32
buf [512]byte
err error
multistream bool
}

Writer struct #

A Writer is an io.WriteCloser. Writes to a Writer are compressed and written to w.

type Writer struct {
Header
w io.Writer
level int
wroteHeader bool
closed bool
buf [10]byte
compressor *flate.Writer
digest uint32
size uint32
err error
}

Functions

Close method #

Close closes the [Reader]. It does not close the underlying [io.Reader]. In order for the GZIP checksum to be verified, the reader must be fully consumed until the [io.EOF].

func (z *Reader) Close() error

Close method #

Close closes the [Writer] by flushing any unwritten data to the underlying [io.Writer] and writing the GZIP footer. It does not close the underlying [io.Writer].

func (z *Writer) Close() error

Flush method #

Flush flushes any pending compressed 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. 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 (z *Writer) Flush() error

Multistream method #

Multistream controls whether the reader supports multistream files. If enabled (the default), the [Reader] expects the input to be a sequence of individually gzipped data streams, each with its own header and trailer, ending at EOF. The effect is that the concatenation of a sequence of gzipped files is treated as equivalent to the gzip of the concatenation of the sequence. This is standard behavior for gzip readers. Calling Multistream(false) disables this behavior; disabling the behavior can be useful when reading file formats that distinguish individual gzip data streams or mix gzip data streams with other data streams. In this mode, when the [Reader] reaches the end of the data stream, [Reader.Read] returns [io.EOF]. The underlying reader must implement [io.ByteReader] in order to be left positioned just after the gzip stream. To start the next stream, call z.Reset(r) followed by z.Multistream(false). If there is no next stream, z.Reset(r) will return [io.EOF].

func (z *Reader) Multistream(ok bool)

NewReader function #

NewReader creates a new [Reader] reading the given reader. 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 [Reader] when done. The [Reader.Header] fields will be valid in the [Reader] returned.

func NewReader(r io.Reader) (*Reader, error)

NewWriter function #

NewWriter returns a new [Writer]. Writes to the returned writer are compressed and written to w. It is the caller's responsibility to call Close on the [Writer] when done. Writes may be buffered and not flushed until Close. Callers that wish to set the fields in Writer.Header must do so before the first call to Write, Flush, or Close.

func NewWriter(w io.Writer) *Writer

NewWriterLevel function #

NewWriterLevel is like [NewWriter] but specifies the compression level instead of assuming [DefaultCompression]. The compression level can be [DefaultCompression], [NoCompression], [HuffmanOnly] or any integer value between [BestSpeed] and [BestCompression] inclusive. The error returned will be nil if the level is valid.

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

Read method #

Read implements [io.Reader], reading uncompressed bytes from its underlying [Reader].

func (z *Reader) Read(p []byte) (n int, err error)

Reset method #

Reset discards the [Writer] z's state and makes it equivalent to the result of its original state from [NewWriter] or [NewWriterLevel], but writing to w instead. This permits reusing a [Writer] rather than allocating a new one.

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

Reset method #

Reset discards the [Reader] z's state and makes it equivalent to the result of its original state from [NewReader], but reading from r instead. This permits reusing a [Reader] rather than allocating a new one.

func (z *Reader) Reset(r io.Reader) error

Write method #

Write writes a compressed form of p to the underlying [io.Writer]. The compressed bytes are not necessarily flushed until the [Writer] is closed.

func (z *Writer) Write(p []byte) (int, error)

init method # 

func (z *Writer) init(w io.Writer, level int)

noEOF function #

noEOF converts io.EOF to io.ErrUnexpectedEOF.

func noEOF(err error) error

readHeader method #

readHeader reads the GZIP header according to section 2.3.1. This method does not set z.err.

func (z *Reader) readHeader() (hdr Header, err error)

readString method #

readString reads a NUL-terminated string from z.r. It treats the bytes read as being encoded as ISO 8859-1 (Latin-1) and will output a string encoded using UTF-8. This method always updates z.digest with the data read.

func (z *Reader) readString() (string, error)

writeBytes method #

writeBytes writes a length-prefixed byte slice to z.w.

func (z *Writer) writeBytes(b []byte) error

writeString method #

writeString writes a UTF-8 string s in GZIP's format to z.w. GZIP (RFC 1952) specifies that strings are NUL-terminated ISO 8859-1 (Latin-1).

func (z *Writer) writeString(s string) (err error)

Generated with Arrow