HCodecs-0.0.2: The library to read, write and manipulate MIDI, WAV, and SoundFont2 files.Source codeContentsIndex
Data.ByteString.Builder
PortabilityPortable
Stabilityexperimental
MaintainerGeorge Giorgidze <http://cs.nott.ac.uk/~ggg/>
Contents
The Builder type
Constructing Builders
Flushing the buffer state
Derived Builders
Big-endian writes
Little-endian writes
Host-endian, unaligned writes
Description
Efficient construction of lazy bytestrings.
Synopsis
data Builder
toLazyByteString :: Builder -> ByteString
empty :: Builder
singleton :: Word8 -> Builder
putWord8 :: Word8 -> Builder
putInt8 :: Int8 -> Builder
append :: Builder -> Builder -> Builder
fromByteString :: ByteString -> Builder
fromLazyByteString :: ByteString -> Builder
putString :: String -> Builder
flush :: Builder
putWord16be :: Word16 -> Builder
putWord24be :: Word32 -> Builder
putWord32be :: Word32 -> Builder
putWord64be :: Word64 -> Builder
putInt16be :: Int16 -> Builder
putInt32be :: Int32 -> Builder
putInt64be :: Int64 -> Builder
putWord16le :: Word16 -> Builder
putWord24le :: Word32 -> Builder
putWord32le :: Word32 -> Builder
putWord64le :: Word64 -> Builder
putInt16le :: Int16 -> Builder
putInt32le :: Int32 -> Builder
putInt64le :: Int64 -> Builder
putWordHost :: Word -> Builder
putWord16host :: Word16 -> Builder
putWord32host :: Word32 -> Builder
putWord64host :: Word64 -> Builder
putVarLenBe :: Word64 -> Builder
putVarLenLe :: Word64 -> Builder
The Builder type
data Builder Source

A Builder is an efficient way to build lazy ByteStrings. There are several functions for constructing Builders, but only one to inspect them: to extract any data, you have to turn them into lazy ByteStrings using toLazyByteString.

Internally, a Builder constructs a lazy L.Bytestring by filling byte arrays piece by piece. As each buffer is filled, it is 'popped' off, to become a new chunk of the resulting lazy ByteString. All this is hidden from the user of the Builder.

show/hide Instances
toLazyByteString :: Builder -> ByteStringSource
O(n). Extract a lazy ByteString from a Builder. The construction work takes place if and when the relevant part of the lazy ByteString is demanded.
Constructing Builders
empty :: BuilderSource

O(1). The empty Builder, satisfying

singleton :: Word8 -> BuilderSource

O(1). A Builder taking a single byte, satisfying

putWord8 :: Word8 -> BuilderSource
putInt8 :: Int8 -> BuilderSource
append :: Builder -> Builder -> BuilderSource

O(1). The concatenation of two Builders, an associative operation with identity empty, satisfying

fromByteString :: ByteString -> BuilderSource

O(1). A Builder taking a ByteString, satisfying

fromLazyByteString :: ByteString -> BuilderSource

O(1). A Builder taking a lazy ByteString, satisfying

putString :: String -> BuilderSource
Flushing the buffer state
flush :: BuilderSource
O(1). Pop the ByteString we have constructed so far, if any, yielding a new chunk in the result lazy ByteString.
Derived Builders
Big-endian writes
putWord16be :: Word16 -> BuilderSource
Write a Word16 in big endian format
putWord24be :: Word32 -> BuilderSource
Write a 24 bit number in big endian format represented as Word32
putWord32be :: Word32 -> BuilderSource
Write a Word32 in big endian format
putWord64be :: Word64 -> BuilderSource
Write a Word64 in big endian format
putInt16be :: Int16 -> BuilderSource
putInt32be :: Int32 -> BuilderSource
putInt64be :: Int64 -> BuilderSource
Little-endian writes
putWord16le :: Word16 -> BuilderSource
Write a Word16 in little endian format
putWord24le :: Word32 -> BuilderSource
Write a 24 bit number in little endian format represented as Word32
putWord32le :: Word32 -> BuilderSource
Write a Word32 in little endian format
putWord64le :: Word64 -> BuilderSource
Write a Word64 in little endian format
putInt16le :: Int16 -> BuilderSource
putInt32le :: Int32 -> BuilderSource
putInt64le :: Int64 -> BuilderSource
Host-endian, unaligned writes
putWordHost :: Word -> BuilderSource
O(1). A Builder taking a single native machine word. The word is written 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. Values written this way are not portable to different endian or word sized machines, without conversion.
putWord16host :: Word16 -> BuilderSource
Write a Word16 in native host order and host endianness. 2 bytes will be written, unaligned.
putWord32host :: Word32 -> BuilderSource
Write a Word32 in native host order and host endianness. 4 bytes will be written, unaligned.
putWord64host :: Word64 -> BuilderSource
Write a Word64 in native host order. On a 32 bit machine we write two host order Word32s, in big endian form. 8 bytes will be written, unaligned.
putVarLenBe :: Word64 -> BuilderSource
putVarLenLe :: Word64 -> BuilderSource
Produced by Haddock version 2.4.2