ktor-io/io.ktor.utils.io.core/BytePacketBuilder

BytePacketBuilder

class BytePacketBuilder(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool) : Output

A builder that provides ability to build byte packets with no knowledge of it's size. Unlike Java's ByteArrayOutputStream it doesn't copy the whole content every time it's internal buffer overflows but chunks buffers instead. Packet building via build function is O(1) operation and only does instantiate a new ByteReadPacket. Once a byte packet has been built via build function call, the builder could be reused again. You also can discard all written bytes via reset or release. Please note that an instance of builder need to be terminated either via build function invocation or via release call otherwise it will cause byte buffer leak so that may have performance impact.

Byte packet builder is also an Appendable so it does append UTF-8 characters to a packet

buildPacket {
    listOf(1,2,3).joinTo(this, separator = ",")
}

Constructors

BytePacketBuilder

fun BytePacketBuilder(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool)

Functions

append

open override fun append(value: Char): BytePacketBuilder

Append single UTF-8 character

open override fun append(value: CharSequence?): BytePacketBuilder

open override fun append(value: CharSequence?, startIndex: Int, endIndex: Int): BytePacketBuilder

fun append(csq: CharArray, start: Int, end: Int): Appendable

build

fun build(): ByteReadPacket

Builds byte packet instance and resets builder's state to be able to build another one packet if needed

override fun close()

Should flush and close the destination

flush

fun flush()

release

fun release()

Release any resources that the builder holds. Builder shouldn't be used after release

toString

open override fun toString(): String

writeByte

fun writeByte(v: Byte)

writePacket

fun writePacket(packet: ByteReadPacket)

Writes another packet to the end. Please note that the instance packet gets consumed so you don't need to release it

fun writePacket(p: ByteReadPacket, n: Int)

fun writePacket(p: ByteReadPacket, n: Long)

Write exact n bytes from packet to the builder

Properties

isEmpty

val isEmpty: Boolean

If no bytes were written or the builder has been reset.

isNotEmpty

val isNotEmpty: Boolean

If at least one byte was written after the creation or the last reset.

size

val size: Int

Number of bytes written to the builder after the creation or the last reset.

Extensions

append

fun Output.append(csq: CharSequence, start: Int = 0, end: Int = csq.length): Appendable

fun Output.append(csq: CharArray, start: Int = 0, end: Int = csq.size): Appendable

fill

fun Output.fill(times: Long, value: Byte = 0)

outputStream

fun BytePacketBuilder.outputStream(): OutputStream

Creates OutputStream adapter to the builder

preview

inline fun <R> BytePacketBuilder.preview(block: (tmp: ByteReadPacket) -> R): R

Creates a temporary packet view of the packet being build without discarding any bytes from the builder. This is similar to build().copy() except that the builder keeps already written bytes untouched. A temporary view packet is passed as argument to block function and it shouldn't leak outside of this block otherwise an unexpected behaviour may occur.

reset

fun BytePacketBuilder.reset()

Discard all written bytes and prepare to build another packet.

writeByteBufferDirect

inline fun BytePacketBuilder.writeByteBufferDirect(size: Int, block: (ByteBuffer) -> Unit): Int

Write bytes directly to packet builder's segment. Generally shouldn't be used in user's code and useful for efficient integration.

writeDirect

inline fun BytePacketBuilder.writeDirect(size: Int, block: (ByteBuffer) -> Unit)

Write bytes directly to packet builder's segment. Generally shouldn't be used in user's code and useful for efficient integration.

writeDouble

fun Output.writeDouble(value: Double, byteOrder: ByteOrder)

fun Output.writeDouble(value: Double)

writeDoubleLittleEndian

fun Output.writeDoubleLittleEndian(value: Double)

writeFloat

fun Output.writeFloat(value: Float, byteOrder: ByteOrder)

fun Output.writeFloat(value: Float)

writeFloatLittleEndian

fun Output.writeFloatLittleEndian(value: Float)

writeFully

fun Output.writeFully(src: ByteArray, offset: Int = 0, length: Int = src.size - offset)

fun Output.writeFully(src: ShortArray, offset: Int = 0, length: Int = src.size - offset)

fun Output.writeFully(src: IntArray, offset: Int = 0, length: Int = src.size - offset)

fun Output.writeFully(src: LongArray, offset: Int = 0, length: Int = src.size - offset)

fun Output.writeFully(src: FloatArray, offset: Int = 0, length: Int = src.size - offset)

fun Output.writeFully(src: DoubleArray, offset: Int = 0, length: Int = src.size - offset)

fun Output.writeFully(src: Buffer, length: Int = src.readRemaining)

fun Output.writeFully(src: Memory, offset: Int, length: Int)

fun Output.writeFully(src: Memory, offset: Long, length: Long)

@ExperimentalUnsignedTypes

inline fun Output.writeFully(array: UByteArray, offset: Int = 0, length: Int = array.size - offset)

@ExperimentalUnsignedTypes

inline fun Output.writeFully(array: UShortArray, offset: Int = 0, length: Int = array.size - offset)

@ExperimentalUnsignedTypes

inline fun Output.writeFully(array: UIntArray, offset: Int = 0, length: Int = array.size - offset)

@ExperimentalUnsignedTypes

inline fun Output.writeFully(array: ULongArray, offset: Int = 0, length: Int = array.size - offset)

fun BytePacketBuilder.writeFully(src: ArrayBuffer, offset: Int = 0, length: Int = src.byteLength - offset)

Write exactly length bytes from the specified src array buffer

fun BytePacketBuilder.writeFully(src: Int8Array, offset: Int = 0, length: Int = src.length - offset)

Write exactly length bytes from the specified src typed array

fun Output.writeFully(bb: ByteBuffer)

fun BytePacketBuilder.writeFully(src: CPointer<ByteVar>, size: Int)

Write all remaining src buffer bytes and change its position accordingly

fun Output.writeFully(src: CPointer<ByteVar>, offset: Int, length: Int)

fun Output.writeFully(src: CPointer<ByteVar>, offset: Long, length: Long)

writeFullyLittleEndian

fun Output.writeFullyLittleEndian(source: UShortArray, offset: Int = 0, length: Int = source.size - offset)

fun Output.writeFullyLittleEndian(source: ShortArray, offset: Int = 0, length: Int = source.size - offset)

fun Output.writeFullyLittleEndian(source: UIntArray, offset: Int = 0, length: Int = source.size - offset)

fun Output.writeFullyLittleEndian(source: IntArray, offset: Int = 0, length: Int = source.size - offset)

fun Output.writeFullyLittleEndian(source: ULongArray, offset: Int = 0, length: Int = source.size - offset)

fun Output.writeFullyLittleEndian(source: LongArray, offset: Int = 0, length: Int = source.size - offset)

fun Output.writeFullyLittleEndian(source: FloatArray, offset: Int = 0, length: Int = source.size - offset)

fun Output.writeFullyLittleEndian(source: DoubleArray, offset: Int = 0, length: Int = source.size - offset)

writeInt

fun Output.writeInt(value: Int, byteOrder: ByteOrder)

fun Output.writeInt(value: Int)

writeIntLittleEndian

fun Output.writeIntLittleEndian(value: Int)

writeLong

fun Output.writeLong(value: Long, byteOrder: ByteOrder)

fun Output.writeLong(value: Long)

writeLongLittleEndian

fun Output.writeLongLittleEndian(value: Long)

writerUTF8

fun BytePacketBuilder.writerUTF8(): Writer

Creates Writer that encodes all characters in UTF-8 encoding

writeShort

fun Output.writeShort(value: Short, byteOrder: ByteOrder)

fun Output.writeShort(value: Short)

writeShortLittleEndian

fun Output.writeShortLittleEndian(value: Short)

writeText

fun Output.writeText(text: CharSequence, fromIndex: Int = 0, toIndex: Int = text.length, charset: Charset = Charsets.UTF_8)

fun Output.writeText(text: CharArray, fromIndex: Int = 0, toIndex: Int = text.size, charset: Charset = Charsets.UTF_8)

Writes text characters in range \[fromIndex .. toIndex) with the specified charset

writeUByte

@ExperimentalUnsignedTypes

inline fun Output.writeUByte(v: UByte)

writeUInt

@ExperimentalUnsignedTypes

inline fun Output.writeUInt(v: UInt)

writeULong

@ExperimentalUnsignedTypes

inline fun Output.writeULong(v: ULong)

writeUShort

@ExperimentalUnsignedTypes

inline fun Output.writeUShort(v: UShort)