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).