package s2
Import Path
github.com/klauspost/compress/s2 (on go.dev)
Dependency Relation
imports 17 packages, and imported by one package
Involved Source Files
decode.go
decode_asm.go
dict.go
encode.go
encode_all.go
encode_amd64.go
encode_best.go
encode_better.go
encodeblock_amd64.go
index.go
lz4convert.go
lz4sconvert.go
reader.go
Package s2 implements the S2 compression format.
S2 is an extension of Snappy. Similar to Snappy S2 is aimed for high throughput,
which is why it features concurrent compression for bigger payloads.
Decoding is compatible with Snappy compressed content,
but content compressed with S2 cannot be decompressed by Snappy.
For more information on Snappy/S2 differences see README in: https://github.com/klauspost/compress/tree/master/s2
There are actually two S2 formats: block and stream. They are related,
but different: trying to decompress block-compressed data as a S2 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.
A "better" compression option is available. This will trade some compression
speed
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.
Blocks to not offer much data protection, so it is up to you to
add data validation of decompressed blocks.
Streams perform CRC validation of the decompressed data.
Stream compression will also be performed on multiple CPU cores concurrently
significantly improving throughput.
writer.go
decode_amd64.s
encodeblock_amd64.s
Package-Level Type Names (total 10)
Dict contains a dictionary that can be used for encoding and decoding s2
Bytes will return a serialized version of the dictionary.
The output can be sent to NewDict.
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.
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.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EncodeBest 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.
EncodeBest compresses as good as reasonably possible but with a
big speed decrease.
The dst and src must not overlap. It is valid to pass a nil dst.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EncodeBetter 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.
EncodeBetter compresses better than Encode but typically with a
10-40% speed decrease on both compression and decompression.
The dst and src must not overlap. It is valid to pass a nil dst.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
*Dict : github.com/apache/arrow-go/v18/internal/hashing.ByteSlice
func MakeDict(data []byte, searchStart []byte) *Dict
func MakeDictManual(data []byte, firstIdx uint16) *Dict
func NewDict(dict []byte) *Dict
ErrCantSeek is returned if the stream cannot be seeked.
Reason string
Error returns the error as string.
ErrCantSeek : error
Index represents an S2/Snappy index.
// Total Compressed size if known. Will be -1 if unknown.
// Total Uncompressed size if known. Will be -1 if unknown.
Find the offset at or before the wanted (uncompressed) offset.
If offset is 0 or positive it is the offset from the beginning of the file.
If the uncompressed size is known, the offset must be within the file.
If an offset outside the file is requested io.ErrUnexpectedEOF is returned.
If the offset is negative, it is interpreted as the distance from the end of the file,
where -1 represents the last byte.
If offset from the end of the file is requested, but size is unknown,
ErrUnsupported will be returned.
JSON returns the index as JSON text.
Load a binary index.
A zero value Index can be used or a previous one can be reused.
LoadStream will load an index from the end of the supplied stream.
ErrUnsupported will be returned if the signature cannot be found.
ErrCorrupt will be returned if unexpected values are found.
io.ErrUnexpectedEOF is returned if there are too few bytes.
IO errors are returned as-is.
LZ4Converter provides conversion from LZ4 blocks as defined here:
https://github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md
ConvertBlock will convert an LZ4 block and append it as an S2
block without block length to dst.
The uncompressed size is returned as well.
dst must have capacity to contain the entire compressed block.
ConvertBlockSnappy will convert an LZ4 block and append it
as a Snappy block without block length to dst.
The uncompressed size is returned as well.
dst must have capacity to contain the entire compressed block.
LZ4sConverter provides conversion from LZ4s.
(Intel modified LZ4 Blocks)
https://cdrdv2-public.intel.com/743912/743912-qat-programmers-guide-v2.0.pdf
LZ4s is a variant of LZ4 block format. LZ4s should be considered as an intermediate compressed block format.
The LZ4s format is selected when the application sets the compType to CPA_DC_LZ4S in CpaDcSessionSetupData.
The LZ4s block returned by the Intel® QAT hardware can be used by an external
software post-processing to generate other compressed data formats.
The following table lists the differences between LZ4 and LZ4s block format. LZ4s block format uses
the same high-level formatting as LZ4 block format with the following encoding changes:
For Min Match of 4 bytes, Copy length value 1-15 means length 4-18 with 18 bytes adding an extra byte.
ONLY "Min match of 4 bytes" is supported.
ConvertBlock will convert an LZ4s block and append it as an S2
block without block length to dst.
The uncompressed size is returned as well.
dst must have capacity to contain the entire compressed block.
ConvertBlockSnappy will convert an LZ4s block and append it
as a Snappy block without block length to dst.
The uncompressed size is returned as well.
dst must have capacity to contain the entire compressed block.
Reader is an io.Reader that can read Snappy-compressed bytes.
DecodeConcurrent will decode the full stream to w.
This function should not be combined with reading, seeking or other operations.
Up to 'concurrent' goroutines will be used.
If <= 0, runtime.NumCPU will be used.
On success the number of bytes decompressed nil and is returned.
This is mainly intended for bigger streams.
GetBufferCapacity returns the capacity of the internal buffer.
This might be useful to know when reusing the same reader in combination
with the lazy buffer option.
Read satisfies the io.Reader interface.
ReadByte satisfies the io.ByteReader interface.
ReadSeeker will return an io.ReadSeeker and io.ReaderAt
compatible version of the reader.
If 'random' is specified the returned io.Seeker can be used for
random seeking, otherwise only forward seeking is supported.
Enabling random seeking requires the original input to support
the io.Seeker interface.
A custom index can be specified which will be used if supplied.
When using a custom index, it will not be read from the input stream.
The ReadAt position will affect regular reads and the current position of Seek.
So using Read after ReadAt will continue from where the ReadAt stopped.
No functions should be used concurrently.
The returned ReadSeeker contains a shallow reference to the existing Reader,
meaning changes performed to one is reflected in the other.
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.
Skip will skip n bytes forward in the decompressed output.
For larger skips this consumes less CPU and is faster than reading output and discarding it.
CRC is not checked on skipped blocks.
io.ErrUnexpectedEOF is returned if the stream ends before all bytes have been skipped.
If a decoding error is encountered subsequent calls to Read will also fail.
SkippableCB will register a callback for chunks with the specified ID.
ID must be a Reserved skippable chunks ID, 0x80-0xfd (inclusive).
For each chunk with the ID, the callback is called with the content.
Any returned non-nil error will abort decompression.
Only one callback per ID is supported, latest sent will be used.
Sending a nil function will disable previous callbacks.
You can peek the stream, triggering the callback, by doing a Read with a 0
byte buffer.
*Reader : github.com/klauspost/compress/flate.Reader
*Reader : github.com/quic-go/quic-go/quicvarint.Reader
*Reader : compress/flate.Reader
*Reader : google.golang.org/protobuf/encoding/protodelim.Reader
*Reader : io.ByteReader
*Reader : io.Reader
func NewReader(r io.Reader, opts ...ReaderOption) *Reader
ReaderOption is an option for creating a decoder.
func ReaderAllocBlock(blockSize int) ReaderOption
func ReaderIgnoreCRC() ReaderOption
func ReaderIgnoreStreamIdentifier() ReaderOption
func ReaderMaxBlockSize(blockSize int) ReaderOption
func ReaderSkippableCB(id uint8, fn func(r io.Reader) error) ReaderOption
func NewReader(r io.Reader, opts ...ReaderOption) *Reader
ReadSeeker provides random or forward seeking in compressed content.
See Reader.ReadSeeker
Reader *Reader
DecodeConcurrent will decode the full stream to w.
This function should not be combined with reading, seeking or other operations.
Up to 'concurrent' goroutines will be used.
If <= 0, runtime.NumCPU will be used.
On success the number of bytes decompressed nil and is returned.
This is mainly intended for bigger streams.
GetBufferCapacity returns the capacity of the internal buffer.
This might be useful to know when reusing the same reader in combination
with the lazy buffer option.
Read satisfies the io.Reader interface.
ReadAt reads len(p) bytes into p starting at offset off in the
underlying input source. It returns the number of bytes
read (0 <= n <= len(p)) and any error encountered.
When ReadAt returns n < len(p), it returns a non-nil error
explaining why more bytes were not returned. In this respect,
ReadAt is stricter than Read.
Even if ReadAt returns n < len(p), it may use all of p as scratch
space during the call. If some data is available but not len(p) bytes,
ReadAt blocks until either all the data is available or an error occurs.
In this respect ReadAt is different from Read.
If the n = len(p) bytes returned by ReadAt are at the end of the
input source, ReadAt may return either err == EOF or err == nil.
If ReadAt is reading from an input source with a seek offset,
ReadAt should not affect nor be affected by the underlying
seek offset.
Clients of ReadAt can execute parallel ReadAt calls on the
same input source. This is however not recommended.
ReadByte satisfies the io.ByteReader interface.
ReadSeeker will return an io.ReadSeeker and io.ReaderAt
compatible version of the reader.
If 'random' is specified the returned io.Seeker can be used for
random seeking, otherwise only forward seeking is supported.
Enabling random seeking requires the original input to support
the io.Seeker interface.
A custom index can be specified which will be used if supplied.
When using a custom index, it will not be read from the input stream.
The ReadAt position will affect regular reads and the current position of Seek.
So using Read after ReadAt will continue from where the ReadAt stopped.
No functions should be used concurrently.
The returned ReadSeeker contains a shallow reference to the existing Reader,
meaning changes performed to one is reflected in the other.
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.
Seek allows seeking in compressed data.
Skip will skip n bytes forward in the decompressed output.
For larger skips this consumes less CPU and is faster than reading output and discarding it.
CRC is not checked on skipped blocks.
io.ErrUnexpectedEOF is returned if the stream ends before all bytes have been skipped.
If a decoding error is encountered subsequent calls to Read will also fail.
SkippableCB will register a callback for chunks with the specified ID.
ID must be a Reserved skippable chunks ID, 0x80-0xfd (inclusive).
For each chunk with the ID, the callback is called with the content.
Any returned non-nil error will abort decompression.
Only one callback per ID is supported, latest sent will be used.
Sending a nil function will disable previous callbacks.
You can peek the stream, triggering the callback, by doing a Read with a 0
byte buffer.
ReadSeeker : github.com/klauspost/compress/flate.Reader
*ReadSeeker : github.com/apache/arrow-go/v18/arrow/ipc.ReadAtSeeker
*ReadSeeker : github.com/apache/arrow-go/v18/internal/utils.Reader
*ReadSeeker : github.com/apache/arrow-go/v18/parquet.ReaderAtSeeker
ReadSeeker : github.com/quic-go/quic-go/quicvarint.Reader
ReadSeeker : compress/flate.Reader
ReadSeeker : google.golang.org/protobuf/encoding/protodelim.Reader
ReadSeeker : io.ByteReader
ReadSeeker : io.Reader
*ReadSeeker : io.ReaderAt
*ReadSeeker : io.ReadSeeker
*ReadSeeker : io.Seeker
func (*Reader).ReadSeeker(random bool, index []byte) (*ReadSeeker, error)
Writer is an io.Writer that can write Snappy-compressed bytes.
AddSkippableBlock will add a skippable block to the stream.
The ID must be 0x80-0xfe (inclusive).
Length of the skippable block must be <= 16777215 bytes.
AsyncFlush writes any buffered bytes to a block and starts compressing it.
It does not wait for the output has been written as Flush() does.
Close calls Flush and then closes the Writer.
Calling Close multiple times is ok,
but calling CloseIndex after this will make it not return the index.
CloseIndex calls Close and returns an index on first call.
This is not required if you are only adding index to a stream.
EncodeBuffer will add a buffer to the stream.
This is the fastest way to encode a stream,
but the input buffer cannot be written to by the caller
until Flush or Close has been called when concurrency != 1.
Use the WriterBufferDone to receive a callback when the buffer is done
Processing.
Note that input is not buffered.
This means that each write will result in discrete blocks being created.
For buffered writes, use the regular Write function.
Flush flushes the Writer to its underlying io.Writer.
This does not apply padding.
ReadFrom implements the io.ReaderFrom interface.
Using this is typically more efficient since it avoids a memory copy.
ReadFrom reads data from r until EOF or error.
The return value n is the number of bytes read.
Any error except io.EOF encountered during the read is also returned.
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 : github.com/apache/thrift/lib/go/thrift.Flusher
*Writer : github.com/miekg/dns.Writer
*Writer : github.com/parquet-go/parquet-go/compress.Writer
*Writer : github.com/prometheus/common/expfmt.Closer
*Writer : internal/bisect.Writer
*Writer : io.Closer
*Writer : io.ReaderFrom
*Writer : io.WriteCloser
*Writer : io.Writer
func NewWriter(w io.Writer, opts ...WriterOption) *Writer
WriterOption is an option for creating a encoder.
func WriterAddIndex() WriterOption
func WriterBestCompression() WriterOption
func WriterBetterCompression() WriterOption
func WriterBlockSize(n int) WriterOption
func WriterBufferDone(fn func(b []byte)) WriterOption
func WriterConcurrency(n int) WriterOption
func WriterCustomEncoder(fn func(dst, src []byte) int) WriterOption
func WriterFlushOnWrite() WriterOption
func WriterPadding(n int) WriterOption
func WriterPaddingSrc(reader io.Reader) WriterOption
func WriterSnappyCompat() WriterOption
func WriterUncompressed() WriterOption
func NewWriter(w io.Writer, opts ...WriterOption) *Writer
Package-Level Functions (total 36)
ConcatBlocks will concatenate the supplied blocks and append them to the supplied destination.
If the destination is nil or too small, a new will be allocated.
The blocks are not validated, so garbage in = garbage out.
dst may not overlap block data.
Any data in dst is preserved as is, so it will not be considered a block.
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.
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.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EncodeBest 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.
EncodeBest compresses as good as reasonably possible but with a
big speed decrease.
The dst and src must not overlap. It is valid to pass a nil dst.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EncodeBetter 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.
EncodeBetter compresses better than Encode but typically with a
10-40% speed decrease on both compression and decompression.
The dst and src must not overlap. It is valid to pass a nil dst.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EncodeSnappy 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 output is Snappy compatible and will likely decompress faster.
The dst and src must not overlap. It is valid to pass a nil dst.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EncodeSnappyBest 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 output is Snappy compatible and will likely decompress faster.
The dst and src must not overlap. It is valid to pass a nil dst.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EncodeSnappyBetter 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 output is Snappy compatible and will likely decompress faster.
The dst and src must not overlap. It is valid to pass a nil dst.
The blocks will require the same amount of memory to decode as encoding,
and does not make for concurrent decoding.
Also note that blocks do not contain CRC information, so corruption may be undetected.
If you need to encode larger amounts of data, consider using
the streaming interface which gives all of these features.
EstimateBlockSize will perform a very fast compression
without outputting the result and return the compressed output size.
The function returns -1 if no improvement could be achieved.
Using actual compression will most often produce better compression than the estimate.
IndexStream will return an index for a stream.
The stream structure will be checked, but
data within blocks is not verified.
The returned index can either be appended to the end of the stream
or stored separately.
MakeDict will create a dictionary.
'data' must be at least MinDictSize.
If data is longer than MaxDictSize only the last MaxDictSize bytes will be used.
If searchStart is set the start repeat value will be set to the last
match of this content.
If no matches are found, it will attempt to find shorter matches.
This content should match the typical start of a block.
If at least 4 bytes cannot be matched, repeat is set to start of block.
MakeDictManual will create a dictionary.
'data' must be at least MinDictSize and less than or equal to MaxDictSize.
A manual first repeat index into data must be provided.
It must be less than len(data)-8.
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.
32 bit platforms will have lower thresholds for rejecting big content.
NewDict will read a dictionary.
It will return nil if the dictionary is invalid.
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 with S2 changes.
NewWriter returns a new Writer that compresses to w, using the
framing format described at
https://github.com/google/snappy/blob/master/framing_format.txt
Users must call Close to guarantee all data has been forwarded to
the underlying io.Writer and that resources are released.
They may also call Flush zero or more times before calling Close.
ReaderAllocBlock allows to control upfront stream allocations
and not allocate for frames bigger than this initially.
If frames bigger than this is seen a bigger buffer will be allocated.
Default is 1MB, which is default output size.
ReaderIgnoreCRC will make the reader skip CRC calculation and checks.
ReaderIgnoreStreamIdentifier will make the reader skip the expected
stream identifier at the beginning of the stream.
This can be used when serving a stream that has been forwarded to a specific point.
ReaderMaxBlockSize allows to control allocations if the stream
has been compressed with a smaller WriterBlockSize, or with the default 1MB.
Blocks must be this size or smaller to decompress,
otherwise the decoder will return ErrUnsupported.
For streams compressed with Snappy this can safely be set to 64KB (64 << 10).
Default is the maximum limit of 4MB.
ReaderSkippableCB will register a callback for chuncks with the specified ID.
ID must be a Reserved skippable chunks ID, 0x80-0xfd (inclusive).
For each chunk with the ID, the callback is called with the content.
Any returned non-nil error will abort decompression.
Only one callback per ID is supported, latest sent will be used.
You can peek the stream, triggering the callback, by doing a Read with a 0
byte buffer.
RemoveIndexHeaders will trim all headers and trailers from a given index.
This is expected to save 20 bytes.
These can be restored using RestoreIndexHeaders.
This removes a layer of security, but is the most compact representation.
Returns nil if headers contains errors.
The returned slice references the provided slice.
RestoreIndexHeaders will index restore headers removed by RemoveIndexHeaders.
No error checking is performed on the input.
If a 0 length slice is sent, it is returned without modification.
WriterAddIndex will append an index to the end of a stream
when it is closed.
WriterBestCompression will enable better compression.
EncodeBest compresses better than Encode but typically with a
big speed decrease on compression.
WriterBetterCompression will enable better compression.
EncodeBetter compresses better than Encode but typically with a
10-40% speed decrease on both compression and decompression.
WriterBlockSize allows to override the default block size.
Blocks will be this size or smaller.
Minimum size is 4KB and maximum size is 4MB.
Bigger blocks may give bigger throughput on systems with many cores,
and will increase compression slightly, but it will limit the possible
concurrency for smaller payloads for both encoding and decoding.
Default block size is 1MB.
When writing Snappy compatible output using WriterSnappyCompat,
the maximum block size is 64KB.
WriterBufferDone will perform a callback when EncodeBuffer has finished
writing a buffer to the output and the buffer can safely be reused.
If the buffer was split into several blocks, it will be sent after the last block.
Callbacks will not be done concurrently.
WriterConcurrency will set the concurrency,
meaning the maximum number of decoders to run concurrently.
The value supplied must be at least 1.
By default this will be set to GOMAXPROCS.
WriterCustomEncoder allows to override the encoder for blocks on the stream.
The function must compress 'src' into 'dst' and return the bytes used in dst as an integer.
Block size (initial varint) should not be added by the encoder.
Returning value 0 indicates the block could not be compressed.
Returning a negative value indicates that compression should be attempted.
The function should expect to be called concurrently.
WriterFlushOnWrite will compress blocks on each call to the Write function.
This is quite inefficient as blocks size will depend on the write size.
Use WriterConcurrency(1) to also make sure that output is flushed.
When Write calls return, otherwise they will be written when compression is done.
WriterPadding will add padding to all output so the size will be a multiple of n.
This can be used to obfuscate the exact output size or make blocks of a certain size.
The contents will be a skippable frame, so it will be invisible by the decoder.
n must be > 0 and <= 4MB.
The padded area will be filled with data from crypto/rand.Reader.
The padding will be applied whenever Close is called on the writer.
WriterPaddingSrc will get random data for padding from the supplied source.
By default crypto/rand is used.
WriterSnappyCompat will write snappy compatible output.
The output can be decompressed using either snappy or s2.
If block size is more than 64KB it is set to that.
WriterUncompressed will bypass compression.
The stream will be written as uncompressed blocks only.
If concurrency is > 1 CRC and output will still be done async.
Package-Level Variables (total 5)
ErrCorrupt reports that the input is invalid.
ErrCRC reports that the input failed CRC validation (streams only)
ErrDstTooSmall is returned when provided destination is too small.
ErrTooLarge reports that the uncompressed length is too large.
ErrUnsupported reports that the input isn't supported.
Package-Level Constants (total 7)
const ChunkTypeIndex = 153
MaxBlockSize is the maximum value where MaxEncodedLen will return a valid block size.
Blocks this big are highly discouraged, though.
Half the size on 32 bit systems.
MaxDictSize is the maximum dictionary size when repeat has been read.
MaxDictSrcOffset is the maximum offset where a dictionary entry can start.
MinDictSize is the minimum dictionary size when repeat has been read.
const S2IndexHeader = "s2idx\x00" const S2IndexTrailer = "\x00xdi2s" |
The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |