abstract class AbstractInput : Input
The default abstract base class implementing Input interface. |
|
abstract class AbstractOutput : Appendable, Output
The default Output implementation. |
|
open class Buffer
Represents a buffer with read and write positions. |
|
enum expect class ByteOrder |
|
class BytePacketBuilder : BytePacketBuilderPlatformBase
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. |
|
abstract class |
|
abstract class |
|
class ByteReadPacket : ByteReadPacketPlatformBase, Input
Read-only immutable byte packet. Could be consumed only once however it does support copy that doesn't copy every byte but creates a new view instead. Once packet created it should be either completely read (consumed) or released via release. |
|
abstract class |
|
abstract class |
|
expect interface Closeable |
|
expect interface Input : Closeable
Usually shouldn't be implemented directly. Inherit AbstractInput instead. |
|
expect class
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. |
|
expect interface Output : Appendable, Closeable
This shouldn't be implemented directly. Inherit AbstractOutput instead. |
annotation class ExperimentalIoApi
API marked with this annotation is experimental and could be changed |
class BufferLimitExceededException : Exception |
|
expect class EOFException : IOException |
|
class InsufficientSpaceException : Exception |
expect val PACKET_MAX_COPY_SIZE: Int |
|
var Buffer. |
|
val Input.
For streaming input it should be Input.endOfInput instead. val ByteReadPacket.isEmpty: Boolean |
|
val Input.
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. val ByteReadPacket.isNotEmpty: Boolean |
expect fun BytePacketBuilder(headerSizeHint: Int = 0): BytePacketBuilder |
|
expect fun ByteReadPacket(array: ByteArray, offset: Int = 0, length: Int = array.size, block: (ByteArray) -> Unit): ByteReadPacket fun ByteReadPacket(array: ByteArray, offset: Int = 0, length: Int = array.size): ByteReadPacket fun ByteReadPacket(bb: ByteBuffer, release: (ByteBuffer) -> Unit = {}): ByteReadPacket |
|
expect fun String(bytes: ByteArray, offset: Int = 0, length: Int = bytes.size, charset: Charset = Charsets.UTF_8): String
Create an instance of String from the specified bytes range starting at offset and bytes length interpreting characters in the specified charset. |
|
fun Buffer. fun Buffer. fun Buffer. fun Buffer. 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 |
|
fun buildPacket(headerSizeHint: Int = 0, block: BytePacketBuilder.() -> Unit): ByteReadPacket
Build a byte packet in block lambda. Creates a temporary builder and releases it in case of failure |
|
fun Buffer.canRead(): Boolean |
|
fun Buffer.canWrite(): Boolean |
|
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. |
|
fun Input.discard(): Long
Discard all remaining bytes. |
|
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. |
|
fun Input.discardUntilDelimiter(delimiter: Byte): Long
Discards bytes until delimiter occurred |
|
fun Input.discardUntilDelimiters(delimiter1: Byte, delimiter2: Byte): Long
Discards bytes until of of the specified delimiters delimiter1 or delimiter2 occurred |
|
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. fun Buffer.
Write byte v value repeated n times. fun Output.fill(times: Long, value: Byte = 0): Unit |
|
fun Buffer. |
|
fun Buffer.forEach(block: (Byte) -> Unit): Unit
For every byte from this buffer invokes block function giving it as parameter. fun Input.forEach(block: (Byte) -> Unit): Unit
For every byte from this input invokes block function giving it as parameter. |
|
fun Buffer. fun ChunkBuffer. |
|
fun Input.peekCharUtf8(): Char |
|
fun Input. fun Input.
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 |
|
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 |
|
fun Buffer.
Push back n bytes: only possible if there were at least n bytes read before this operation. |
|
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. |
|
fun Buffer.readAvailable(destination: ByteArray, offset: Int = 0, length: Int = destination.size - offset): Int 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. fun IoBuffer. fun Input. fun Input.readAvailable(dst: ByteArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: Buffer, length: 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 Input.readAvailable(dst: ByteBuffer, length: Int = dst.remaining()): Int fun Buffer.readAvailable(dst: ByteBuffer, length: Int = dst.remaining()): Int fun Buffer.readAvailable(destination: ShortArray, offset: Int = 0, length: Int = destination.size - offset): Int fun Buffer.readAvailable(destination: IntArray, offset: Int = 0, length: Int = destination.size - offset): Int fun Buffer.readAvailable(destination: LongArray, offset: Int = 0, length: Int = destination.size - offset): Int fun Buffer.readAvailable(destination: FloatArray, offset: Int = 0, length: Int = destination.size - offset): Int fun Buffer.readAvailable(destination: DoubleArray, 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 elements. If less than length elements available then less elements will be copied and the corresponding number will be returned as result (possibly zero). fun Buffer.readAvailable(dst: Buffer, length: Int = dst.writeRemaining): Int
Read at most length available bytes to the dst buffer or fun ByteReadPacket.readAvailable(dst: ByteBuffer): Int
Read at most |
|
fun Input.readAvailableLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Buffer.readAvailableLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Int fun Buffer.readAvailableLittleEndian(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Buffer.readAvailableLittleEndian(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Buffer.readAvailableLittleEndian(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Buffer.readAvailableLittleEndian(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Buffer.readAvailableLittleEndian(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Int |
|
fun Input. fun Input. fun Input. fun Input. fun Input. fun Input. |
|
fun ByteReadPacket.readByteBuffer(n: Int = remaining.coerceAtMostMaxIntOrFail("Unable to make a ByteBuffer: packet is too big"), direct: Boolean = false): ByteBuffer
Read exactly n (optional, read all remaining by default) bytes to a newly allocated byte buffer |
|
fun Buffer.readBytes(count: Int = readRemaining): ByteArray
Read the specified number of bytes specified (optional, read all remaining by default) fun ByteReadPacket.readBytes(n: Int = remaining.coerceAtMostMaxIntOrFail("Unable to convert to a ByteArray: packet is too big")): ByteArray
Read exactly n bytes (consumes all remaining if n is not specified but up to Int.MAX_VALUE bytes). Does fail if not enough bytes remaining. fun Input.readBytes(n: Int): ByteArray
Reads exactly n bytes from the input or fails if not enough bytes available. fun Input.readBytes(): ByteArray
Reads all remaining bytes from the input |
|
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 |
|
fun ByteReadPacket.readDirect(size: Int, block: (ByteBuffer) -> Unit): Unit fun AbstractInput. fun ByteReadPacketBase. fun Buffer.readDirect(block: (ByteBuffer) -> Unit): Int |
|
fun Buffer.readDouble(): Double
Read a floating point number or fail if not enough bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readDouble(byteOrder: ByteOrder): Double fun Input.readDouble(): Double |
|
fun Input.readDoubleFallback(): Double |
|
fun Input.readDoubleLittleEndian(): Double fun Buffer.readDoubleLittleEndian(): Double |
|
fun Buffer.readFloat(): Float
Read a floating point number or fail if not enough bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readFloat(byteOrder: ByteOrder): Float fun Input.readFloat(): Float |
|
fun Input.readFloatFallback(): Float |
|
fun Input.readFloatLittleEndian(): Float fun Buffer.readFloatLittleEndian(): Float |
|
fun Buffer.readFully(dst: Array<Byte>, offset: Int = 0, length: Int = dst.size - offset): Unit fun IoBuffer. fun Input. fun Input.readFully(dst: ByteArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: Buffer, length: 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 Input.readFully(dst: ByteBuffer, length: Int = dst.remaining()): Unit fun Buffer.readFully(dst: ByteBuffer, length: Int): Unit fun Buffer.readFully(destination: ByteArray, offset: Int = 0, length: Int = destination.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: ShortArray, offset: Int = 0, length: Int = destination.size - offset): Unit fun Buffer.readFully(destination: IntArray, offset: Int = 0, length: Int = destination.size - offset): Unit fun Buffer.readFully(destination: LongArray, offset: Int = 0, length: Int = destination.size - offset): Unit fun Buffer.readFully(destination: FloatArray, offset: Int = 0, length: Int = destination.size - offset): Unit fun Buffer.readFully(destination: DoubleArray, offset: Int = 0, length: Int = destination.size - offset): Unit
Read from this buffer to the destination array to offset and length bytes. Numeric values are interpreted in the network byte order (Big Endian). fun Buffer.readFully(dst: Buffer, length: Int = dst.writeRemaining): Int
Read at most length bytes from this buffer to the dst buffer. fun Buffer.readFully(destination: ByteBuffer): Unit
Read buffer's content to the destination buffer moving it's position. fun ByteReadPacket.readFully(dst: ByteBuffer): Int
Read exactly |
|
fun Input.readFullyLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFullyLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFullyLittleEndian(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFullyLittleEndian(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFullyLittleEndian(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFullyLittleEndian(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Buffer.readFullyLittleEndian(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Unit |
|
fun Input. fun Input. fun Input. fun Input. fun Input. fun Input. |
|
fun Buffer.readInt(): Int
Read an integer or fail if not enough bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readInt(byteOrder: ByteOrder): Int fun Input.readInt(): Int |
|
fun Input.readIntLittleEndian(): Int fun Buffer.readIntLittleEndian(): Int |
|
fun Buffer.readLong(): Long
Read a long integer or fail if not enough bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readLong(byteOrder: ByteOrder): Long fun Input.readLong(): Long |
|
fun Input.readLongLittleEndian(): Long fun Buffer.readLongLittleEndian(): Long |
|
fun Buffer.readShort(): Short
Read a short integer or fail if no bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readShort(byteOrder: ByteOrder): Short fun Input.readShort(): Short |
|
fun Input.readShortLittleEndian(): Short fun Buffer.readShortLittleEndian(): Short |
|
fun Buffer. fun ByteReadPacket. fun Input. fun Input.
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 fun Input.readText(charset: Charset = Charsets.UTF_8, max: Int = Int.MAX_VALUE): String fun Buffer.readText(charset: Charset = Charsets.UTF_8, max: Int = Int.MAX_VALUE): String
Reads at most max characters decoding bytes with specified charset. Extra character bytes will remain unconsumed |
|
fun Input.
Read exactly n characters interpreting bytes in the specified charset. |
|
fun Input.
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). |
|
fun Input.readTextExactCharacters(charactersCount: Int, charset: Charset = Charsets.UTF_8): String
Read exactly charactersCount characters interpreting bytes in the specified charset. |
|
fun Buffer.readUByte(): <ERROR CLASS>
Read an unsigned byte or fail if no bytes available for reading. fun IoBuffer. fun Input.readUByte(): <ERROR CLASS> |
|
fun Buffer.readUInt(): <ERROR CLASS>
Read an unsigned integer or fail if not enough bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readUInt(): <ERROR CLASS> |
|
fun Buffer.readULong(): <ERROR CLASS>
Read an unsigned long integer or fail if not enough bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readULong(): <ERROR CLASS> |
|
fun Buffer.readUShort(): <ERROR CLASS>
Read an unsigned short integer or fail if not enough bytes available for reading. The numeric value is decoded in the network order (Big Endian). fun IoBuffer. fun Input.readUShort(): <ERROR CLASS> |
|
fun ByteReadPacket.readUTF8Line(estimate: Int = 16, limit: Int = Int.MAX_VALUE): String? 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 |
|
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 |
|
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 |
|
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. |
|
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. |
|
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. |
|
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. |
|
fun ChunkBuffer.remainingAll(): Long
Summarize remainings of all elements of the chain fun |
|
fun BytePacketBuilder.reset(): Unit
Discard all written bytes and prepare to build another packet. |
|
fun Input.takeWhile(block: (Buffer) -> Boolean): Unit
Invoke block function for every chunk until end of input or block function return |
|
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 |
|
fun Buffer.
Peek the next unsigned byte or return |
|
fun <C, R> C.use(block: (C) -> R): R fun <I : Input, R> I.use(block: (I) -> R): R fun <O : Output, R> O.use(block: (O) -> R): R |
|
fun <R> withBuffer(size: Int, block: Buffer.() -> R): R
Invoke block function with a temporary Buffer instance of the specified size in bytes. The provided instance shouldn't be captured and used outside of the block otherwise an undefined behaviour may occur including crash and/or data corruption. fun <R> withBuffer(pool: ObjectPool<Buffer>, block: Buffer.() -> R): R
Invoke block function with a temporary Buffer instance taken from the specified pool. Depending on the pool it may be safe or unsafe to capture and use the provided buffer outside of the block. Usually it is always recommended to NOT capture an instance outside. |
|
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. |
|
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. |
|
fun BytePacketBuilder.writeDirect(size: Int, block: (ByteBuffer) -> Unit): Unit
Write bytes directly to packet builder's segment. Generally shouldn't be used in user's code and useful for efficient integration. fun Buffer.writeDirect(size: Int = 1, block: (ByteBuffer) -> Unit): Int |
|
fun Buffer.writeDouble(value: Double): Unit
Write a floating point number or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). fun IoBuffer. fun Output.writeDouble(value: Double, byteOrder: ByteOrder): Unit fun Output.writeDouble(value: Double): Unit |
|
fun Output.writeDoubleLittleEndian(value: Double): Unit fun Buffer.writeDoubleLittleEndian(value: Double): Unit |
|
fun Buffer.writeFloat(value: Float): Unit
Write a floating point number or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). fun IoBuffer. fun Output.writeFloat(value: Float, byteOrder: ByteOrder): Unit fun Output.writeFloat(value: Float): Unit |
|
fun Output.writeFloatLittleEndian(value: Float): Unit fun Buffer.writeFloatLittleEndian(value: Float): Unit |
|
fun Buffer.writeFully(source: ByteArray, offset: Int = 0, length: Int = source.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 IoBuffer. 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. 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 fun Buffer.writeFully(source: ShortArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFully(source: IntArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFully(source: LongArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFully(source: FloatArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFully(source: DoubleArray, offset: Int = 0, length: Int = source.size - offset): Unit
Write the whole source array range staring at offset and having the specified items length. Numeric values are interpreted in the network byte order (Big Endian). 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. fun Buffer.writeFully(src: Buffer, length: Int): Unit
Write at most length readable bytes from src to this buffer. Fails if not enough space available to write all bytes. fun Buffer.writeFully(source: ByteBuffer): Unit
Write source buffer content moving it's position. fun BytePacketBuilder.
Write all src buffer remaining bytes and change it's position accordingly |
|
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 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 fun Buffer.writeFullyLittleEndian(source: ShortArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFullyLittleEndian(source: IntArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFullyLittleEndian(source: LongArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFullyLittleEndian(source: FloatArray, offset: Int = 0, length: Int = source.size - offset): Unit fun Buffer.writeFullyLittleEndian(source: DoubleArray, offset: Int = 0, length: Int = source.size - offset): Unit |
|
fun Buffer.writeInt(value: Int): Unit
Write an integer or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). fun IoBuffer. fun Output.writeInt(value: Int, byteOrder: ByteOrder): Unit fun Output.writeInt(value: Int): Unit |
|
fun Output.writeIntLittleEndian(value: Int): Unit fun Buffer.writeIntLittleEndian(value: Int): Unit |
|
fun Buffer.writeLong(value: Long): Unit
Write a long integer or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). fun IoBuffer. fun Output.writeLong(value: Long, byteOrder: ByteOrder): Unit fun Output.writeLong(value: Long): Unit |
|
fun Output.writeLongLittleEndian(value: Long): Unit fun Buffer.writeLongLittleEndian(value: Long): Unit |
|
fun Output.writePacket(packet: ByteReadPacket): Unit |
|
fun Buffer.writeShort(value: Short): Unit
Write a short integer or fail if not enough space available for writing. The numeric value is encoded in the network order (Big Endian). fun IoBuffer. fun Output.writeShort(value: Short, byteOrder: ByteOrder): Unit fun Output.writeShort(value: Short): Unit |
|
fun Output.writeShortLittleEndian(value: Short): Unit fun Buffer.writeShortLittleEndian(value: Short): Unit |
|
fun Output.
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 |
|
fun Buffer.writeUByte(value: <ERROR CLASS>): Unit
Write an unsigned byte or fail if not enough space available for writing. fun IoBuffer. fun Output.writeUByte(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). fun IoBuffer. fun Output.writeUInt(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). fun IoBuffer. fun Output.writeULong(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). fun IoBuffer. fun Output.writeUShort(v: <ERROR CLASS>): Unit |
|
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. |
|
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). |