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.

remaining

val Source.remaining: Long

size

val Sink.size: Int

Functions

append

fun Sink.append(value: CharSequence, startIndex: Int = 0, endIndex: Int = value.length)

build

fun Sink.build(): Source

buildPacket

inline fun buildPacket(block: Sink.() -> Unit): Source

Build a byte packet in block lambda. Creates a temporary builder and releases it in case of failure

BytePacketBuilder

fun BytePacketBuilder(): Sink

ByteReadPacket

fun ByteReadPacket(array: ByteArray, offset: Int = 0, length: Int = array.size): Source

fun ByteReadPacket(byteBuffer: ByteBuffer): Source

canRead

fun Buffer.canRead(): Boolean

copy

fun Source.copy(): Source

copyTo

fun Source.~~copyTo~~(output: Sink): 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, Input and Output are always optimized so no bytes will be copied.

discard

fun Source.discard(count: Long = Long.MAX_VALUE): Long

preview

fun <T> Sink.preview(function: (Source) -> T): T

fun <T> Source.preview(function: (Source) -> T): T

read

fun Source.read(block: (ByteBuffer) -> Unit)

readAvailable

fun Source.readAvailable(out: Buffer): Int

fun Input.readAvailable(buffer: ByteArray, offset: Int = 0, length: Int = buffer.size - offset): Int

fun Source.readAvailable(buffer: ByteBuffer): Int

readBytes

fun Source.~~readBytes~~(): 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 Buffer.readBytes(count: Int = size.toInt()): ByteArray

Read the specified number of bytes specified (optional, read all remaining by default)

fun Source.~~readBytes~~(count: Int): ByteArray

readFully

fun Source.readFully(out: ByteArray, offset: Int = 0, length: Int = out.size - offset)

fun Source.readFully(buffer: ByteBuffer)

readShortLittleEndian

fun Source.readShortLittleEndian(): Short

readText

fun Source.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

readTextExact

fun Source.~~readTextExact~~(charset: Charset = Charsets.UTF_8, n: Int): String

Read exactly n characters interpreting bytes in the specified charset.

readTextExactCharacters

fun Source.readTextExactCharacters(charactersCount: Int, charset: Charset = Charsets.UTF_8): String

Read exactly charactersCount characters interpreting bytes in the specified charset.

release

fun Source.~~release~~()

Sink

fun ~~Sink~~(): Buffer

fun ~~Sink~~(pool: ObjectPool<*>): Buffer

storeIntAt

fun ByteArray.storeIntAt(index: Int, value: Int)

String

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.

takeWhile

fun Source.takeWhile(block: (Buffer) -> Boolean)

toByteArray

fun String.toByteArray(charset: Charset = Charsets.UTF_8): ByteArray

use

inline fun <T : Closeable?, R> T.use(block: (T) -> R): R

withMemory

fun <T> withMemory(size: Int, block: (ByteArray) -> T): T

write

fun Sink.write(block: (buffer: CPointer<ByteVar>, offset: Long, length: Long) -> Long): Long

writeByteBuffer

fun Buffer.~~writeByteBuffer~~(source: ByteBuffer)

Write source buffer content moving its position.

fun Sink.writeByteBuffer(bb: ByteBuffer)

writeFully

fun Sink.writeFully(buffer: ByteArray, offset: Int = 0, length: Int = buffer.size - offset)

fun Sink.writeFully(buffer: ByteBuffer)

fun Sink.writeFully(buffer: CPointer<ByteVar>, offset: Long, length: Long)

writePacket

fun Sink.writePacket(packet: Source)

writeText

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

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

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