expect class IoBuffer : Input, Output, ChunkBuffer
A read-write facade to actual buffer of fixed size. Multiple views could share the same actual buffer. Concurrent unsafe. The only concurrent-safe operation is release. In most cases ByteReadPacket and BytePacketBuilder should be used instead.
IoBuffer(memory: Memory, origin: ChunkBuffer?) IoBuffer(external: ByteBuffer) |
var |
|
val endOfInput: Boolean
It is |
abstract val endOfInput: Boolean
It is |
|
var next: ChunkBuffer?
Reference to next buffer view. Useful to chain multiple views. |
|
var origin: ChunkBuffer?
Reference to an origin buffer view this was copied from |
|
val referenceCount: Int |
fun fun fun fun |
|
fun fun |
|
fun |
|
fun |
|
fun close(): Unit |
|
fun duplicate(): IoBuffer
Create a new Buffer instance pointing to the same memory and having the same positions. |
|
fun |
|
fun flush(): Unit |
|
fun |
|
fun |
|
fun
Creates a new view to the same actual buffer with independent read and write positions and gaps |
|
fun peekTo(destination: Memory, destinationOffset: Long, offset: Long, min: Long, max: Long): Long
Copy at least min but up to max bytes to the specified destination buffer from this input
skipping offset bytes. If there are not enough bytes available to provide min bytes then
it fails with an exception.
It is safe to specify fun
Copy available bytes to the specified buffer but keep them available. If the underlying implementation could trigger bytes population from the underlying source and block until any bytes available |
|
fun
Push back n bytes: only possible if there were at least n bytes read before this operation. |
|
fun fun |
|
fun fun fun fun fun fun fun fun |
|
fun readDirect(block: (ByteBuffer) -> Unit): Int
Apply block function on a ByteBuffer of readable bytes. The block function should return number of consumed bytes. |
|
fun |
|
fun |
|
fun fun fun fun fun fun fun fun |
|
fun |
|
fun |
|
fun |
|
fun |
|
fun release(pool: ObjectPool<IoBuffer>): Unit |
|
fun resetFromContentToWrite(child: ByteBuffer): Unit
Reset read/write position to original's content pos/limit. May not work due to slicing. |
|
fun |
|
fun toString(): String |
|
fun tryPeek(): Int |
|
fun fun |
|
fun |
|
fun writeDirect(size: Int, block: (ByteBuffer) -> Unit): Int
Apply block function on a ByteBuffer of the free space. The block function should return number of written bytes. |
|
fun |
|
fun |
|
fun fun fun fun fun fun fun fun |
|
fun |
|
fun |
|
fun |
abstract fun append(csq: CharArray, start: Int, end: Int): Appendable |
|
fun cleanNext(): ChunkBuffer? |
|
abstract fun discard(n: Long): Long
Discard at most n bytes |
|
open fun duplicate(): ChunkBuffer
Create a new Buffer instance pointing to the same memory and having the same positions. |
|
open fun |
|
abstract fun peekTo(destination: Memory, destinationOffset: Long, offset: Long = 0, min: Long = 1, max: Long = Long.MAX_VALUE): Long
Try to copy at least min but up to max bytes to the specified destination buffer from this input
skipping offset bytes. If there are not enough bytes available to provide min bytes after skipping offset
bytes then it will trigger the underlying source reading first and after that will
simply copy available bytes even if EOF encountered so min is not a requirement but a desired number of bytes.
It is safe to specify max greater than the destination free space.
open fun
Copy available bytes to the specified buffer but keep them available. The underlying implementation could trigger bytes population from the underlying source and block until any bytes available. |
|
open fun open fun open fun open fun open fun open fun open fun open fun |
|
abstract fun readByte(): Byte
Read the next upcoming byte |
|
open fun |
|
open fun |
|
open fun open fun open fun open fun open fun open fun open fun open fun |
|
open fun |
|
open fun |
|
open fun |
|
open fun release(pool: ObjectPool<ChunkBuffer>): Unit |
|
fun reset(): Unit
Clear buffer's state: read/write positions, gaps and so on. Byte content is not cleaned-up. |
|
abstract fun tryPeek(): Int |
|
abstract fun writeByte(v: Byte): Unit |
|
open fun |
|
open fun |
|
open fun open fun open fun open fun open fun open fun open fun open fun |
|
open fun |
|
open fun |
|
open fun |
val Empty: IoBuffer
The empty buffer singleton: it has zero capacity for read and write. |
|
val EmptyPool: ObjectPool<IoBuffer>
A pool that always returns IoBuffer.Empty |
|
val NoPool: ObjectPool<IoBuffer>
Pool that always instantiates new buffers instead of reusing it |
|
val Pool: ObjectPool<IoBuffer>
The default buffer pool |
|
val ReservedSize: Int
Number of bytes usually reserved in the end of chunk when several instances of ChunkBuffer are connected into a chain (usually inside of ByteReadPacket or BytePacketBuilder) |
var Buffer. |
|
val Input.
For streaming input it should be Input.endOfInput instead. |
|
val Input.
For streaming input there is no reliable way to detect it without triggering bytes population from the underlying source. Consider using Input.endOfInput or use ByteReadPacket instead. |
fun Output. fun Output.afterHeadWrite(current: ChunkBuffer): Unit |
|
fun Buffer. fun Buffer. fun Buffer. fun Output.append(csq: CharSequence, start: Int = 0, end: Int = csq.length): Appendable |
|
fun Buffer.canRead(): Boolean |
|
fun Buffer.canWrite(): Boolean |
|
fun Input. fun Input.completeReadHead(current: ChunkBuffer): Unit |
|
fun Input.copyTo(output: Output): Long
Copy all bytes to the output. Depending on actual input and output implementation it could be zero-copy or copy byte per byte. All regular types such as ByteReadPacket, BytePacketBuilder, AbstractInput and AbstractOutput are always optimized so no bytes will be copied. |
|
fun IoBuffer. |
|
fun Input.discard(): Long
Discard all remaining bytes. |
|
fun Input.discardExact(n: Long): Unit fun Input.discardExact(n: Int): Unit
Discard exactly n bytes or fail if not enough bytes in the input to be discarded. |
|
fun Input.discardUntilDelimiter(delimiter: Byte): Long
Discards bytes until delimiter occurred |
|
fun Input.discardUntilDelimiters(delimiter1: Byte, delimiter2: Byte): Long
Discards bytes until of of the specified delimiters delimiter1 or delimiter2 occurred |
|
fun Buffer.fill(times: Int, value: Byte): Unit
Write byte value repeated the specified times. fun Buffer.fill(times: Int, value: <ERROR CLASS>): Unit
|
|
fun Buffer. |
|
fun Input.peekCharUtf8(): Char |
|
fun Input. fun Input.
Copy at least min but up to max bytes to the specified destination buffer from this input
skipping offset bytes. If there are not enough bytes available to provide min bytes then
it simply return number of available bytes with no exception so the returned value need
to be checked.
It is safe to specify |
|
fun Input.prepareReadFirstHead(minSize: Int): ChunkBuffer? |
|
fun Input. |
|
fun Input.prepareReadNextHead(current: ChunkBuffer): ChunkBuffer? |
|
fun Input. |
|
fun Output. fun Output.prepareWriteHead(capacity: Int, current: ChunkBuffer?): ChunkBuffer |
|
fun Buffer.
Push back n bytes: only possible if there were at least n bytes read before this operation. |
|
fun Buffer.read(block: (memory: Memory, start: Int, endExclusive: Int) -> Int): Int
Apply block of code with buffer's memory providing read range indices. The returned value of block lambda should return number of bytes to be marked as consumed. No read/write functions on this buffer should be called inside of block otherwise an undefined behaviour may occur including data damage. |
|
fun IoBuffer. fun Input. fun Input.readAvailable(destination: Memory, destinationOffset: Int, length: Int): Int fun Input.readAvailable(destination: Memory, destinationOffset: Long, length: Long): Long fun Buffer.readAvailable(destination: <ERROR CLASS>, offset: Int = 0, length: Int = destination.size - offset): Int
Read available for read bytes to the destination array range starting at array offset and length bytes. If less than length bytes available then less bytes will be copied and the corresponding number will be returned as result. |
|
fun Input.readAvailableLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Int fun Buffer.readAvailableLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Int |
|
fun Input. fun Input. fun Input. fun Input. fun Input. fun Input. |
|
fun Input.readBytes(): ByteArray
Reads all remaining bytes from the input |
|
fun Input.readBytesOf(min: Int = 0, max: Int = Int.MAX_VALUE): ByteArray
Reads at least min but no more than max bytes from the input to a new byte array |
|
fun Buffer.readDirect(block: (ByteBuffer) -> Unit): Int |
|
fun IoBuffer. fun Input.readDouble(byteOrder: ByteOrder): Double |
|
fun Input.readDoubleFallback(): Double |
|
fun IoBuffer. fun Input.readFloat(byteOrder: ByteOrder): Float |
|
fun Input.readFloatFallback(): Float |
|
fun IoBuffer. fun Buffer.readFully(dst: Array<Byte>, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input. fun Input.readFully(destination: Memory, destinationOffset: Int, length: Int): Unit fun Input.readFully(destination: Memory, destinationOffset: Long, length: Long): Unit fun Input.readFully(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFully(destination: <ERROR CLASS>, offset: Int = 0, length: Int = destination.size - offset): Unit
Read from this buffer to the destination array to offset and length bytes. fun Buffer.readFully(destination: ByteBuffer): Unit
Read buffer's content to the destination buffer moving it's position. |
|
fun Input.readFullyLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFullyLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit |
|
fun Input. fun Input. fun Input. fun Input. fun Input. fun Input. |
|
fun IoBuffer. fun Input.readInt(byteOrder: ByteOrder): Int |
|
fun IoBuffer. fun Input.readLong(byteOrder: ByteOrder): Long |
|
fun IoBuffer. fun Input.readShort(byteOrder: ByteOrder): Short |
|
fun Buffer. fun Input. fun Input.
Reads at most max characters decoding bytes with specified decoder. Extra character bytes will remain unconsumed fun Input.readText(out: Appendable, charset: Charset = Charsets.UTF_8, max: Int = Int.MAX_VALUE): Int
Reads at most max characters decoding bytes with specified charset. Extra character bytes will remain unconsumed |
|
fun Input.
Read exactly n characters interpreting bytes in the specified charset. |
|
fun Input.
Read exactly the specified number of bytes interpreting bytes in the specified charset (optional, UTF-8 by default). fun Input.readTextExactBytes(bytesCount: Int, charset: Charset = Charsets.UTF_8): String
Read exactly bytesCount interpreting bytes in the specified charset (optional, UTF-8 by default). |
|
fun Input.readTextExactCharacters(charactersCount: Int, charset: Charset = Charsets.UTF_8): String
Read exactly charactersCount characters interpreting bytes in the specified charset. |
|
fun IoBuffer. |
|
fun IoBuffer. |
|
fun IoBuffer. |
|
fun IoBuffer. |
|
fun Input.readUTF8Line(estimate: Int = 16, limit: Int = Int.MAX_VALUE): String?
Read a string line considering optionally specified estimate but up to optional limit characters length
(does fail once limit exceeded) or return |
|
fun Input.readUTF8LineTo(out: Appendable, limit: Int): Boolean
Read UTF-8 line and append all line characters to out except line endings. Does support CR, LF and CR+LF |
|
fun Input.readUTF8UntilDelimiter(delimiters: String, limit: Int = Int.MAX_VALUE): String
Reads UTF-8 characters until one of the specified delimiters found, limit exceeded or end of stream encountered |
|
fun Input.readUTF8UntilDelimiterTo(out: Appendable, delimiters: String, limit: Int = Int.MAX_VALUE): Int fun Input.readUTF8UntilDelimiterTo(out: Output, delimiters: String, limit: Int = Int.MAX_VALUE): Int
Reads UTF-8 characters to out buffer until one of the specified delimiters found, limit exceeded or end of stream encountered fun Input. |
|
fun Input.readUntilDelimiter(delimiter: Byte, dst: ByteArray, offset: Int = 0, length: Int = dst.size): Int
Copies to dst array at offset at most length bytes or until the specified delimiter occurred. fun Input.readUntilDelimiter(delimiter: Byte, dst: Output): Long
Copies to dst output until the specified delimiter occurred. |
|
fun Input.readUntilDelimiters(delimiter1: Byte, delimiter2: Byte, dst: ByteArray, offset: Int = 0, length: Int = dst.size): Int
Copies to dst array at offset at most length bytes or until one of the specified delimiters delimiter1 or delimiter2 occurred. fun Input.readUntilDelimiters(delimiter1: Byte, delimiter2: Byte, dst: Output): Long
Copies to dst output until one of the specified delimiters delimiter1 or delimiter2 occurred. |
|
fun IoBuffer.release(pool: ObjectPool<IoBuffer>): Unit
releases buffer view and returns it to the pool if there are no more usages. Based on simple ref-counting so it is very fragile. |
|
fun ChunkBuffer.remainingAll(): Long
Summarize remainings of all elements of the chain |
|
fun Input.takeWhile(block: (Buffer) -> Boolean): Unit
Invoke block function for every chunk until end of input or block function return |
|
fun Input.takeWhileSize(initialSize: Int = 1, block: (Buffer) -> Int): Unit
Invoke block function for every chunk until end of input or block function return zero block function returns number of bytes required to read next primitive and shouldn't require too many bytes at once otherwise it could fail with an exception. It is not guaranteed that every chunk will have fixed size but it will be always at least requested bytes length. block function should never release provided buffer and should not write to it otherwise an undefined behaviour could be observed |
|
fun Buffer.
Peek the next unsigned byte or return |
|
fun Buffer.write(block: (memory: Memory, start: Int, endExclusive: Int) -> Int): Int
Apply block of code with buffer's memory providing write range indices. The returned value of block lambda should return number of bytes were written. o read/write functions on this buffer should be called inside of block otherwise an undefined behaviour may occur including data damage. |
|
fun Buffer.writeDirect(size: Int = 1, block: (ByteBuffer) -> Unit): Int |
|
fun IoBuffer. fun Output.writeDouble(value: Double, byteOrder: ByteOrder): Unit |
|
fun IoBuffer. fun Output.writeFloat(value: Float, byteOrder: ByteOrder): Unit |
|
fun IoBuffer. fun Output. fun Output.writeFully(src: Memory, offset: Int, length: Int): Unit fun Output.writeFully(src: Memory, offset: Long, length: Long): Unit fun Output.writeFully(array: <ERROR CLASS>, offset: Int = 0, length: Int = array.size - offset): Unit fun Buffer.writeFully(source: <ERROR CLASS>, offset: Int = 0, length: Int = source.size - offset): Unit
Write the whole source array range staring at offset and having the specified bytes length. fun Buffer.writeFully(src: Buffer): Unit
Write all readable bytes from src to this buffer. Fails if not enough space available to write all bytes. |
|
fun Output.writeFullyLittleEndian(source: <ERROR CLASS>, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFullyLittleEndian(source: <ERROR CLASS>, offset: Int = 0, length: Int = source.size - offset): Unit |
|
fun IoBuffer. fun Output.writeInt(value: Int, byteOrder: ByteOrder): Unit |
|
fun IoBuffer. fun Output.writeLong(value: Long, byteOrder: ByteOrder): Unit |
|
fun Output.writePacket(packet: ByteReadPacket): Unit |
|
fun IoBuffer. fun Output.writeShort(value: Short, byteOrder: ByteOrder): Unit |
|
fun Output.
Writes text characters in range \[fromIndex .. toIndex) with the specified encoder fun Output.writeText(text: CharSequence, fromIndex: Int = 0, toIndex: Int = text.length, charset: Charset = Charsets.UTF_8): Unit fun Output.writeText(text: CharArray, fromIndex: Int = 0, toIndex: Int = text.size, charset: Charset = Charsets.UTF_8): Unit
Writes text characters in range \[fromIndex .. toIndex) with the specified charset |
|
fun IoBuffer. fun Output.writeUByte(v: <ERROR CLASS>): Unit fun Buffer.writeUByte(value: <ERROR CLASS>): Unit
Write an unsigned byte or fail if not enough space available for writing. |
|
fun IoBuffer. fun Output.writeUInt(v: <ERROR CLASS>): Unit fun Buffer.writeUInt(value: <ERROR CLASS>): Unit
Write an unsigned integer or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). |
|
fun IoBuffer. fun Output.writeULong(v: <ERROR CLASS>): Unit fun Buffer.writeULong(value: <ERROR CLASS>): Unit
Write an unsigned long integer or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). |
|
fun IoBuffer. fun Output.writeUShort(v: <ERROR CLASS>): Unit fun Buffer.writeUShort(value: <ERROR CLASS>): Unit
Write an unsigned short integer or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). |
|
fun Output.writeWhile(block: (Buffer) -> Boolean): Unit
Append number of chunks invoking block function while the returned value is true. Depending on the output underlying implementation it could invoke block function with the same buffer several times however it is guaranteed that it is always non-empty. |
|
fun Output.writeWhileSize(initialSize: Int = 1, block: (Buffer) -> Int): Unit
Append number of chunks invoking block function while the returned value is positive. If returned value is positive then it will be invoked again with a buffer having at least requested number of bytes space (could be the same buffer as before if it complies to the restriction). |