zlib-bindings-0.1.1.2: Low-level bindings to the zlib package.

Safe HaskellNone

Codec.Zlib

Contents

Description

This is a middle-level wrapper around the zlib C API. It allows you to work fully with bytestrings and not touch the FFI at all, but is still low-level enough to allow you to implement high-level abstractions such as enumerators. Significantly, it does not use lazy IO.

You'll probably need to reference the docs a bit to understand the WindowBits parameters below, but a basic rule of thumb is 15 is for zlib compression, and 31 for gzip compression.

A simple streaming compressor in pseudo-code would look like:

 def <- initDeflate ...
 popper <- feedDeflate def rawContent
 pullPopper popper
 ...
 finishDeflate def sendCompressedData

You can see a more complete example is available in the included file-test.hs.

Synopsis

Inflate

data Inflate Source

The state of an inflation (eg, decompression) process. All allocated memory is automatically reclaimed by the garbage collector. Also can contain the inflation dictionary that is used for decompression.

initInflate :: WindowBits -> IO InflateSource

Initialize an inflation process with the given WindowBits. You will need to call feedInflate to feed compressed data to this and finishInflate to extract the final chunk of decompressed data.

initInflateWithDictionary :: WindowBits -> ByteString -> IO InflateSource

Initialize an inflation process with the given WindowBits. Unlike initInflate a dictionary for inflation is set which must match the one set during compression.

feedInflate :: Inflate -> ByteString -> IO PopperSource

Feed the given ByteString to the inflater. This function takes a function argument which takes a "popper". A popper is an IO action that will return the next bit of inflated data, returning Nothing when there is no more data to be popped.

Note that this function automatically buffers the output to defaultChunkSize, and therefore you won't get any data from the popper until that much decompressed data is available. After you have fed all of the compressed data to this function, you can extract your final chunk of decompressed data using finishInflate.

finishInflate :: Inflate -> IO ByteStringSource

As explained in feedInflate, inflation buffers your decompressed data. After you call feedInflate with your last chunk of compressed data, you will likely have some data still sitting in the buffer. This function will return it to you.

flushInflate :: Inflate -> IO ByteStringSource

Flush the inflation buffer. Useful for interactive application.

This is actually a synonym for finishInflate. It is provided for its more semantic name.

Since 0.0.3

Deflate

data Deflate Source

The state of a deflation (eg, compression) process. All allocated memory is automatically reclaimed by the garbage collector.

initDeflateSource

Arguments

:: Int

Compression level

-> WindowBits 
-> IO Deflate 

Initialize a deflation process with the given compression level and WindowBits. You will need to call feedDeflate to feed uncompressed data to this and finishDeflate to extract the final chunks of compressed data.

initDeflateWithDictionarySource

Arguments

:: Int

Compression level

-> ByteString

Deflate dictionary

-> WindowBits 
-> IO Deflate 

Initialize an deflation process with the given compression level and WindowBits. Unlike initDeflate a dictionary for deflation is set.

feedDeflate :: Deflate -> ByteString -> IO PopperSource

Feed the given ByteString to the deflater. This function takes a function argument which takes a "popper". A popper is an IO action that will return the next bit of deflated data, returning Nothing when there is no more data to be popped.

Note that this function automatically buffers the output to defaultChunkSize, and therefore you won't get any data from the popper until that much compressed data is available. After you have fed all of the decompressed data to this function, you can extract your final chunks of compressed data using finishDeflate.

finishDeflate :: Deflate -> PopperSource

As explained in feedDeflate, deflation buffers your compressed data. After you call feedDeflate with your last chunk of uncompressed data, we need to flush the rest of the data waiting to be deflated. This function takes a function parameter which accepts a "popper", just like feedDeflate.

flushDeflate :: Deflate -> PopperSource

Flush the deflation buffer. Useful for interactive application.

Internally this passes Z_SYNC_FLUSH to the zlib library.

Since 0.0.3

Data types

data WindowBits

This specifies the size of the compression window. Larger values of this parameter result in better compression at the expense of higher memory usage.

The compression window size is the value of the the window bits raised to the power 2. The window bits must be in the range 8..15 which corresponds to compression window sizes of 256b to 32Kb. The default is 15 which is also the maximum size.

The total amount of memory used depends on the window bits and the MemoryLevel. See the MemoryLevel for the details.

Constructors

WindowBits Int 

defaultWindowBits :: WindowBits

The default WindowBits is 15 which is also the maximum size.

data ZlibException Source

Exception that can be thrown from the FFI code. The parameter is the numerical error code from the zlib library. Quoting the zlib.h file directly:

  • #define Z_OK 0
  • #define Z_STREAM_END 1
  • #define Z_NEED_DICT 2
  • #define Z_ERRNO (-1)
  • #define Z_STREAM_ERROR (-2)
  • #define Z_DATA_ERROR (-3)
  • #define Z_MEM_ERROR (-4)
  • #define Z_BUF_ERROR (-5)
  • #define Z_VERSION_ERROR (-6)

Constructors

ZlibException Int