|Portability||portable to Hugs and GHC.|
|Maintainer||Lennart Kolmodin <firstname.lastname@example.org>|
The Get monad. A monad for efficiently building structures from encoded lazy ByteStrings.
- data Get a
- runGet :: Get a -> ByteString -> a
- runGetOrFail :: Get a -> ByteString -> Either (ByteString, ByteOffset, String) (ByteString, ByteOffset, a)
- type ByteOffset = Int64
- data Decoder a
- runGetIncremental :: Get a -> Decoder a
- pushChunk :: Decoder a -> ByteString -> Decoder a
- pushChunks :: Decoder a -> ByteString -> Decoder a
- pushEndOfInput :: Decoder a -> Decoder a
- skip :: Int -> Get ()
- isEmpty :: Get Bool
- bytesRead :: Get Int64
- getByteString :: Int -> Get ByteString
- getLazyByteString :: Int64 -> Get ByteString
- getLazyByteStringNul :: Get ByteString
- getRemainingLazyByteString :: Get ByteString
- getWord8 :: Get Word8
- getWord16be :: Get Word16
- getWord32be :: Get Word32
- getWord64be :: Get Word64
- getWord16le :: Get Word16
- getWord32le :: Get Word32
- getWord64le :: Get Word64
- getWordhost :: Get Word
- getWord16host :: Get Word16
- getWord32host :: Get Word32
- getWord64host :: Get Word64
- runGetState :: Get a -> ByteString -> ByteOffset -> (a, ByteString, ByteOffset)
- remaining :: Get Int64
- getBytes :: Int -> Get ByteString
The Get type
The lazy input interface
The lazy interface consumes a single lazy
ByteString. It's the easiest
interface to get started with, but it doesn't support interleaving I/O and
parsing, unless lazy I/O is used.
There is no way to provide more input other than the initial data. To be able to incrementally give more data, see the incremental input interface.
The incremental input interface
The incremental interface gives you more control over how input is provided during parsing. This lets you e.g. interleave parsing and I/O.
The incremental interface consumes a strict
ByteString at a time, each
being part of the total amount of input. If your decoder needs more input to
finish it will return a
Partial with a continuation.
If there is no more input, provide it
Fail will be returned if it runs into an error, together with a message,
the position and the remaining input.
If it succeeds it will return
Done with the resulting value,
the position and the remaining input.
A decoder procuced by running a
|Fail !ByteString !ByteOffset String|
The decoder ran into an error. The decoder either used
|Partial (Maybe ByteString -> Decoder a)|
|Done !ByteString !ByteOffset a|
The decoder has successfully finished. Except for the output value you also get any unused input as well as the number of bytes consumed.
Test whether all input has been consumed, i.e. there are no remaining undecoded bytes.
An efficient get method for strict ByteStrings. Fails if fewer than
bytes are left in the input. If
n <= 0 then the empty string is returned.
An efficient get method for lazy ByteStrings. Fails if fewer than
bytes are left in the input.
Get a lazy ByteString that is terminated with a NUL byte. The returned string does not contain the NUL byte. Fails if it reaches the end of input without finding a NUL.
Get the remaining bytes as a lazy ByteString. Note that this can be an expensive function to use as it forces reading all input and keeping the string in-memory.
Host-endian, unaligned decoding
O(1). Read a single native machine word. The word is read in host order, host endian form, for the machine you're on. On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes.
O(1). Read a 2 byte Word16 in native host order and host endianness.
Deprecated: Use runGetPartial instead. This function will be removed.
DEPRECATED. Provides compatibility with previous versions of this library.
Get monad and return a tuple with thee values.
The first value is the result of the decoder. The second and third are the
unused input, and the number of consumed bytes.
DEPRECATED. Get the number of bytes of remaining input. Note that this is an expensive function to use as in order to calculate how much input remains, all input has to be read and kept in-memory. The decoder keeps the input as a strict bytestring, so you are likely better off by calculating the remaining input in another way.