Input device

readInput should return 0 on EOF.

Output device

writeOutput should not return until all data are written (may not necessarily flushed to hardware, that should be done in device specific way).

Input device with buffer, NOT THREAD SAFE!

• A BufferedInput should not be used in multiple threads, there's no locking mechanism to protect buffering state.
• A Input device should only be used with a single BufferedInput, If multiple BufferedInput s are opened on a same Input device, the behaviour is undefined.

Open a new buffered input with defaultChunkSize as buffer size.

Open a new buffered input with given buffer size, e.g. defaultChunkSize.

Request bytes chunk from BufferedInput.

The buffering logic is quite simple:

If we have pushed back bytes, directly return it, otherwise we read using buffer size. If we read N bytes, and N is larger than half of the buffer size, then we freeze buffer and return, otherwise we copy buffer into result and reuse buffer afterward.

Request UTF8 Text chunk from BufferedInput.

The buffer size must be larger than 4 bytes to guarantee decoding progress. If there're trailing bytes before EOF, an OtherError with name EINCOMPLETE will be thrown, if there're invalid UTF8 bytes, an OtherError with name EINVALIDUTF8 will be thrown.`

Push bytes back into buffer(if not empty).

Read buffer and parse with Parser.

This function will continuously draw data from input before parsing finish. Unconsumed bytes will be returned to buffer.

Either during parsing or before parsing, reach EOF will result in ParseError.

Read exactly N bytes.

If EOF reached before N bytes read, an OtherError with name EINCOMPLETE will be thrown.

Read until reach a magic bytes, return bytes(including the magic bytes).

Empty bytes indicate EOF. if EOF is reached before meet a magic byte, partial bytes are returned.

 /----- readToMagic ----- \ /----- readToMagic -----\ ...
+------------------+-------+-----------------+-------+
|       ...        | magic |       ...       | magic | ...
+------------------+-------+-----------------+-------+

Read to a linefeed ('n' or 'rn'), return Bytes before it.

Return bytes don't include linefeed, empty bytes indicate empty line, Nothing indicate EOF. If EOF is reached before meet a line feed, partial line is returned.

 /--- readLine ---\ discarded /--- readLine ---\ discarded / ...
+------------------+---------+------------------+---------+
|      ...         | \r\n/\n |       ...        | \r\n/\n | ...
+------------------+---------+------------------+---------+

Read all chunks from a BufferedInput until EOF.

This function will loop read until meet EOF(Input device return empty), Useful for reading small file into memory.

Read all chunks from a BufferedInput, and concat chunks together.

This function will loop read until meet EOF(Input device return empty), Useful for reading small file into memory.

Output device with buffer, NOT THREAD SAFE!

• A BufferedOutput should not be used in multiple threads, there's no locking mechanism to protect buffering state.
• A Output device should only be used with a single BufferedOutput, If multiple BufferedOutput s are opened on a same BufferedOutput device, the output will be interleaved.

Open a new buffered output with defaultChunkSize as buffer size.

Open a new buffered output with given buffer size, e.g. defaultChunkSize.

Write Bytes into buffered handle.

• If buffer is empty and bytes are larger than half of buffer, directly write bytes, otherwise copy bytes to buffer.
• If buffer is not empty, then copy bytes to buffer if it can hold, otherwise write buffer first, then try again.

Directly write Builder into buffered handle.

Run Builder with buffer if it can hold, write to device when buffer is full.

Flush the buffer into output device(if buffer is not empty).

The chunk size used for I/O. Currently set to 16k - chunkOverhead

The recommended chunk size. Currently set to 4k - chunkOverhead.

The memory management overhead. Currently this is tuned for GHC only.