blaze-builder-0.3.3.0: Efficient buffered output.

Portability | tested on GHC only
Stability | experimental
Maintainer | Simon Meier <iridcode@gmail.com>
Safe Haskell | None

Blaze.ByteString.Builder.Internal.Buffer

Contents

- Buffers
  - Status information
  - Creation and modification
  - Conversion to bytestings
- Buffer allocation strategies
- Executing puts respect to some monad

Description

Execution of the `Put` monad and hence also `Builder`s with respect to buffers.

Synopsis

- data Buffer = Buffer !(ForeignPtr Word8) !(Ptr Word8) !(Ptr Word8) !(Ptr Word8)
- freeSize :: Buffer -> Int
- sliceSize :: Buffer -> Int
- bufferSize :: Buffer -> Int
- allocBuffer :: Int -> IO Buffer
- reuseBuffer :: Buffer -> Buffer
- nextSlice :: Int -> Buffer -> Maybe Buffer
- updateEndOfSlice :: Buffer -> Ptr Word8 -> Buffer
- execBuildStep :: BuildStep a -> Buffer -> IO (BuildSignal a)
- unsafeFreezeBuffer :: Buffer -> ByteString
- unsafeFreezeNonEmptyBuffer :: Buffer -> Maybe ByteString
- type BufferAllocStrategy = (IO Buffer, Int -> Buffer -> IO (IO Buffer))
- allNewBuffersStrategy :: Int -> BufferAllocStrategy
- reuseBufferStrategy :: IO Buffer -> BufferAllocStrategy
- runPut :: Monad m => (IO (BuildSignal a) -> m (BuildSignal a)) -> (Int -> Buffer -> m Buffer) -> (ByteString -> m ()) -> Put a -> Buffer -> m (a, Buffer)

# Buffers

data Buffer Source

A buffer `Buffer fpbuf p0 op ope` describes a buffer with the underlying byte array `fpbuf..ope`, the currently written slice `p0..op` and the free space `op..ope`.

Constructors

Buffer !(ForeignPtr Word8) !(Ptr Word8) !(Ptr Word8) !(Ptr Word8) |

## Status information

freeSize :: Buffer -> Int Source

The size of the free space of the buffer.

sliceSize :: Buffer -> Int Source

The size of the written slice in the buffer.

bufferSize :: Buffer -> Int Source

The size of the whole byte array underlying the buffer.

## Creation and modification

allocBuffer :: Int -> IO Buffer Source

`allocBuffer size` allocates a new buffer of size `size`.

reuseBuffer :: Buffer -> Buffer Source

Resets the beginning of the next slice and the next free byte such that the whole buffer can be filled again.

nextSlice :: Int -> Buffer -> Maybe Buffer Source

Move the beginning of the slice to the next free byte such that the remaining free space of the buffer can be filled further. This operation is safe and can be used to fill the remaining part of the buffer after a direct insertion of a bytestring or a flush.

updateEndOfSlice :: Buffer -> Ptr Word8 -> Buffer Source

Update the end of slice pointer.

execBuildStep :: BuildStep a -> Buffer -> IO (BuildSignal a)Source

Execute a build step on the given buffer.

## Conversion to bytestings

unsafeFreezeBuffer :: Buffer -> ByteString Source

Convert the buffer to a bytestring. This operation is unsafe in the sense that created bytestring shares the underlying byte array with the buffer. Hence, depending on the later use of this buffer (e.g., if it gets reset and filled again) referential transparency may be lost.

unsafeFreezeNonEmptyBuffer :: Buffer -> Maybe ByteString Source

Convert a buffer to a non-empty bytestring. See `unsafeFreezeBuffer` for the explanation of why this operation may be unsafe.

# Buffer allocation strategies

type BufferAllocStrategy = (IO Buffer, Int -> Buffer -> IO (IO Buffer))Source

A buffer allocation strategy `(buf0, nextBuf)` specifies the initial buffer to use and how to compute a new buffer `nextBuf minSize buf` with at least size `minSize` from a filled buffer `buf`. The double nesting of the `IO` monad helps to ensure that the reference to the filled buffer `buf` is lost as soon as possible, but the new buffer doesn't have to be allocated too early.

allNewBuffersStrategy :: Int -> BufferAllocStrategy Source

The simplest buffer allocation strategy: whenever a buffer is requested, allocate a new one that is big enough for the next build step to execute.

NOTE that this allocation strategy may spill quite some memory upon direct insertion of a bytestring by the builder. Thats no problem for garbage collection, but it may lead to unreasonably high memory consumption in special circumstances.

reuseBufferStrategy :: IO Buffer -> BufferAllocStrategy Source

An unsafe, but possibly more efficient buffer allocation strategy: reuse the buffer, if it is big enough for the next build step to execute.

# Executing puts respect to some monad

runPut :: Monad m => (IO (BuildSignal a) -> m (BuildSignal a)) -> (Int -> Buffer -> m Buffer) -> (ByteString -> m ()) -> Put a -> Buffer -> m (a, Buffer)Source

Execute a put on a buffer.

TODO: Generalize over buffer allocation strategy.