Bio.Iteratee.ZLib

Enumeratees

enumInflate :: MonadIO m => Format -> DecompressParams -> Enumeratee ByteString ByteString m a

Decompress the input and send to inner iteratee. If there is data after the end of zlib stream, it is left unprocessed.

enumInflateAny :: MonadIO m => Enumeratee ByteString ByteString m a

Inflate if Gzip format is recognized, otherwise pass through.

enumDeflate

Arguments

:: MonadIO m

=> Format

Format of input

-> CompressParams

Parameters of compression

-> Enumeratee ByteString ByteString m a

Compress the input and send to inner iteratee.

Exceptions

data ZLibParamsException

Denotes error is user-supplied parameter

Constructors

IncorrectCompressionLevel !Int

Incorrect compression level was chosen

IncorrectWindowBits !Int

Incorrect number of window bits was chosen

IncorrectMemoryLevel !Int

Incorrect memory level was chosen

Instances

Eq ZLibParamsException

Show ZLibParamsException

Exception ZLibParamsException

data ZLibException

Denotes error in compression and decompression

Constructors

NeedDictionary

Decompression requires user-supplied dictionary (not supported)

BufferError

Buffer error - denotes a library error | File Error

StreamError

State of steam inconsistent

DataError

Input data corrupted

MemoryError

Not enough memory

VersionError

Version error

Unexpected !CInt

Unexpected or unknown error - please report as bug

IncorrectState

Incorrect state - denotes error in library

Instances

Eq ZLibException

Show ZLibException

Exception ZLibException

Parameters

data CompressParams

Set of parameters for compression. For sane defaults use defaultCompressParams

Constructors

CompressParams

Fields

compressLevel :: !CompressionLevel

compressMethod :: !Method

compressWindowBits :: !WindowBits

compressMemoryLevel :: !MemoryLevel

compressStrategy :: !CompressionStrategy

compressBufferSize :: !Int

The size of output buffer. That is the size of Chunks that will be emitted to inner iterator (except the last Chunk).

compressDictionary :: !(Maybe ByteString)

defaultCompressParams :: CompressParams

data DecompressParams

Set of parameters for decompression. For sane defaults see defaultDecompressParams.

Constructors

DecompressParams

Fields

decompressWindowBits :: !WindowBits

Window size - it have to be at least the size of compressWindowBits the stream was compressed with.

Default in defaultDecompressParams is the maximum window size - please do not touch it unless you know what you are doing.

decompressBufferSize :: !Int

The size of output buffer. That is the size of Chunks that will be emitted to inner iterator (except the last Chunk).

decompressDictionary :: !(Maybe ByteString)

defaultDecompressParams :: DecompressParams

data Format

Specify the format for compression and decompression

Constructors

GZip

The gzip format is widely used and uses a header with checksum and some optional metadata about the compress file.

It is intended primarily for compressing individual files but is also used for network protocols such as HTTP.

The format is described in RFC 1952 http://www.ietf.org/rfc/rfc1952.txt.

Zlib

The zlib format uses a minimal header with a checksum but no other metadata. It is designed for use in network protocols.

The format is described in RFC 1950 http://www.ietf.org/rfc/rfc1950.txt

Raw

The 'raw' format is just the DEFLATE compressed data stream without and additionl headers.

Thr format is described in RFC 1951 http://www.ietf.org/rfc/rfc1951.txt

GZipOrZlib

Format for decompressing a Zlib or GZip stream.

Instances

Eq Format

data CompressionLevel

The compression level specify the tradeoff between speed and compression.

Constructors

DefaultCompression

Default compression level set at 6.

NoCompression

No compression, just a block copy.

BestSpeed

The fastest compression method (however less compression)

BestCompression

The best compression method (however slowest)

CompressionLevel Int

Compression level set by number from 1 to 9

data Method

Specify the compression method.

Constructors

Deflated

'Deflate' is so far the only method supported.

data WindowBits

This specify the size of compression level. Larger values result in better compression at the expense of highier memory usage.

The compression window size is 2 to the power of the value of the window bits.

The total memory used depends on windows bits and MemoryLevel.

Constructors

WindowBits Int

The size of window bits. It have to be between 8 (which corresponds to 256b i.e. 32B) and 15 (which corresponds to 32 kib i.e. 4kiB).

DefaultWindowBits

The default window size which is 4kiB

data MemoryLevel

The MemoryLevel specifies how much memory should be allocated for the internal state. It is a tradeoff between memory usage, speed and compression. Using more memory allows faster and better compression.

The memory used for interal state, excluding WindowBits, is 512 bits times 2 to power of memory level.

The total amount of memory use depends on the WindowBits and MemoryLevel.

Constructors

DefaultMemoryLevel

Default memory level set to 8.

MinMemoryLevel

Use the small amount of memory (equivalent to memory level 1) - i.e. 1024b or 256 B. It slow and reduces the compresion ratio.

MaxMemoryLevel

Maximum memory level for optimal compression speed (equivalent to memory level 9). The internal state is 256kib or 32kiB.

MemoryLevel Int

A specific level. It have to be between 1 and 9.

data CompressionStrategy

Tunes the compress algorithm but does not affact the correctness.

Constructors

DefaultStrategy

Default strategy

Filtered

Use the filtered compression strategy for data produced by a filter (or predictor). Filtered data consists mostly of small values with a somewhat random distribution. In this case, the compression algorithm is tuned to compress them better. The effect of this strategy is to force more Huffman coding and less string matching; it is somewhat intermediate between DefaultStrategy and HuffmanOnly.

HuffmanOnly

Use the Huffman-only compression strategy to force Huffman encoding only (no string match).

enumSyncFlush :: Monad m => Enumerator ByteString m a

Enumerate synchronise flush. It cause the all pending output to be flushed and all available input is sent to inner Iteratee.

enumFullFlush :: Monad m => Enumerator ByteString m a

Enumerate full flush. It flushes all pending output and reset the compression. It allows to restart from this point if compressed data was corrupted but it can affect the compression rate.

It may be only used during compression.

enumBlockFlush :: Monad m => Enumerator ByteString m a

Enumerate block flush. If the enumerator is compressing it allows to finish current block. If the enumerator is decompressing it forces to stop on next block boundary.