package snapref

Import Path
	github.com/klauspost/compress/internal/snapref (on go.dev)

Dependency Relation
	imports 4 packages, and imported by one package


Involved Source Files

	    decode.go
	    decode_other.go
	    encode.go
	    encode_other.go
	
		Package snapref 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.


Package-Level Type Names (total 2, both are exported)


	/* sort exporteds by:  |  */
	
		Reader is an io.Reader that can read Snappy-compressed bytes.
		
		Reader handles the Snappy stream format, not the Snappy block format.

		
			
		
			
				Read satisfies the io.Reader interface.

			
				ReadByte satisfies the io.ByteReader interface.

			
				Reset discards any buffered data, resets all state, and switches the Snappy
				reader to read from r. This permits reusing a Reader rather than allocating
				a new one.

			
		
			*Reader : github.com/klauspost/compress/flate.Reader
			*Reader : compress/flate.Reader
			*Reader : io.ByteReader
			*Reader : io.Reader
		
			func NewReader(r io.Reader) *Reader


	
		Writer is an io.Writer that can write Snappy-compressed bytes.
		
		Writer handles the Snappy stream format, not the Snappy block format.

		
			
		
			
				Close calls Flush and then closes the Writer.

			
				Flush flushes the Writer to its underlying io.Writer.

			
				Reset discards the writer's state and switches the Snappy writer to write to
				w. This permits reusing a Writer rather than allocating a new one.

			
				Write satisfies the io.Writer interface.

			
		
			*Writer : internal/bisect.Writer
			*Writer : io.Closer
			*Writer : io.WriteCloser
			*Writer : io.Writer
			
		
			func NewBufferedWriter(w io.Writer) *Writer
			func NewWriter(w io.Writer) *Writer




Package-Level Functions (total 17, in which 8 are exported)


	
		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.


	
		DecodedLen returns the length of the decoded block.


	
		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.


	
		EncodeBlockInto exposes encodeBlock but checks dst size.


	
		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.


	
		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.


	
		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


	
		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.


	


Package-Level Variables (total 6, in which 3 are exported)


	
		ErrCorrupt reports that the input is invalid.


	
		ErrTooLarge reports that the uncompressed length is too large.


	
		ErrUnsupported reports that the input isn't supported.


	


Package-Level Constants (total 20, none are exported)