Output

expect interface Output : Appendable, Closeable

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

actual interface Output : Closeable, Appendable

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

actual interface Output : Closeable

Functions

append

expect abstract fun append(value: Char): Appendable

expect abstract fun append(value: CharSequence?): Appendable

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

expect abstract fun append(value: CharSequence?, startIndex: Int, endIndex: Int): Appendable

abstract fun append(p0: Char): Appendable

abstract fun append(p0: CharSequence): Appendable

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

abstract fun append(p0: CharSequence, p1: Int, p2: Int): Appendable

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

expect abstract override fun close()

actual abstract override fun close()

fill

~~expect~~ ~~open~~ ~~fun~~ ~~fill~~(n: Long, v: Byte)

~~actual~~ ~~open~~ ~~fun~~ ~~fill~~(n: Long, v: Byte)

flush

expect abstract fun flush()

actual abstract fun flush()

writeByte

expect abstract fun writeByte(v: Byte)

actual abstract fun writeByte(v: Byte)

writeDouble

~~expect~~ ~~open~~ ~~fun~~ ~~writeDouble~~(v: Double)

~~actual~~ ~~open~~ ~~fun~~ ~~writeDouble~~(v: Double)

writeFloat

~~expect~~ ~~open~~ ~~fun~~ ~~writeFloat~~(v: Float)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFloat~~(v: Float)

writeFully

~~expect~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: IoBuffer, ~~length~~: Int)

~~expect~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: ByteArray, ~~offset~~: Int, ~~length~~: Int)

~~expect~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: DoubleArray, ~~offset~~: Int, ~~length~~: Int)

~~expect~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: FloatArray, ~~offset~~: Int, ~~length~~: Int)

~~expect~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: IntArray, ~~offset~~: Int, ~~length~~: Int)

~~expect~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: LongArray, ~~offset~~: Int, ~~length~~: Int)

~~expect~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: ShortArray, ~~offset~~: Int, ~~length~~: Int)

~~open~~ ~~fun~~ ~~writeFully~~(bb: ByteBuffer)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: IoBuffer, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: ByteArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: DoubleArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: FloatArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: IntArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: LongArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: ShortArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: IoBuffer, ~~length~~: Int)

~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: <ERROR CLASS><<ERROR CLASS>>, ~~offset~~: Int, ~~length~~: Int)

~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: <ERROR CLASS><<ERROR CLASS>>, ~~offset~~: Long, ~~length~~: Long)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: ByteArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: DoubleArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: FloatArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: IntArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: LongArray, ~~offset~~: Int, ~~length~~: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeFully~~(~~src~~: ShortArray, ~~offset~~: Int, ~~length~~: Int)

writeInt

~~expect~~ ~~open~~ ~~fun~~ ~~writeInt~~(v: Int)

~~actual~~ ~~open~~ ~~fun~~ ~~writeInt~~(v: Int)

writeLong

~~expect~~ ~~open~~ ~~fun~~ ~~writeLong~~(v: Long)

~~actual~~ ~~open~~ ~~fun~~ ~~writeLong~~(v: Long)

writeShort

~~expect~~ ~~open~~ ~~fun~~ ~~writeShort~~(v: Short)

~~actual~~ ~~open~~ ~~fun~~ ~~writeShort~~(v: Short)

Properties

byteOrder

~~expect~~ ~~abstract~~ ~~var~~ ~~byteOrder~~: ByteOrder

~~actual~~ ~~abstract~~ ~~var~~ ~~byteOrder~~: ByteOrder

Inheritors

AbstractOutput

IoBuffer

Extensions

afterHeadWrite

~~fun~~ Output.~~afterHeadWrite~~(~~current~~: IoBuffer)

fun Output.afterHeadWrite(current: ChunkBuffer)

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)

prepareWriteHead

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

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

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~~: IoBuffer, ~~length~~: Int = ~~src.readRemaining~~)

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 Output.writeFully(bb: ByteBuffer)

fun Output.writeFully(src: <ERROR CLASS><<ERROR CLASS>>, offset: Int, length: Int)

fun Output.writeFully(src: <ERROR CLASS><<ERROR CLASS>>, 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)

writePacket

fun Output.writePacket(packet: ByteReadPacket)

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~~, ~~encoder~~: CharsetEncoder)

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)

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)

writeWhile

inline fun Output.writeWhile(block: (Buffer) -> Boolean)

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

inline fun Output.writeWhileSize(initialSize: Int = 1, block: (Buffer) -> Int)

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