IoBuffer

expect class IoBuffer : Input, Output, ChunkBuffer

Deprecated: Use Memory, Input or Output instead.

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.

Constructors

<init>

IoBuffer(memory: Memory, origin: ChunkBuffer?)

IoBuffer(external: ByteBuffer)

Properties

byteOrder	`var byteOrder: ByteOrder`
endOfInput	`val endOfInput: Boolean` It is `true` when it is known that no more bytes will be available. When it is `false` then this means that it is not known yet or there are available bytes. Please note that `false` value doesn’t guarantee that there are available bytes so `readByte()` may fail.

Inherited Properties

endOfInput	`abstract val endOfInput: Boolean` It is `true` when it is known that no more bytes will be available. When it is `false` then this means that it is not known yet or there are available bytes. Please note that `false` value doesn’t guarantee that there are available bytes so `readByte()` may fail.
next	`var next: ChunkBuffer?` Reference to next buffer view. Useful to chain multiple views.
origin	`var origin: ChunkBuffer?` Reference to an origin buffer view this was copied from
referenceCount	`val referenceCount: Int`

Functions

append	`fun append( csq: CharSequence?, start: Int, end: Int ): Appendable` `fun append(csq: CharSequence?): Appendable` `fun append(csq: CharArray, start: Int, end: Int): Appendable` `fun append(c: Char): Appendable`
appendChars	`fun appendChars(csq: CharArray, start: Int, end: Int): Int` `fun appendChars(csq: CharSequence, start: Int, end: Int): Int`
canRead	`fun canRead(): Boolean`
canWrite	`fun canWrite(): Boolean`
close	`fun close(): Unit`
duplicate	`fun duplicate(): IoBuffer` Create a new Buffer instance pointing to the same memory and having the same positions.
fill	`fun fill(n: Long, v: Byte): Unit`
flush	`fun flush(): Unit`
getNext	`fun getNext(): IoBuffer?`
isExclusivelyOwned	`fun isExclusivelyOwned(): Boolean`
makeView	`fun makeView(): IoBuffer` Creates a new view to the same actual buffer with independent read and write positions and gaps
peekTo	`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 `max > destination.writeRemaining` but `min` shouldn’t be bigger than the destination free space. This function could trigger the underlying source reading that may lead to blocking I/O. It is safe to specify too big offset but only if `min = 0`, fails otherwise. This function usually copy more bytes than min (unless `max = min`). `fun peekTo(buffer: IoBuffer): Int` 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
pushBack	`fun pushBack(n: Int): Unit` Push back n bytes: only possible if there were at least n bytes read before this operation.
read	`fun read(dst: ByteBuffer, size: Int): Unit` `fun read(dst: ByteArray, offset: Int, length: Int): Unit`
readAvailable	`fun readAvailable( dst: ByteArray, offset: Int, length: Int ): Int` `fun readAvailable(dst: IoBuffer, length: Int): Int` `fun readAvailable( dst: ShortArray, offset: Int, length: Int ): Int` `fun readAvailable( dst: IntArray, offset: Int, length: Int ): Int` `fun readAvailable( dst: LongArray, offset: Int, length: Int ): Int` `fun readAvailable( dst: FloatArray, offset: Int, length: Int ): Int` `fun readAvailable( dst: DoubleArray, offset: Int, length: Int ): Int` `fun readAvailable(dst: ByteBuffer, length: Int): Int`
readDirect	`fun readDirect(block: (ByteBuffer) -> Unit): Int` Apply block function on a ByteBuffer of readable bytes. The block function should return number of consumed bytes.
readDouble	`fun readDouble(): Double`
readFloat	`fun readFloat(): Float`
readFully	`fun readFully(dst: ByteArray, offset: Int, length: Int): Unit` `fun readFully(dst: IoBuffer, length: Int): Unit` `fun readFully( dst: ShortArray, offset: Int, length: Int ): Unit` `fun readFully(dst: IntArray, offset: Int, length: Int): Unit` `fun readFully(dst: LongArray, offset: Int, length: Int): Unit` `fun readFully( dst: DoubleArray, offset: Int, length: Int ): Unit` `fun readFully( dst: FloatArray, offset: Int, length: Int ): Unit` `fun readFully(dst: ByteBuffer, length: Int): Unit`
readInt	`fun readInt(): Int`
readLong	`fun readLong(): Long`
readShort	`fun readShort(): Short`
readText	`fun readText( decoder: CharsetDecoder, out: Appendable, lastBuffer: Boolean, max: Int = Int.MAX_VALUE ): Int`
release	`fun release(pool: ObjectPool<IoBuffer>): Unit`
resetFromContentToWrite	`fun resetFromContentToWrite(child: ByteBuffer): Unit` Reset read/write position to original’s content pos/limit. May not work due to slicing.
setNext	`fun setNext(newNext: IoBuffer?): Unit`
toString	`fun toString(): String`
tryPeek	`fun tryPeek(): Int`
write	`fun write(src: ByteBuffer): Unit` `fun write(src: ByteArray, offset: Int, length: Int): Unit`
writeBuffer	`fun writeBuffer(src: IoBuffer, length: Int): Int`
writeDirect	`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.
writeDouble	`fun writeDouble(v: Double): Unit`
writeFloat	`fun writeFloat(v: Float): Unit`
writeFully	`fun writeFully( src: ByteArray, offset: Int, length: Int ): Unit` `fun writeFully( src: ShortArray, offset: Int, length: Int ): Unit` `fun writeFully(src: IntArray, offset: Int, length: Int): Unit` `fun writeFully( src: LongArray, offset: Int, length: Int ): Unit` `fun writeFully( src: FloatArray, offset: Int, length: Int ): Unit` `fun writeFully( src: DoubleArray, offset: Int, length: Int ): Unit` `fun writeFully(src: IoBuffer, length: Int): Unit` `fun writeFully(bb: ByteBuffer): Unit`
writeInt	`fun writeInt(v: Int): Unit`
writeLong	`fun writeLong(v: Long): Unit`
writeShort	`fun writeShort(v: Short): Unit`

Inherited Functions

append	`abstract fun append( csq: CharArray, start: Int, end: Int ): Appendable`
cleanNext	`fun cleanNext(): ChunkBuffer?`
discard	`abstract fun discard(n: Long): Long` Discard at most n bytes
duplicate	`open fun duplicate(): ChunkBuffer` Create a new Buffer instance pointing to the same memory and having the same positions.
fill	`open fun fill(n: Long, v: Byte): Unit`
peekTo	`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. `min` shouldn’t be bigger than the destination free space. This function could trigger the underlying source reading that may lead to blocking I/O. It is allowed to specify too big offset so in this case this function will always return `0` after prefetching all underlying bytes but note that it may lead to significant memory consumption. This function usually copy more bytes than min (unless `max = min`) but it is not guaranteed. When `0` is returned with `offset = 0` then it makes sense to check endOfInput. `open fun peekTo(buffer: IoBuffer): Int` 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.
readAvailable	`open fun readAvailable( dst: ByteArray, offset: Int, length: Int ): Int` `open fun readAvailable( dst: ShortArray, offset: Int, length: Int ): Int` `open fun readAvailable( dst: IntArray, offset: Int, length: Int ): Int` `open fun readAvailable( dst: LongArray, offset: Int, length: Int ): Int` `open fun readAvailable( dst: FloatArray, offset: Int, length: Int ): Int` `open fun readAvailable( dst: DoubleArray, offset: Int, length: Int ): Int` `open fun readAvailable(dst: IoBuffer, length: Int): Int` `open fun readAvailable( dst: ByteBuffer, length: Int = dst.remaining() ): Int`
readByte	`abstract fun readByte(): Byte` Read the next upcoming byte
readDouble	`open fun readDouble(): Double`
readFloat	`open fun readFloat(): Float`
readFully	`open fun readFully( dst: ByteArray, offset: Int, length: Int ): Unit` `open fun readFully( dst: ShortArray, offset: Int, length: Int ): Unit` `open fun readFully( dst: IntArray, offset: Int, length: Int ): Unit` `open fun readFully( dst: LongArray, offset: Int, length: Int ): Unit` `open fun readFully( dst: FloatArray, offset: Int, length: Int ): Unit` `open fun readFully( dst: DoubleArray, offset: Int, length: Int ): Unit` `open fun readFully(dst: IoBuffer, length: Int): Unit` `open fun readFully( dst: ByteBuffer, length: Int = dst.remaining() ): Unit`
readInt	`open fun readInt(): Int`
readLong	`open fun readLong(): Long`
readShort	`open fun readShort(): Short`
release	`open fun release(pool: ObjectPool<ChunkBuffer>): Unit`
reset	`fun reset(): Unit` Clear buffer’s state: read/write positions, gaps and so on. Byte content is not cleaned-up.
tryPeek	`abstract fun tryPeek(): Int`
writeByte	`abstract fun writeByte(v: Byte): Unit`
writeDouble	`open fun writeDouble(v: Double): Unit`
writeFloat	`open fun writeFloat(v: Float): Unit`
writeFully	`open fun writeFully( src: ByteArray, offset: Int, length: Int ): Unit` `open fun writeFully( src: ShortArray, offset: Int, length: Int ): Unit` `open fun writeFully( src: IntArray, offset: Int, length: Int ): Unit` `open fun writeFully( src: LongArray, offset: Int, length: Int ): Unit` `open fun writeFully( src: FloatArray, offset: Int, length: Int ): Unit` `open fun writeFully( src: DoubleArray, offset: Int, length: Int ): Unit` `open fun writeFully(src: IoBuffer, length: Int): Unit` `open fun writeFully(bb: ByteBuffer): Unit`
writeInt	`open fun writeInt(v: Int): Unit`
writeLong	`open fun writeLong(v: Long): Unit`
writeShort	`open fun writeShort(v: Short): Unit`

Companion Object Properties

Empty	`val Empty: IoBuffer` The empty buffer singleton: it has zero capacity for read and write.
EmptyPool	`val EmptyPool: ObjectPool<IoBuffer>` A pool that always returns IoBuffer.Empty
NoPool	`val NoPool: ObjectPool<IoBuffer>` Pool that always instantiates new buffers instead of reusing it
Pool	`val Pool: ObjectPool<IoBuffer>` The default buffer pool
ReservedSize	`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)

Extension Properties

byteOrder	`var Buffer.byteOrder: ByteOrder`
isEmpty	`val Input.isEmpty: Boolean` For streaming input it should be Input.endOfInput instead.
isNotEmpty	`val Input.isNotEmpty: Boolean` 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.

Extension Functions

afterHeadWrite	`fun Output.afterHeadWrite(current: IoBuffer): Unit` `fun Output.afterHeadWrite(current: ChunkBuffer): Unit`
append	`fun Buffer.append(c: Char): Buffer` `fun Buffer.append(csq: CharSequence?): Buffer` `fun Buffer.append( csq: CharSequence?, start: Int, end: Int ): Buffer` `fun Output.append( csq: CharSequence, start: Int = 0, end: Int = csq.length ): Appendable`
asStream	`fun Input.asStream(): InputStream` Convert io.ktor.utils.io Input to java InputStream
canRead	`fun Buffer.canRead(): Boolean`
canWrite	`fun Buffer.canWrite(): Boolean`
completeReadHead	`fun Input.completeReadHead(current: IoBuffer): Unit` `fun Input.completeReadHead(current: ChunkBuffer): Unit`
copyTo	`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.
decodeUTF8	`fun IoBuffer.decodeUTF8(consumer: (Char) -> Boolean): Int`
discard	`fun Input.discard(): Long` Discard all remaining bytes.
discardExact	`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.
discardUntilDelimiter	`fun Input.discardUntilDelimiter(delimiter: Byte): Long` Discards bytes until delimiter occurred
discardUntilDelimiters	`fun Input.discardUntilDelimiters( delimiter1: Byte, delimiter2: Byte ): Long` Discards bytes until of of the specified delimiters delimiter1 or delimiter2 occurred
fill	`fun Buffer.fill(times: Int, value: Byte): Unit` Write byte value repeated the specified times. `fun Buffer.fill(times: Int, value: <ERROR CLASS>): Unit` Write unsigned byte value repeated the specified times.
flush	`fun Buffer.flush(): Unit`
peekCharUtf8	`fun Input.peekCharUtf8(): Char`
peekTo	`fun Input.peekTo( destination: IoBuffer, offset: Int = 0, min: Int = 1, max: Int = Int.MAX_VALUE ): Int` `fun Input.peekTo( destination: Buffer, offset: Int = 0, min: Int = 1, max: Int = Int.MAX_VALUE ): Int` 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 `max > destination.writeRemaining` but `min` shouldn’t be bigger than the destination free space. This function could trigger the underlying source reading that may lead to blocking I/O. It is safe to specify too big offset so in this case this function will always return `0`. This function usually copy more bytes than min (unless `max = min`) but it is not guaranteed. When `0` is returned with `offset = 0` then it makes sense to check Input.endOfInput.
prepareReadFirstHead	`fun Input.prepareReadFirstHead(minSize: Int): ChunkBuffer?`
prepareReadFirstHeadOld	`fun Input.prepareReadFirstHeadOld(minSize: Int): IoBuffer?`
prepareReadNextHead	`fun Input.prepareReadNextHead( current: ChunkBuffer ): ChunkBuffer?`
prepareReadNextHeadOld	`fun Input.prepareReadNextHeadOld( current: IoBuffer ): IoBuffer?`
prepareWriteHead	`fun Output.prepareWriteHead( capacity: Int, current: IoBuffer? ): IoBuffer` `fun Output.prepareWriteHead( capacity: Int, current: ChunkBuffer? ): ChunkBuffer`
pushBack	`fun Buffer.pushBack(n: Int): Unit` Push back n bytes: only possible if there were at least n bytes read before this operation.
read	`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.
readAvailable	`fun IoBuffer.readAvailable( destination: ByteArray, offset: Int = 0, length: Int = destination.size - offset ): Int` `fun Input.readAvailable( dst: IoBuffer, size: Int = dst.writeRemaining ): Int` `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.
readAvailableLittleEndian	`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`
readAvailableOld	`fun Input.readAvailableOld( dst: ByteArray, offset: Int = 0, length: Int = dst.size - offset ): Int` `fun Input.readAvailableOld( dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset ): Int` `fun Input.readAvailableOld( dst: IntArray, offset: Int = 0, length: Int = dst.size - offset ): Int` `fun Input.readAvailableOld( dst: LongArray, offset: Int = 0, length: Int = dst.size - offset ): Int` `fun Input.readAvailableOld( dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset ): Int` `fun Input.readAvailableOld( dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset ): Int`
readBytes	`fun Input.readBytes(): ByteArray` Reads all remaining bytes from the input
readBytesOf	`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
readDirect	`fun Buffer.readDirect(block: (ByteBuffer) -> Unit): Int`
readDouble	`fun IoBuffer.readDouble(): Double` `fun Input.readDouble(byteOrder: ByteOrder): Double`
readDoubleFallback	`fun Input.readDoubleFallback(): Double`
readFloat	`fun IoBuffer.readFloat(): Float` `fun Input.readFloat(byteOrder: ByteOrder): Float`
readFloatFallback	`fun Input.readFloatFallback(): Float`
readFully	`fun IoBuffer.readFully( destination: ByteArray, offset: Int = 0, length: Int = destination.size - offset ): Unit` `fun Buffer.readFully( dst: Array<Byte>, offset: Int = 0, length: Int = dst.size - offset ): Unit` `fun Input.readFully( dst: IoBuffer, size: Int = dst.writeRemaining ): Unit` `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.
readFullyLittleEndian	`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`
readFullyOld	`fun Input.readFullyOld( dst: ByteArray, offset: Int = 0, length: Int = dst.size - offset ): Unit` `fun Input.readFullyOld( dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset ): Unit` `fun Input.readFullyOld( dst: IntArray, offset: Int = 0, length: Int = dst.size - offset ): Unit` `fun Input.readFullyOld( dst: LongArray, offset: Int = 0, length: Int = dst.size - offset ): Unit` `fun Input.readFullyOld( dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset ): Unit` `fun Input.readFullyOld( dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset ): Unit`
readInt	`fun IoBuffer.readInt(): Int` `fun Input.readInt(byteOrder: ByteOrder): Int`
readLong	`fun IoBuffer.readLong(): Long` `fun Input.readLong(byteOrder: ByteOrder): Long`
readShort	`fun IoBuffer.readShort(): Short` `fun Input.readShort(byteOrder: ByteOrder): Short`
readText	`fun Buffer.readText( decoder: CharsetDecoder, out: Appendable, lastBuffer: Boolean, max: Int = Int.MAX_VALUE ): Int` `fun Input.readText( out: Appendable, decoder: CharsetDecoder, max: Int = Int.MAX_VALUE ): Int` `fun Input.readText( decoder: CharsetDecoder, max: Int = Int.MAX_VALUE ): String` 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
readTextExact	`fun Input.readTextExact( charset: Charset = Charsets.UTF_8, n: Int ): String` Read exactly n characters interpreting bytes in the specified charset.
readTextExactBytes	`fun Input.readTextExactBytes( charset: Charset = Charsets.UTF_8, bytes: Int ): String` 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).
readTextExactCharacters	`fun Input.readTextExactCharacters( charactersCount: Int, charset: Charset = Charsets.UTF_8 ): String` Read exactly charactersCount characters interpreting bytes in the specified charset.
readUByte	`fun IoBuffer.readUByte(): <ERROR CLASS>`
readUInt	`fun IoBuffer.readUInt(): <ERROR CLASS>`
readULong	`fun IoBuffer.readULong(): <ERROR CLASS>`
readUShort	`fun IoBuffer.readUShort(): <ERROR CLASS>`
readUTF8Line	`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 `null` if the packet is empty
readUTF8LineTo	`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
readUTF8UntilDelimiter	`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
readUTF8UntilDelimiterTo	`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.readUTF8UntilDelimiterTo( out: BytePacketBuilderBase, delimiters: String, limit: Int = Int.MAX_VALUE ): Int`
readUntilDelimiter	`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.
readUntilDelimiters	`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.
release	`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.
remainingAll	`fun ChunkBuffer.remainingAll(): Long` Summarize remainings of all elements of the chain
takeWhile	`fun Input.takeWhile(block: (Buffer) -> Boolean): Unit` Invoke block function for every chunk until end of input or block function return `false` block function returns `true` to request more chunks or `false` to stop loop
takeWhileSize	`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
tryPeek	`fun Buffer.tryPeek(): Int` Peek the next unsigned byte or return `-1` if no more bytes available for reading. No bytes will be marked as consumed in any case.
write	`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.
writeDirect	`fun Buffer.writeDirect( size: Int = 1, block: (ByteBuffer) -> Unit ): Int`
writeDouble	`fun IoBuffer.writeDouble(value: Double): Unit` `fun Output.writeDouble( value: Double, byteOrder: ByteOrder ): Unit`
writeFloat	`fun IoBuffer.writeFloat(value: Float): Unit` `fun Output.writeFloat( value: Float, byteOrder: ByteOrder ): Unit`
writeFully	`fun IoBuffer.writeFully( source: ByteArray, offset: Int = 0, length: Int = source.size - offset ): Unit` `fun Output.writeFully( src: IoBuffer, length: Int = src.readRemaining ): Unit` `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.
writeFullyLittleEndian	`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`
writeInt	`fun IoBuffer.writeInt(value: Int): Unit` `fun Output.writeInt(value: Int, byteOrder: ByteOrder): Unit`
writeLong	`fun IoBuffer.writeLong(value: Long): Unit` `fun Output.writeLong(value: Long, byteOrder: ByteOrder): Unit`
writePacket	`fun Output.writePacket(packet: ByteReadPacket): Unit`
writeShort	`fun IoBuffer.writeShort(value: Short): Unit` `fun Output.writeShort( value: Short, byteOrder: ByteOrder ): Unit`
writeText	`fun Output.writeText( text: CharSequence, fromIndex: Int = 0, toIndex: Int = text.length, encoder: CharsetEncoder ): Unit` 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
writeUByte	`fun IoBuffer.writeUByte(value: <ERROR CLASS>): Unit` `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.
writeUInt	`fun IoBuffer.writeUInt(value: <ERROR CLASS>): Unit` `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).
writeULong	`fun IoBuffer.writeULong(value: <ERROR CLASS>): Unit` `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).
writeUShort	`fun IoBuffer.writeUShort(value: <ERROR CLASS>): Unit` `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).
writeWhile	`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.
writeWhileSize	`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).