Output

expect interface Output : Appendable, Closeable

This shouldn’t be implemented directly. Inherit AbstractOutput instead.

Properties

byteOrder

abstract var byteOrder: ByteOrder

Functions

append

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

close

abstract fun close(): Unit

fill

open fun fill(n: Long, v: Byte): Unit

flush

abstract fun flush(): Unit

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

Extension Functions

afterHeadWrite

fun Output.afterHeadWrite(current: IoBuffer): Unit
fun Output.afterHeadWrite(current: ChunkBuffer): Unit

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): Unit

prepareWriteHead

fun Output.prepareWriteHead(
    capacity: Int,
    current: IoBuffer?
): IoBuffer
fun Output.prepareWriteHead(
    capacity: Int,
    current: ChunkBuffer?
): ChunkBuffer

use

fun <O : Output, R> O.use(block: (O) -> R): R

writeDouble

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

writeDoubleLittleEndian

fun Output.writeDoubleLittleEndian(value: Double): Unit

writeFloat

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

writeFloatLittleEndian

fun Output.writeFloatLittleEndian(value: Float): Unit

writeFully

fun Output.writeFully(
    src: ByteArray,
    offset: Int = 0,
    length: Int = src.size - offset
): Unit
fun Output.writeFully(
    src: ShortArray,
    offset: Int = 0,
    length: Int = src.size - offset
): Unit
fun Output.writeFully(
    src: IntArray,
    offset: Int = 0,
    length: Int = src.size - offset
): Unit
fun Output.writeFully(
    src: LongArray,
    offset: Int = 0,
    length: Int = src.size - offset
): Unit
fun Output.writeFully(
    src: FloatArray,
    offset: Int = 0,
    length: Int = src.size - offset
): Unit
fun Output.writeFully(
    src: DoubleArray,
    offset: Int = 0,
    length: Int = src.size - offset
): Unit
fun Output.writeFully(
    src: IoBuffer,
    length: Int = src.readRemaining
): Unit
fun Output.writeFully(
    src: Buffer,
    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 Output.writeFully(bb: ByteBuffer): Unit

writeFullyLittleEndian

fun Output.writeFullyLittleEndian(
    source: <ERROR CLASS>,
    offset: Int = 0,
    length: Int = source.size - offset
): Unit
fun Output.writeFullyLittleEndian(
    source: ShortArray,
    offset: Int = 0,
    length: Int = source.size - offset
): Unit
fun Output.writeFullyLittleEndian(
    source: IntArray,
    offset: Int = 0,
    length: Int = source.size - offset
): Unit
fun Output.writeFullyLittleEndian(
    source: LongArray,
    offset: Int = 0,
    length: Int = source.size - offset
): Unit
fun Output.writeFullyLittleEndian(
    source: FloatArray,
    offset: Int = 0,
    length: Int = source.size - offset
): Unit
fun Output.writeFullyLittleEndian(
    source: DoubleArray,
    offset: Int = 0,
    length: Int = source.size - offset
): Unit

writeInt

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

writeIntLittleEndian

fun Output.writeIntLittleEndian(value: Int): Unit

writeLong

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

writeLongLittleEndian

fun Output.writeLongLittleEndian(value: Long): Unit

writePacket

fun Output.writePacket(packet: ByteReadPacket): Unit

writeShort

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

writeShortLittleEndian

fun Output.writeShortLittleEndian(value: Short): 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 Output.writeUByte(v: <ERROR CLASS>): Unit

writeUInt

fun Output.writeUInt(v: <ERROR CLASS>): Unit

writeULong

fun Output.writeULong(v: <ERROR CLASS>): Unit

writeUShort

fun Output.writeUShort(v: <ERROR CLASS>): Unit

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

Inheritors

AbstractOutput

abstract class AbstractOutput : Appendable, Output

The default Output implementation.

IoBuffer

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.