ktor-io

alltypes

open class Buffer

Buffer(memory: Memory)
val Empty: Buffer
const val ReservedSize: Int
var attachment: Any?
val capacity: Int
fun commitWritten(count: Int): Unit
fun discard(count: Int): Int
fun discard(count: Long): Long
fun discardExact(count: Int = readRemaining): Unit
open fun duplicate(): Buffer
protected open fun duplicateTo(copy: Buffer): Unit
inline val endGap: Int
var limit: Int
val memory: Memory
fun readByte(): Byte
var readPosition: Int
inline val readRemaining: Int
fun reserveEndGap(endGap: Int): Unit
fun reserveStartGap(startGap: Int): Unit
open fun reset(): Unit
fun resetForRead(): Unit
fun resetForWrite(): Unit
fun resetForWrite(limit: Int): Unit
fun rewind(count: Int = readPosition - startGap): Unit
var startGap: Int
open fun toString(): String
fun tryPeekByte(): Int
fun tryReadByte(): Int
fun writeByte(value: Byte): Unit
var writePosition: Int
inline val writeRemaining: Int

class BufferLimitExceededException : Exception

BufferLimitExceededException(message: String)

class ByteBufferPool : DefaultPool<ByteBuffer>

ByteBufferPool(capacity: Int = DEFAULT_POOL_CAPACITY, bufferSize: Int = DEFAULT_BUFFER_SIZE)
val bufferSize: Int
protected fun clearInstance(instance: ByteBuffer): ByteBuffer
protected fun produceInstance(): ByteBuffer
protected fun validateInstance(instance: ByteBuffer): Unit

interface ByteChannel : ByteReadChannel, ByteWriteChannel

abstract fun attachJob(job: Job): Unit

abstract class ByteChannelSequentialBase : ByteChannel, ByteReadChannel, ByteWriteChannel, SuspendableReadSession, HasReadSession, HasWriteSession

ByteChannelSequentialBase(initial: ChunkBuffer, autoFlush: Boolean)
ByteChannelSequentialBase(initial: ChunkBuffer, autoFlush: Boolean, pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool)
protected fun afterRead(): Unit
protected fun afterRead(count: Int): Unit
protected fun afterWrite(): Unit
protected fun afterWrite(count: Int): Unit
open val autoFlush: Boolean
open val availableForRead: Int
open val availableForWrite: Int
open suspend fun await(atLeast: Int): Boolean
open suspend fun awaitFreeSpace(): Unit
protected suspend fun awaitSuspend(atLeast: Int): Boolean
open fun beginWriteSession(): WriterSuspendSession
open fun cancel(cause: Throwable?): Boolean
open fun close(cause: Throwable?): Boolean
protected var closed: Boolean
var closedCause: Throwable?
open fun discard(n: Int): Int
open suspend fun discard(max: Long): Long
open fun endReadSession(): Unit
open fun endWriteSession(written: Int): Unit
open fun flush(): Unit
open val isClosedForRead: Boolean
open val isClosedForWrite: Boolean
suspend fun peekTo(destination: Memory, destinationOffset: Long, offset: Long, min: Long, max: Long): Long
protected fun prepareFlushedBytes(): Unit
open suspend fun readAvailable(dst: ChunkBuffer): Int
open suspend fun readAvailable(dst: ByteArray, offset: Int, length: Int): Int
protected fun readAvailableClosed(): Int
open suspend fun readBoolean(): Boolean
open suspend fun readByte(): Byte
open suspend fun readDouble(): Double
open suspend fun readFloat(): Float
open suspend fun readFully(dst: ChunkBuffer, n: Int): Unit
open suspend fun readFully(dst: ByteArray, offset: Int, length: Int): Unit
open suspend fun readInt(): Int
open suspend fun readLong(): Long
open suspend fun readPacket(size: Int, headerSizeHint: Int): ByteReadPacket
open suspend fun readRemaining(limit: Long, headerSizeHint: Int): ByteReadPacket
open fun readSession(consumer: ReadSession.() -> Unit): Unit
open suspend fun readShort(): Short
open suspend fun readSuspendableSession(consumer: suspend SuspendableReadSession.() -> Unit): Unit
open suspend fun readUTF8Line(limit: Int): String?
open suspend fun <A : Appendable> readUTF8LineTo(out: A, limit: Int): Boolean
protected val readable: ByteReadPacket
open fun request(atLeast: Int): ChunkBuffer?
open fun startReadSession(): SuspendableReadSession
open val totalBytesRead: Long
open val totalBytesWritten: Long
protected val writable: BytePacketBuilder
open suspend fun writeAvailable(src: ChunkBuffer): Int
open suspend fun writeAvailable(src: ByteArray, offset: Int, length: Int): Int
open suspend fun writeByte(b: Byte): Unit
open suspend fun writeDouble(d: Double): Unit
open suspend fun writeFloat(f: Float): Unit
open suspend fun writeFully(src: Buffer): Unit
open suspend fun writeFully(src: ByteArray, offset: Int, length: Int): Unit
open suspend fun writeFully(memory: Memory, startIndex: Int, endIndex: Int): Unit
open suspend fun writeInt(i: Int): Unit
open suspend fun writeLong(l: Long): Unit
open suspend fun writePacket(packet: ByteReadPacket): Unit
open suspend fun writeShort(s: Short): Unit
open suspend fun writeSuspendSession(visitor: suspend WriterSuspendSession.() -> Unit): Unit

class ByteChannelSequentialJVM : ByteChannelSequentialBase

ByteChannelSequentialJVM(initial: ChunkBuffer, autoFlush: Boolean)
fun attachJob(job: Job): Unit
suspend fun awaitContent(): Unit
suspend fun consumeEachBufferRange(visitor: ConsumeEachBufferVisitor): Unit
fun <R> lookAhead(visitor: LookAheadSession.() -> R): R
suspend fun <R> lookAheadSuspend(visitor: suspend LookAheadSuspendSession.() -> R): R
suspend fun read(min: Int, consumer: (ByteBuffer) -> Unit): Unit
suspend fun readAvailable(dst: ByteBuffer): Int
fun readAvailable(min: Int, block: (ByteBuffer) -> Unit): Int
suspend fun readFully(dst: ByteBuffer): Int
suspend fun write(min: Int, block: (ByteBuffer) -> Unit): Unit
suspend fun writeAvailable(src: ByteBuffer): Int
fun writeAvailable(min: Int, block: (ByteBuffer) -> Unit): Int
suspend fun writeFully(src: ByteBuffer): Unit
suspend fun writeWhile(block: (ByteBuffer) -> Boolean): Unit

enum expect class ByteOrder

BIG_ENDIAN
LITTLE_ENDIAN
fun nativeOrder(): ByteOrder
val nioOrder: ByteOrder
fun of(nioOrder: ByteOrder): ByteOrder

class BytePacketBuilder : Output

BytePacketBuilder(headerSizeHint: Int = 0, pool: ObjectPool<ChunkBuffer>)
fun append(c: Char): BytePacketBuilder
fun append(csq: CharSequence?): BytePacketBuilder
fun append(csq: CharSequence?, start: Int, end: Int): BytePacketBuilder
fun build(): ByteReadPacket
protected fun closeDestination(): Unit
protected fun flush(source: Memory, offset: Int, length: Int): Unit
val isEmpty: Boolean
val isNotEmpty: Boolean
val size: Int
fun toString(): String

expect interface ByteReadChannel

val Empty: ByteReadChannel
abstract val availableForRead: Int
abstract suspend fun awaitContent(): Unit
abstract fun cancel(cause: Throwable?): Boolean
open suspend fun consumeEachBufferRange(visitor: ConsumeEachBufferVisitor): Unit
abstract suspend fun discard(max: Long): Long
abstract val isClosedForRead: Boolean
abstract val isClosedForWrite: Boolean
abstract fun <R> lookAhead(visitor: LookAheadSession.() -> R): R
abstract suspend fun <R> lookAheadSuspend(visitor: suspend LookAheadSuspendSession.() -> R): R
abstract suspend fun peekTo(destination: Memory, destinationOffset: Long, offset: Long = 0, min: Long = 1, max: Long = Long.MAX_VALUE): Long
abstract suspend fun read(min: Int = 1, consumer: (ByteBuffer) -> Unit): Unit
abstract suspend fun readAvailable(dst: ByteArray, offset: Int, length: Int): Int
abstract suspend fun readAvailable(dst: ChunkBuffer): Int
abstract fun readAvailable(min: Int = 1, block: (ByteBuffer) -> Unit): Int
abstract suspend fun readAvailable(dst: ByteBuffer): Int
abstract suspend fun readBoolean(): Boolean
abstract suspend fun readByte(): Byte
abstract suspend fun readDouble(): Double
abstract suspend fun readFloat(): Float
abstract suspend fun readFully(dst: ByteArray, offset: Int, length: Int): Unit
abstract suspend fun readFully(dst: ChunkBuffer, n: Int): Unit
abstract suspend fun readFully(dst: ByteBuffer): Int
abstract suspend fun readInt(): Int
abstract suspend fun readLong(): Long
abstract suspend fun readPacket(size: Int, headerSizeHint: Int): ByteReadPacket
abstract suspend fun readRemaining(limit: Long, headerSizeHint: Int): ByteReadPacket
abstract fun readSession(consumer: ReadSession.() -> Unit): Unit
abstract suspend fun readShort(): Short
abstract suspend fun readSuspendableSession(consumer: suspend SuspendableReadSession.() -> Unit): Unit
abstract suspend fun readUTF8Line(limit: Int): String?
abstract suspend fun <A : Appendable> readUTF8LineTo(out: A, limit: Int): Boolean
abstract val totalBytesRead: Long

class ByteReadPacket : Input

ByteReadPacket(head: ChunkBuffer, pool: ObjectPool<ChunkBuffer>)
val Empty: ByteReadPacket
protected fun closeSource(): Unit
fun copy(): ByteReadPacket
protected fun fill(): ChunkBuffer?
protected fun fill(destination: Memory, offset: Int, length: Int): Int
fun toString(): String

expect interface ByteWriteChannel

abstract val autoFlush: Boolean
abstract val availableForWrite: Int
abstract suspend fun awaitFreeSpace(): Unit
abstract fun close(cause: Throwable?): Boolean
abstract val closedCause: Throwable?
abstract fun flush(): Unit
abstract val isClosedForWrite: Boolean
abstract val totalBytesWritten: Long
abstract suspend fun write(min: Int = 1, block: (ByteBuffer) -> Unit): Unit
abstract suspend fun writeAvailable(src: ByteArray, offset: Int, length: Int): Int
abstract suspend fun writeAvailable(src: ChunkBuffer): Int
abstract suspend fun writeAvailable(src: ByteBuffer): Int
abstract fun writeAvailable(min: Int = 1, block: (ByteBuffer) -> Unit): Int
abstract suspend fun writeByte(b: Byte): Unit
abstract suspend fun writeDouble(d: Double): Unit
abstract suspend fun writeFloat(f: Float): Unit
abstract suspend fun writeFully(src: ByteArray, offset: Int, length: Int): Unit
abstract suspend fun writeFully(src: Buffer): Unit
abstract suspend fun writeFully(memory: Memory, startIndex: Int, endIndex: Int): Unit
abstract suspend fun writeFully(src: ByteBuffer): Unit
abstract suspend fun writeInt(i: Int): Unit
abstract suspend fun writeLong(l: Long): Unit
abstract suspend fun writePacket(packet: ByteReadPacket): Unit
abstract suspend fun writeShort(s: Short): Unit
abstract suspend fun writeSuspendSession(visitor: suspend WriterSuspendSession.() -> Unit): Unit
abstract suspend fun writeWhile(block: (ByteBuffer) -> Boolean): Unit

typealias CancellationException = <ERROR CLASS>
expect object Charsets

val ISO_8859_1: Charset
val UTF_8: Charset

open class ChunkBuffer : Buffer

val Empty: ChunkBuffer
val EmptyPool: ObjectPool<ChunkBuffer>
val Pool: ObjectPool<ChunkBuffer>
fun cleanNext(): ChunkBuffer?
open fun duplicate(): ChunkBuffer
var next: ChunkBuffer?
var origin: ChunkBuffer?
val referenceCount: Int
open fun release(pool: ObjectPool<ChunkBuffer>): Unit
fun reset(): Unit

expect interface Closeable

abstract fun close(): Unit

class ClosedWriteChannelException

ClosedWriteChannelException(message: String?)

typealias ConsumeEachBufferVisitor = (buffer: ByteBuffer, last: Boolean) -> Boolean
annotation class DangerousInternalIoApi

DangerousInternalIoApi()

abstract expect class DefaultPool<T : Any> : ObjectPool<T>

DefaultPool(capacity: Int)
fun borrow(): T
val capacity: Int
protected open fun clearInstance(instance: T): T
fun dispose(): Unit
protected open fun disposeInstance(instance: T): Unit
protected abstract fun produceInstance(): T
fun recycle(instance: T): Unit
protected open fun validateInstance(instance: T): Unit

class DirectByteBufferPool : DefaultPool<ByteBuffer>

DirectByteBufferPool(capacity: Int = DEFAULT_POOL_CAPACITY, bufferSize: Int = DEFAULT_BUFFER_SIZE)
val bufferSize: Int
protected fun clearInstance(instance: ByteBuffer): ByteBuffer
protected fun produceInstance(): ByteBuffer
protected fun validateInstance(instance: ByteBuffer): Unit

expect class EOFException : IOException

EOFException(message: String)

open expect class EOFException : IOException

EOFException(message: String)

annotation class ExperimentalIoApi

ExperimentalIoApi()

open expect class IOException : Exception

IOException(message: String)
IOException(message: String, cause: Throwable?)

abstract class Input : Closeable

Input(head: ChunkBuffer = ChunkBuffer.Empty, remaining: Long = head.remainingAll(), pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool)
fun canRead(): Boolean
open fun close(): Unit
protected abstract fun closeSource(): Unit
fun discard(n: Int): Int
fun discard(n: Long): Long
fun discardExact(n: Int): Unit
val endOfInput: Boolean
fun ensureNextHead(current: ChunkBuffer): ChunkBuffer?
protected abstract fun fill(destination: Memory, offset: Int, length: Int): Int
protected open fun fill(): ChunkBuffer?
fun fixGapAfterRead(current: ChunkBuffer): Unit
fun hasBytes(n: Int): Boolean
protected fun markNoMoreChunksAvailable(): Unit
fun peekTo(destination: Memory, destinationOffset: Long, offset: Long = 0, min: Long = 1, max: Long = Long.MAX_VALUE): Long
fun peekTo(buffer: ChunkBuffer): Int
val pool: ObjectPool<ChunkBuffer>
fun prepareReadHead(minSize: Int): ChunkBuffer?
fun readByte(): Byte
fun readText(out: Appendable, min: Int = 0, max: Int = Int.MAX_VALUE): Int
fun readText(min: Int = 0, max: Int = Int.MAX_VALUE): String
fun readTextExact(out: Appendable, exactCharacters: Int): Unit
fun readTextExact(exactCharacters: Int): String
fun release(): Unit
val remaining: Long
fun tryPeek(): Int
fun updateHeadRemaining(remaining: Int): Unit

class InsufficientSpaceException : Exception

InsufficientSpaceException(size: Int, availableSpace: Int)
InsufficientSpaceException(name: String, size: Int, availableSpace: Int)
InsufficientSpaceException(size: Long, availableSpace: Long)
InsufficientSpaceException(message: String = "Not enough free space")

interface LookAheadSession

abstract fun consumed(n: Int): Unit
abstract fun request(skip: Int, atLeast: Int): ByteBuffer?

interface LookAheadSuspendSession : LookAheadSession

abstract suspend fun awaitAtLeast(n: Int): Boolean

open expect class MalformedInputException : Throwable

MalformedInputException(message: String)
open val message: String?

class MalformedUTF8InputException : Exception

MalformedUTF8InputException(message: String)

expect class Memory

Memory(buffer: ByteBuffer)
val Empty: Memory
val buffer: ByteBuffer
fun copyTo(destination: Memory, offset: Int, length: Int, destinationOffset: Int): Unit
fun copyTo(destination: Memory, offset: Long, length: Long, destinationOffset: Long): Unit
inline fun loadAt(index: Int): Byte
inline fun loadAt(index: Long): Byte
val size: Long
val size32: Int
fun slice(offset: Int, length: Int): Memory
fun slice(offset: Long, length: Long): Memory
inline fun storeAt(index: Int, value: Byte): Unit
inline fun storeAt(index: Long, value: Byte): Unit

abstract class NoPoolImpl<T : Any> : ObjectPool<T>

NoPoolImpl()
open val capacity: Int
open fun dispose(): Unit
open fun recycle(instance: T): Unit

interface ObjectPool<T : Any> : Closeable

abstract fun borrow(): T
abstract val capacity: Int
open fun close(): Unit
abstract fun dispose(): Unit
abstract fun recycle(instance: T): Unit

abstract class Output : Appendable, Closeable

Output(pool: ObjectPool<ChunkBuffer>)
Output()
protected val _size: Int
fun afterHeadWrite(): Unit
open fun append(value: Char): Output
open fun append(value: CharSequence?): Output
open fun append(value: CharSequence?, startIndex: Int, endIndex: Int): Output
fun append(csq: CharArray, start: Int, end: Int): Appendable
fun close(): Unit
protected abstract fun closeDestination(): Unit
protected abstract fun flush(source: Memory, offset: Int, length: Int): Unit
fun flush(): Unit
protected val pool: ObjectPool<ChunkBuffer>
fun prepareWriteHead(n: Int): ChunkBuffer
fun release(): Unit
fun writeByte(v: Byte): Unit
fun writePacket(packet: ByteReadPacket): Unit
fun writePacket(p: ByteReadPacket, n: Int): Unit
fun writePacket(p: ByteReadPacket, n: Long): Unit

interface ReadSession

abstract val availableForRead: Int
abstract fun discard(n: Int): Int
abstract fun request(atLeast: Int = 1): ChunkBuffer?

interface ReaderJob : Job

abstract val channel: ByteWriteChannel

interface ReaderScope : CoroutineScope

abstract val channel: ByteReadChannel

abstract class SingleInstancePool<T : Any> : ObjectPool<T>

SingleInstancePool()
fun borrow(): T
val capacity: Int
fun dispose(): Unit
protected abstract fun disposeInstance(instance: T): Unit
protected abstract fun produceInstance(): T
fun recycle(instance: T): Unit

interface SuspendableReadSession : ReadSession

abstract suspend fun await(atLeast: Int = 1): Boolean

class TooLongLineException : MalformedInputException

TooLongLineException(message: String)

interface WriterJob : Job

abstract val channel: ByteReadChannel

interface WriterScope : CoroutineScope

abstract val channel: ByteWriteChannel

interface WriterSession

abstract fun flush(): Unit
abstract fun request(min: Int): ChunkBuffer?
abstract fun written(n: Int): Unit

interface WriterSuspendSession : WriterSession

abstract suspend fun tryAwait(n: Int): Unit

java.io.InputStream

suspend fun InputStream.copyTo(channel: ByteWriteChannel, limit: Long = Long.MAX_VALUE): Long
fun InputStream.toByteReadChannel(context: <ERROR CLASS> = Dispatchers.IO, pool: ObjectPool<ByteBuffer>): ByteReadChannel
@JvmName("toByteReadChannelWithArrayPool") fun InputStream.toByteReadChannel(context: <ERROR CLASS> = Dispatchers.IO, pool: ObjectPool<ByteArray> = ByteArrayPool): ByteReadChannel

java.io.InputStream

fun InputStream.asInput(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool): Input
fun InputStream.readPacketAtLeast(n: Long): ByteReadPacket
fun InputStream.readPacketAtMost(n: Long): ByteReadPacket
fun InputStream.readPacketExact(n: Long): ByteReadPacket

java.io.OutputStream

fun OutputStream.asOutput(): Output
fun OutputStream.writePacket(builder: BytePacketBuilder.() -> Unit): Unit
fun OutputStream.writePacket(packet: ByteReadPacket): Unit

java.nio.ByteBuffer

fun ByteBuffer.copyTo(destination: Memory, offset: Int): Unit

java.nio.ByteBuffer

fun ByteBuffer.decodeUTF(out: CharArray, offset: Int, length: Int): Long
fun ByteBuffer.decodeUTF8Line(out: CharArray, offset: Int = 0, length: Int = out.size): Long

java.nio.channels.Pipe

suspend fun Pipe.copyTo(ch: ByteWriteChannel, limit: Long = Long.MAX_VALUE): Long

java.nio.channels.ReadableByteChannel

suspend fun ReadableByteChannel.copyTo(ch: ByteWriteChannel, limit: Long = Long.MAX_VALUE): Long

java.nio.channels.ReadableByteChannel

fun ReadableByteChannel.asInput(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool): Input
fun ReadableByteChannel.read(buffer: Buffer): Int
fun ReadableByteChannel.read(destination: Memory, destinationOffset: Int = 0, maxLength: Int = destination.size32 - destinationOffset): Int
fun ReadableByteChannel.readPacketAtLeast(n: Long): ByteReadPacket
fun ReadableByteChannel.readPacketAtMost(n: Long): ByteReadPacket
fun ReadableByteChannel.readPacketExact(n: Long): ByteReadPacket

java.nio.channels.WritableByteChannel

fun WritableByteChannel.asOutput(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool): Output
fun WritableByteChannel.write(buffer: Buffer): Int
fun WritableByteChannel.write(source: Memory, sourceOffset: Int = 0, maxLength: Int = source.size32 - sourceOffset): Int
fun WritableByteChannel.writePacket(builder: BytePacketBuilder.() -> Unit): ByteReadPacket?
fun WritableByteChannel.writePacket(p: ByteReadPacket): Boolean

java.nio.charset.Charset

expect val Charset.name: String

java.nio.charset.CharsetDecoder

expect val CharsetDecoder.charset: Charset
fun CharsetDecoder.decode(input: Input, max: Int = Int.MAX_VALUE): String
expect fun CharsetDecoder.decode(input: Input, dst: Appendable, max: Int): Int
expect fun CharsetDecoder.decodeExactBytes(input: Input, inputLength: Int): String

java.nio.charset.CharsetEncoder

expect val CharsetEncoder.charset: Charset
fun CharsetEncoder.encode(input: CharSequence, fromIndex: Int, toIndex: Int, dst: Output): Unit
fun CharsetEncoder.encode(input: CharSequence, fromIndex: Int = 0, toIndex: Int = input.length): ByteReadPacket
fun CharsetEncoder.encode(input: CharArray, fromIndex: Int, toIndex: Int, dst: Output): Unit
expect fun CharsetEncoder.encodeToByteArray(input: CharSequence, fromIndex: Int = 0, toIndex: Int = input.length): ByteArray
fun CharsetEncoder.encodeToByteArrayImpl(input: CharSequence, fromIndex: Int = 0, toIndex: Int = input.length): ByteArray
expect fun CharsetEncoder.encodeUTF8(input: ByteReadPacket, dst: Output): Unit
fun CharsetEncoder.encodeUTF8(input: ByteReadPacket): ByteReadPacket

kotlin.Any

expect fun Any.makeShared(): Unit
expect fun Any.preventFreeze(): Unit

kotlin.ByteArray

expect fun <R> ByteArray.useMemory(offset: Int = 0, length: Int, block: (Memory) -> R): R

kotlin.Double

expect fun Double.reverseByteOrder(): Double

kotlin.Float

expect fun Float.reverseByteOrder(): Float

kotlin.Int

inline val Int.highShort: Short
inline val Int.lowShort: Short
expect fun Int.reverseByteOrder(): Int

kotlin.Long

inline val Long.highInt: Int
inline val Long.lowInt: Int
expect fun Long.reverseByteOrder(): Long

kotlin.Short

inline val Short.highByte: Byte
inline val Short.lowByte: Byte
expect fun Short.reverseByteOrder(): Short

kotlin.String

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

kotlin.Throwable

expect fun Throwable.printStack(): Unit

kotlinx.coroutines.CoroutineScope

fun CoroutineScope.reader(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, channel: ByteChannel, block: suspend ReaderScope.() -> Unit): ReaderJob
fun CoroutineScope.reader(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, autoFlush: Boolean = false, block: suspend ReaderScope.() -> Unit): ReaderJob
fun CoroutineScope.writer(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, channel: ByteChannel, block: suspend WriterScope.() -> Unit): WriterJob
fun CoroutineScope.writer(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, autoFlush: Boolean = false, block: suspend WriterScope.() -> Unit): WriterJob

package io.ktor.utils.io

interface ByteChannel : ByteReadChannel, ByteWriteChannel

abstract fun attachJob(job: Job): Unit

expect fun ByteChannel(autoFlush: Boolean = false): ByteChannel
fun ByteChannel(autoFlush: Boolean = false, exceptionMapper: (Throwable?) -> Throwable?): ByteChannel
abstract class ByteChannelSequentialBase : ByteChannel, ByteReadChannel, ByteWriteChannel, SuspendableReadSession, HasReadSession, HasWriteSession

ByteChannelSequentialBase(initial: ChunkBuffer, autoFlush: Boolean)
ByteChannelSequentialBase(initial: ChunkBuffer, autoFlush: Boolean, pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool)
protected fun afterRead(): Unit
protected fun afterRead(count: Int): Unit
protected fun afterWrite(): Unit
protected fun afterWrite(count: Int): Unit
open val autoFlush: Boolean
open val availableForRead: Int
open val availableForWrite: Int
open suspend fun await(atLeast: Int): Boolean
open suspend fun awaitFreeSpace(): Unit
protected suspend fun awaitSuspend(atLeast: Int): Boolean
open fun beginWriteSession(): WriterSuspendSession
open fun cancel(cause: Throwable?): Boolean
open fun close(cause: Throwable?): Boolean
protected var closed: Boolean
var closedCause: Throwable?
open fun discard(n: Int): Int
open suspend fun discard(max: Long): Long
open fun endReadSession(): Unit
open fun endWriteSession(written: Int): Unit
open fun flush(): Unit
open val isClosedForRead: Boolean
open val isClosedForWrite: Boolean
suspend fun peekTo(destination: Memory, destinationOffset: Long, offset: Long, min: Long, max: Long): Long
protected fun prepareFlushedBytes(): Unit
open suspend fun readAvailable(dst: ChunkBuffer): Int
open suspend fun readAvailable(dst: ByteArray, offset: Int, length: Int): Int
protected fun readAvailableClosed(): Int
open suspend fun readBoolean(): Boolean
open suspend fun readByte(): Byte
open suspend fun readDouble(): Double
open suspend fun readFloat(): Float
open suspend fun readFully(dst: ChunkBuffer, n: Int): Unit
open suspend fun readFully(dst: ByteArray, offset: Int, length: Int): Unit
open suspend fun readInt(): Int
open suspend fun readLong(): Long
open suspend fun readPacket(size: Int, headerSizeHint: Int): ByteReadPacket
open suspend fun readRemaining(limit: Long, headerSizeHint: Int): ByteReadPacket
open fun readSession(consumer: ReadSession.() -> Unit): Unit
open suspend fun readShort(): Short
open suspend fun readSuspendableSession(consumer: suspend SuspendableReadSession.() -> Unit): Unit
open suspend fun readUTF8Line(limit: Int): String?
open suspend fun <A : Appendable> readUTF8LineTo(out: A, limit: Int): Boolean
protected val readable: ByteReadPacket
open fun request(atLeast: Int): ChunkBuffer?
open fun startReadSession(): SuspendableReadSession
open val totalBytesRead: Long
open val totalBytesWritten: Long
protected val writable: BytePacketBuilder
open suspend fun writeAvailable(src: ChunkBuffer): Int
open suspend fun writeAvailable(src: ByteArray, offset: Int, length: Int): Int
open suspend fun writeByte(b: Byte): Unit
open suspend fun writeDouble(d: Double): Unit
open suspend fun writeFloat(f: Float): Unit
open suspend fun writeFully(src: Buffer): Unit
open suspend fun writeFully(src: ByteArray, offset: Int, length: Int): Unit
open suspend fun writeFully(memory: Memory, startIndex: Int, endIndex: Int): Unit
open suspend fun writeInt(i: Int): Unit
open suspend fun writeLong(l: Long): Unit
open suspend fun writePacket(packet: ByteReadPacket): Unit
open suspend fun writeShort(s: Short): Unit
open suspend fun writeSuspendSession(visitor: suspend WriterSuspendSession.() -> Unit): Unit

class ByteChannelSequentialJVM : ByteChannelSequentialBase

ByteChannelSequentialJVM(initial: ChunkBuffer, autoFlush: Boolean)
fun attachJob(job: Job): Unit
suspend fun awaitContent(): Unit
suspend fun consumeEachBufferRange(visitor: ConsumeEachBufferVisitor): Unit
fun <R> lookAhead(visitor: LookAheadSession.() -> R): R
suspend fun <R> lookAheadSuspend(visitor: suspend LookAheadSuspendSession.() -> R): R
suspend fun read(min: Int, consumer: (ByteBuffer) -> Unit): Unit
suspend fun readAvailable(dst: ByteBuffer): Int
fun readAvailable(min: Int, block: (ByteBuffer) -> Unit): Int
suspend fun readFully(dst: ByteBuffer): Int
suspend fun write(min: Int, block: (ByteBuffer) -> Unit): Unit
suspend fun writeAvailable(src: ByteBuffer): Int
fun writeAvailable(min: Int, block: (ByteBuffer) -> Unit): Int
suspend fun writeFully(src: ByteBuffer): Unit
suspend fun writeWhile(block: (ByteBuffer) -> Boolean): Unit

fun ByteReadChannel(content: ByteArray): ByteReadChannel
fun ByteReadChannel(content: ByteArray, offset: Int): ByteReadChannel
expect fun ByteReadChannel(content: ByteArray, offset: Int, length: Int): ByteReadChannel
fun ByteReadChannel(text: String, charset: Charset = Charsets.UTF_8): ByteReadChannel
fun ByteReadChannel(content: ByteBuffer): ByteReadChannel
expect interface ByteReadChannel

val Empty: ByteReadChannel
abstract val availableForRead: Int
abstract suspend fun awaitContent(): Unit
abstract fun cancel(cause: Throwable?): Boolean
open suspend fun consumeEachBufferRange(visitor: ConsumeEachBufferVisitor): Unit
abstract suspend fun discard(max: Long): Long
abstract val isClosedForRead: Boolean
abstract val isClosedForWrite: Boolean
abstract fun <R> lookAhead(visitor: LookAheadSession.() -> R): R
abstract suspend fun <R> lookAheadSuspend(visitor: suspend LookAheadSuspendSession.() -> R): R
abstract suspend fun peekTo(destination: Memory, destinationOffset: Long, offset: Long = 0, min: Long = 1, max: Long = Long.MAX_VALUE): Long
abstract suspend fun read(min: Int = 1, consumer: (ByteBuffer) -> Unit): Unit
abstract suspend fun readAvailable(dst: ByteArray, offset: Int, length: Int): Int
abstract suspend fun readAvailable(dst: ChunkBuffer): Int
abstract fun readAvailable(min: Int = 1, block: (ByteBuffer) -> Unit): Int
abstract suspend fun readAvailable(dst: ByteBuffer): Int
abstract suspend fun readBoolean(): Boolean
abstract suspend fun readByte(): Byte
abstract suspend fun readDouble(): Double
abstract suspend fun readFloat(): Float
abstract suspend fun readFully(dst: ByteArray, offset: Int, length: Int): Unit
abstract suspend fun readFully(dst: ChunkBuffer, n: Int): Unit
abstract suspend fun readFully(dst: ByteBuffer): Int
abstract suspend fun readInt(): Int
abstract suspend fun readLong(): Long
abstract suspend fun readPacket(size: Int, headerSizeHint: Int): ByteReadPacket
abstract suspend fun readRemaining(limit: Long, headerSizeHint: Int): ByteReadPacket
abstract fun readSession(consumer: ReadSession.() -> Unit): Unit
abstract suspend fun readShort(): Short
abstract suspend fun readSuspendableSession(consumer: suspend SuspendableReadSession.() -> Unit): Unit
abstract suspend fun readUTF8Line(limit: Int): String?
abstract suspend fun <A : Appendable> readUTF8LineTo(out: A, limit: Int): Boolean
abstract val totalBytesRead: Long

expect interface ByteWriteChannel

abstract val autoFlush: Boolean
abstract val availableForWrite: Int
abstract suspend fun awaitFreeSpace(): Unit
abstract fun close(cause: Throwable?): Boolean
abstract val closedCause: Throwable?
abstract fun flush(): Unit
abstract val isClosedForWrite: Boolean
abstract val totalBytesWritten: Long
abstract suspend fun write(min: Int = 1, block: (ByteBuffer) -> Unit): Unit
abstract suspend fun writeAvailable(src: ByteArray, offset: Int, length: Int): Int
abstract suspend fun writeAvailable(src: ChunkBuffer): Int
abstract suspend fun writeAvailable(src: ByteBuffer): Int
abstract fun writeAvailable(min: Int = 1, block: (ByteBuffer) -> Unit): Int
abstract suspend fun writeByte(b: Byte): Unit
abstract suspend fun writeDouble(d: Double): Unit
abstract suspend fun writeFloat(f: Float): Unit
abstract suspend fun writeFully(src: ByteArray, offset: Int, length: Int): Unit
abstract suspend fun writeFully(src: Buffer): Unit
abstract suspend fun writeFully(memory: Memory, startIndex: Int, endIndex: Int): Unit
abstract suspend fun writeFully(src: ByteBuffer): Unit
abstract suspend fun writeInt(i: Int): Unit
abstract suspend fun writeLong(l: Long): Unit
abstract suspend fun writePacket(packet: ByteReadPacket): Unit
abstract suspend fun writeShort(s: Short): Unit
abstract suspend fun writeSuspendSession(visitor: suspend WriterSuspendSession.() -> Unit): Unit
abstract suspend fun writeWhile(block: (ByteBuffer) -> Boolean): Unit

typealias CancellationException = <ERROR CLASS>
class ClosedWriteChannelException

ClosedWriteChannelException(message: String?)

typealias ConsumeEachBufferVisitor = (buffer: ByteBuffer, last: Boolean) -> Boolean
val EmptyByteReadChannel: ByteReadChannel
interface LookAheadSession

abstract fun consumed(n: Int): Unit
abstract fun request(skip: Int, atLeast: Int): ByteBuffer?

interface LookAheadSuspendSession : LookAheadSession

abstract suspend fun awaitAtLeast(n: Int): Boolean

interface ReadSession

abstract val availableForRead: Int
abstract fun discard(n: Int): Int
abstract fun request(atLeast: Int = 1): ChunkBuffer?

interface ReaderJob : Job

abstract val channel: ByteWriteChannel

interface ReaderScope : CoroutineScope

abstract val channel: ByteReadChannel

interface SuspendableReadSession : ReadSession

abstract suspend fun await(atLeast: Int = 1): Boolean

interface WriterJob : Job

abstract val channel: ByteReadChannel

interface WriterScope : CoroutineScope

abstract val channel: ByteWriteChannel

interface WriterSession

abstract fun flush(): Unit
abstract fun request(min: Int): ChunkBuffer?
abstract fun written(n: Int): Unit

interface WriterSuspendSession : WriterSession

abstract suspend fun tryAwait(n: Int): Unit

fun ByteReadChannel.cancel(): Boolean
fun ByteWriteChannel.close(): Boolean
inline suspend fun ByteReadChannel.consumeEachBufferRange(visitor: ConsumeEachBufferVisitor): Unit
inline fun LookAheadSession.consumeEachRemaining(visitor: (ByteBuffer) -> Boolean): Unit
inline suspend fun LookAheadSuspendSession.consumeEachRemaining(visitor: suspend (ByteBuffer) -> Boolean): Unit
suspend fun ByteReadChannel.copyAndClose(dst: ByteWriteChannel, limit: Long = Long.MAX_VALUE): Long
suspend fun ByteChannelSequentialBase.copyTo(dst: ByteChannelSequentialBase, limit: Long = Long.MAX_VALUE): Long
suspend fun ByteReadChannel.copyTo(dst: ByteWriteChannel): Long
suspend expect fun ByteReadChannel.copyTo(dst: ByteWriteChannel, limit: Long): Long
suspend fun ByteReadChannel.discard(): Long
inline suspend fun ByteReadChannel.discardExact(n: Long): Unit
suspend fun ByteChannelSequentialBase.joinTo(dst: ByteChannelSequentialBase, closeOnEnd: Boolean): Unit
suspend expect fun ByteReadChannel.joinTo(dst: ByteWriteChannel, closeOnEnd: Boolean): Unit
kotlin.Any

expect fun Any.makeShared(): Unit
expect fun Any.preventFreeze(): Unit

kotlin.Throwable

expect fun Throwable.printStack(): Unit

kotlinx.coroutines.CoroutineScope

fun CoroutineScope.reader(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, channel: ByteChannel, block: suspend ReaderScope.() -> Unit): ReaderJob
fun CoroutineScope.reader(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, autoFlush: Boolean = false, block: suspend ReaderScope.() -> Unit): ReaderJob
fun CoroutineScope.writer(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, channel: ByteChannel, block: suspend WriterScope.() -> Unit): WriterJob
fun CoroutineScope.writer(coroutineContext: <ERROR CLASS> = EmptyCoroutineContext, autoFlush: Boolean = false, block: suspend WriterScope.() -> Unit): WriterJob

inline suspend fun ByteReadChannel.read(desiredSize: Int = 1, block: (source: Memory, start: Long, endExclusive: Long) -> Int): Int
suspend fun ByteReadChannel.readAvailable(dst: ByteArray): Int
inline suspend fun ByteReadChannel.readDouble(byteOrder: ByteOrder): Double
inline suspend fun ByteReadChannel.readDoubleLittleEndian(): Double
inline suspend fun ByteReadChannel.readFloat(byteOrder: ByteOrder): Float
inline suspend fun ByteReadChannel.readFloatLittleEndian(): Float
suspend fun ByteReadChannel.readFully(dst: ChunkBuffer): Unit
suspend fun ByteReadChannel.readFully(dst: ByteArray): Unit
inline suspend fun ByteReadChannel.readInt(byteOrder: ByteOrder): Int
inline suspend fun ByteReadChannel.readIntLittleEndian(): Int
inline suspend fun ByteReadChannel.readLong(byteOrder: ByteOrder): Long
inline suspend fun ByteReadChannel.readLongLittleEndian(): Long
suspend fun ByteReadChannel.readPacket(size: Int): ByteReadPacket
suspend fun ByteReadChannel.readRemaining(limit: Long): ByteReadPacket
suspend fun ByteReadChannel.readRemaining(): ByteReadPacket
inline suspend fun ByteReadChannel.readShort(byteOrder: ByteOrder): Short
inline suspend fun ByteReadChannel.readShortLittleEndian(): Short
suspend fun ByteReadChannel.readUTF8Line(): String?
suspend fun ByteReadChannel.readUTF8LineTo(out: Appendable): Boolean
suspend fun ByteReadChannel.readUntilDelimiter(delimiter: ByteBuffer, dst: ByteBuffer): Int
fun reader(coroutineContext: <ERROR CLASS>, channel: ByteChannel, parent: Job? = null, block: suspend ReaderScope.() -> Unit): ReaderJob
fun reader(coroutineContext: <ERROR CLASS>, autoFlush: Boolean = false, parent: Job? = null, block: suspend ReaderScope.() -> Unit): ReaderJob
suspend fun ByteReadChannel.skipDelimiter(delimiter: ByteBuffer): Unit
fun <E : Throwable> tryCopyException(exception: E, cause: Throwable): E?
inline suspend fun ByteWriteChannel.write(desiredSpace: Int = 1, block: (freeSpace: Memory, startOffset: Long, endExclusive: Long) -> Int): Int
suspend fun ByteWriteChannel.writeAvailable(src: ByteArray): Int
suspend fun ByteWriteChannel.writeBoolean(b: Boolean): Unit
suspend fun ByteWriteChannel.writeByte(b: Int): Unit
suspend fun ByteWriteChannel.writeChar(ch: Char): Unit
suspend fun ByteWriteChannel.writeDouble(value: Double, byteOrder: ByteOrder): Unit
suspend fun ByteWriteChannel.writeDoubleLittleEndian(value: Double): Unit
suspend fun ByteWriteChannel.writeFloat(value: Float, byteOrder: ByteOrder): Unit
suspend fun ByteWriteChannel.writeFloatLittleEndian(value: Float): Unit
suspend fun ByteWriteChannel.writeFully(src: ByteArray): Unit
suspend fun ByteWriteChannel.writeInt(i: Long): Unit
suspend fun ByteWriteChannel.writeInt(i: Long, byteOrder: ByteOrder): Unit
suspend fun ByteWriteChannel.writeInt(value: Int, byteOrder: ByteOrder): Unit
suspend fun ByteWriteChannel.writeIntLittleEndian(value: Int): Unit
suspend fun ByteWriteChannel.writeLong(value: Long, byteOrder: ByteOrder): Unit
suspend fun ByteWriteChannel.writeLongLittleEndian(value: Long): Unit
inline suspend fun ByteWriteChannel.writePacket(headerSizeHint: Int = 0, builder: BytePacketBuilder.() -> Unit): Unit
suspend fun ByteWriteChannel.writePacketSuspend(builder: suspend BytePacketBuilder.() -> Unit): Unit
suspend fun ByteWriteChannel.writeShort(s: Int): Unit
suspend fun ByteWriteChannel.writeShort(s: Int, byteOrder: ByteOrder): Unit
suspend fun ByteWriteChannel.writeShort(value: Short, byteOrder: ByteOrder): Unit
suspend fun ByteWriteChannel.writeShortLittleEndian(value: Short): Unit
suspend fun ByteWriteChannel.writeStringUtf8(s: CharSequence): Unit
suspend fun ByteWriteChannel.writeStringUtf8(s: String): Unit
fun writer(coroutineContext: <ERROR CLASS>, channel: ByteChannel, parent: Job? = null, block: suspend WriterScope.() -> Unit): WriterJob
fun writer(coroutineContext: <ERROR CLASS>, autoFlush: Boolean = false, parent: Job? = null, block: suspend WriterScope.() -> Unit): WriterJob

package io.ktor.utils.io.bits

expect class Memory

Memory(buffer: ByteBuffer)
val Empty: Memory
val buffer: ByteBuffer
fun copyTo(destination: Memory, offset: Int, length: Int, destinationOffset: Int): Unit
fun copyTo(destination: Memory, offset: Long, length: Long, destinationOffset: Long): Unit
inline fun loadAt(index: Int): Byte
inline fun loadAt(index: Long): Byte
val size: Long
val size32: Int
fun slice(offset: Int, length: Int): Memory
fun slice(offset: Long, length: Long): Memory
inline fun storeAt(index: Int, value: Byte): Unit
inline fun storeAt(index: Long, value: Byte): Unit

fun Memory.copyTo(destination: ByteArray, offset: Int, length: Int): Unit
expect fun Memory.copyTo(destination: ByteArray, offset: Int, length: Int, destinationOffset: Int): Unit
fun Memory.copyTo(destination: ByteArray, offset: Long, length: Int): Unit
expect fun Memory.copyTo(destination: ByteArray, offset: Long, length: Int, destinationOffset: Int): Unit
fun Memory.copyTo(destination: ByteBuffer, offset: Int): Unit
fun Memory.copyTo(destination: ByteBuffer, offset: Long): Unit
expect fun Memory.fill(offset: Long, count: Long, value: Byte): Unit
expect fun Memory.fill(offset: Int, count: Int, value: Byte): Unit
inline operator fun Memory.get(index: Int): Byte
inline operator fun Memory.get(index: Long): Byte
java.nio.ByteBuffer

fun ByteBuffer.copyTo(destination: Memory, offset: Int): Unit

kotlin.ByteArray

expect fun <R> ByteArray.useMemory(offset: Int = 0, length: Int, block: (Memory) -> R): R

kotlin.Double

expect fun Double.reverseByteOrder(): Double

kotlin.Float

expect fun Float.reverseByteOrder(): Float

kotlin.Int

inline val Int.highShort: Short
inline val Int.lowShort: Short
expect fun Int.reverseByteOrder(): Int

kotlin.Long

inline val Long.highInt: Int
inline val Long.lowInt: Int
expect fun Long.reverseByteOrder(): Long

kotlin.Short

inline val Short.highByte: Byte
inline val Short.lowByte: Byte
expect fun Short.reverseByteOrder(): Short

inline fun Memory.loadByteArray(offset: Int, destination: ByteArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadByteArray(offset: Long, destination: ByteArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
expect fun Memory.loadDoubleArray(offset: Int, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
expect fun Memory.loadDoubleArray(offset: Long, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline expect fun Memory.loadDoubleAt(offset: Int): Double
inline expect fun Memory.loadDoubleAt(offset: Long): Double
expect fun Memory.loadFloatArray(offset: Int, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
expect fun Memory.loadFloatArray(offset: Long, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline expect fun Memory.loadFloatAt(offset: Int): Float
inline expect fun Memory.loadFloatAt(offset: Long): Float
expect fun Memory.loadIntArray(offset: Int, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
expect fun Memory.loadIntArray(offset: Long, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline expect fun Memory.loadIntAt(offset: Int): Int
inline expect fun Memory.loadIntAt(offset: Long): Int
expect fun Memory.loadLongArray(offset: Int, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
expect fun Memory.loadLongArray(offset: Long, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline expect fun Memory.loadLongAt(offset: Int): Long
inline expect fun Memory.loadLongAt(offset: Long): Long
expect fun Memory.loadShortArray(offset: Int, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
expect fun Memory.loadShortArray(offset: Long, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline expect fun Memory.loadShortAt(offset: Int): Short
inline expect fun Memory.loadShortAt(offset: Long): Short
inline fun Memory.loadUByteArray(offset: Int, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadUByteArray(offset: Long, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadUIntArray(offset: Int, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadUIntArray(offset: Long, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadUIntAt(offset: Int): <ERROR CLASS>
inline fun Memory.loadUIntAt(offset: Long): <ERROR CLASS>
inline fun Memory.loadULongArray(offset: Int, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadULongArray(offset: Long, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadULongAt(offset: Int): <ERROR CLASS>
inline fun Memory.loadULongAt(offset: Long): <ERROR CLASS>
inline fun Memory.loadUShortArray(offset: Int, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadUShortArray(offset: Long, destination: <ERROR CLASS>, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset): Unit
inline fun Memory.loadUShortAt(offset: Int): <ERROR CLASS>
inline fun Memory.loadUShortAt(offset: Long): <ERROR CLASS>
inline fun Memory.Companion.of(array: ByteArray, offset: Int = 0, length: Int = array.size - offset): Memory
inline fun Memory.Companion.of(buffer: ByteBuffer): Memory
@ExperimentalUnsignedTypes fun <ERROR CLASS>.reverseByteOrder(): <ERROR CLASS>
inline operator fun Memory.set(index: Long, value: Byte): Unit
inline operator fun Memory.set(index: Int, value: Byte): Unit
inline fun Memory.storeAt(index: Long, value: <ERROR CLASS>): Unit
inline fun Memory.storeAt(index: Int, value: <ERROR CLASS>): Unit
inline fun Memory.storeByteArray(offset: Int, source: ByteArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeByteArray(offset: Long, source: ByteArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
expect fun Memory.storeDoubleArray(offset: Int, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
expect fun Memory.storeDoubleArray(offset: Long, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline expect fun Memory.storeDoubleAt(offset: Int, value: Double): Unit
inline expect fun Memory.storeDoubleAt(offset: Long, value: Double): Unit
expect fun Memory.storeFloatArray(offset: Int, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
expect fun Memory.storeFloatArray(offset: Long, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline expect fun Memory.storeFloatAt(offset: Int, value: Float): Unit
inline expect fun Memory.storeFloatAt(offset: Long, value: Float): Unit
expect fun Memory.storeIntArray(offset: Int, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
expect fun Memory.storeIntArray(offset: Long, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline expect fun Memory.storeIntAt(offset: Int, value: Int): Unit
inline expect fun Memory.storeIntAt(offset: Long, value: Int): Unit
expect fun Memory.storeLongArray(offset: Int, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
expect fun Memory.storeLongArray(offset: Long, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline expect fun Memory.storeLongAt(offset: Int, value: Long): Unit
inline expect fun Memory.storeLongAt(offset: Long, value: Long): Unit
expect fun Memory.storeShortArray(offset: Int, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
expect fun Memory.storeShortArray(offset: Long, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline expect fun Memory.storeShortAt(offset: Int, value: Short): Unit
inline expect fun Memory.storeShortAt(offset: Long, value: Short): Unit
inline fun Memory.storeUByteArray(offset: Int, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeUByteArray(offset: Long, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeUIntArray(offset: Int, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeUIntArray(offset: Long, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeUIntAt(offset: Int, value: <ERROR CLASS>): Unit
inline fun Memory.storeUIntAt(offset: Long, value: <ERROR CLASS>): Unit
inline fun Memory.storeULongArray(offset: Int, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeULongArray(offset: Long, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeULongAt(offset: Int, value: <ERROR CLASS>): Unit
inline fun Memory.storeULongAt(offset: Long, value: <ERROR CLASS>): Unit
inline fun Memory.storeUShortArray(offset: Int, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeUShortArray(offset: Long, source: <ERROR CLASS>, sourceOffset: Int = 0, count: Int = source.size - sourceOffset): Unit
inline fun Memory.storeUShortAt(offset: Int, value: <ERROR CLASS>): Unit
inline fun Memory.storeUShortAt(offset: Long, value: <ERROR CLASS>): Unit
inline fun <R> withMemory(size: Int, block: (Memory) -> R): R
inline fun <R> withMemory(size: Long, block: (Memory) -> R): R

package io.ktor.utils.io.charsets

Charset

abstract expect class Charset

fun forName(name: String): Charset
fun isSupported(charset: String): Boolean
abstract fun newDecoder(): CharsetDecoder
abstract fun newEncoder(): CharsetEncoder

actual typealias Charset = Charset

CharsetDecoder

abstract expect class CharsetDecoder
actual typealias CharsetDecoder = CharsetDecoder

CharsetEncoder

abstract expect class CharsetEncoder
actual typealias CharsetEncoder = CharsetEncoder

expect object Charsets

val ISO_8859_1: Charset
val UTF_8: Charset

open expect class MalformedInputException : Throwable

MalformedInputException(message: String)
open val message: String?

class TooLongLineException : MalformedInputException

TooLongLineException(message: String)

fun decodeUtf8Result(numberOfChars: Int, requireBytes: Int): Long
fun decodeUtf8ResultCombine(prev: Long, next: Long): Long
java.nio.ByteBuffer

fun ByteBuffer.decodeUTF(out: CharArray, offset: Int, length: Int): Long
fun ByteBuffer.decodeUTF8Line(out: CharArray, offset: Int = 0, length: Int = out.size): Long

java.nio.charset.Charset

expect val Charset.name: String

java.nio.charset.CharsetDecoder

expect val CharsetDecoder.charset: Charset
fun CharsetDecoder.decode(input: Input, max: Int = Int.MAX_VALUE): String
expect fun CharsetDecoder.decode(input: Input, dst: Appendable, max: Int): Int
expect fun CharsetDecoder.decodeExactBytes(input: Input, inputLength: Int): String

java.nio.charset.CharsetEncoder

expect val CharsetEncoder.charset: Charset
fun CharsetEncoder.encode(input: CharSequence, fromIndex: Int, toIndex: Int, dst: Output): Unit
fun CharsetEncoder.encode(input: CharSequence, fromIndex: Int = 0, toIndex: Int = input.length): ByteReadPacket
fun CharsetEncoder.encode(input: CharArray, fromIndex: Int, toIndex: Int, dst: Output): Unit
expect fun CharsetEncoder.encodeToByteArray(input: CharSequence, fromIndex: Int = 0, toIndex: Int = input.length): ByteArray
fun CharsetEncoder.encodeToByteArrayImpl(input: CharSequence, fromIndex: Int = 0, toIndex: Int = input.length): ByteArray
expect fun CharsetEncoder.encodeUTF8(input: ByteReadPacket, dst: Output): Unit
fun CharsetEncoder.encodeUTF8(input: ByteReadPacket): ByteReadPacket

package io.ktor.utils.io.concurrent

inline expect fun <T> shared(value: T): ReadWriteProperty<Any, T>
expect fun <T : Any> threadLocal(value: T): ReadOnlyProperty<Any, T?>

package io.ktor.utils.io.core

open class Buffer

Buffer(memory: Memory)
val Empty: Buffer
const val ReservedSize: Int
var attachment: Any?
val capacity: Int
fun commitWritten(count: Int): Unit
fun discard(count: Int): Int
fun discard(count: Long): Long
fun discardExact(count: Int = readRemaining): Unit
open fun duplicate(): Buffer
protected open fun duplicateTo(copy: Buffer): Unit
inline val endGap: Int
var limit: Int
val memory: Memory
fun readByte(): Byte
var readPosition: Int
inline val readRemaining: Int
fun reserveEndGap(endGap: Int): Unit
fun reserveStartGap(startGap: Int): Unit
open fun reset(): Unit
fun resetForRead(): Unit
fun resetForWrite(): Unit
fun resetForWrite(limit: Int): Unit
fun rewind(count: Int = readPosition - startGap): Unit
var startGap: Int
open fun toString(): String
fun tryPeekByte(): Int
fun tryReadByte(): Int
fun writeByte(value: Byte): Unit
var writePosition: Int
inline val writeRemaining: Int

class BufferLimitExceededException : Exception

BufferLimitExceededException(message: String)

enum expect class ByteOrder

BIG_ENDIAN
LITTLE_ENDIAN
fun nativeOrder(): ByteOrder
val nioOrder: ByteOrder
fun of(nioOrder: ByteOrder): ByteOrder

expect fun BytePacketBuilder(headerSizeHint: Int = 0): BytePacketBuilder
class BytePacketBuilder : Output

BytePacketBuilder(headerSizeHint: Int = 0, pool: ObjectPool<ChunkBuffer>)
fun append(c: Char): BytePacketBuilder
fun append(csq: CharSequence?): BytePacketBuilder
fun append(csq: CharSequence?, start: Int, end: Int): BytePacketBuilder
fun build(): ByteReadPacket
protected fun closeDestination(): Unit
protected fun flush(source: Memory, offset: Int, length: Int): Unit
val isEmpty: Boolean
val isNotEmpty: Boolean
val size: Int
fun toString(): String

class ByteReadPacket : Input

ByteReadPacket(head: ChunkBuffer, pool: ObjectPool<ChunkBuffer>)
val Empty: ByteReadPacket
protected fun closeSource(): Unit
fun copy(): ByteReadPacket
protected fun fill(): ChunkBuffer?
protected fun fill(destination: Memory, offset: Int, length: Int): Int
fun toString(): String

expect fun ByteReadPacket(array: ByteArray, offset: Int = 0, length: Int = array.size, block: (ByteArray) -> Unit): ByteReadPacket
inline fun ByteReadPacket(array: ByteArray, offset: Int = 0, length: Int = array.size): ByteReadPacket
fun ByteReadPacket(bb: ByteBuffer, release: (ByteBuffer) -> Unit = {}): ByteReadPacket
fun ChunkBuffer(buffer: ByteBuffer, pool: ObjectPool<ChunkBuffer>? = null): ChunkBuffer
expect interface Closeable

abstract fun close(): Unit

expect class EOFException : IOException

EOFException(message: String)

annotation class ExperimentalIoApi

ExperimentalIoApi()

abstract class Input : Closeable

Input(head: ChunkBuffer = ChunkBuffer.Empty, remaining: Long = head.remainingAll(), pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool)
fun canRead(): Boolean
open fun close(): Unit
protected abstract fun closeSource(): Unit
fun discard(n: Int): Int
fun discard(n: Long): Long
fun discardExact(n: Int): Unit
val endOfInput: Boolean
fun ensureNextHead(current: ChunkBuffer): ChunkBuffer?
protected abstract fun fill(destination: Memory, offset: Int, length: Int): Int
protected open fun fill(): ChunkBuffer?
fun fixGapAfterRead(current: ChunkBuffer): Unit
fun hasBytes(n: Int): Boolean
protected fun markNoMoreChunksAvailable(): Unit
fun peekTo(destination: Memory, destinationOffset: Long, offset: Long = 0, min: Long = 1, max: Long = Long.MAX_VALUE): Long
fun peekTo(buffer: ChunkBuffer): Int
val pool: ObjectPool<ChunkBuffer>
fun prepareReadHead(minSize: Int): ChunkBuffer?
fun readByte(): Byte
fun readText(out: Appendable, min: Int = 0, max: Int = Int.MAX_VALUE): Int
fun readText(min: Int = 0, max: Int = Int.MAX_VALUE): String
fun readTextExact(out: Appendable, exactCharacters: Int): Unit
fun readTextExact(exactCharacters: Int): String
fun release(): Unit
val remaining: Long
fun tryPeek(): Int
fun updateHeadRemaining(remaining: Int): Unit

class InsufficientSpaceException : Exception

InsufficientSpaceException(size: Int, availableSpace: Int)
InsufficientSpaceException(name: String, size: Int, availableSpace: Int)
InsufficientSpaceException(size: Long, availableSpace: Long)
InsufficientSpaceException(message: String = "Not enough free space")

abstract class Output : Appendable, Closeable

Output(pool: ObjectPool<ChunkBuffer>)
Output()
protected val _size: Int
fun afterHeadWrite(): Unit
open fun append(value: Char): Output
open fun append(value: CharSequence?): Output
open fun append(value: CharSequence?, startIndex: Int, endIndex: Int): Output
fun append(csq: CharArray, start: Int, end: Int): Appendable
fun close(): Unit
protected abstract fun closeDestination(): Unit
protected abstract fun flush(source: Memory, offset: Int, length: Int): Unit
fun flush(): Unit
protected val pool: ObjectPool<ChunkBuffer>
fun prepareWriteHead(n: Int): ChunkBuffer
fun release(): Unit
fun writeByte(v: Byte): Unit
fun writePacket(packet: ByteReadPacket): Unit
fun writePacket(p: ByteReadPacket, n: Int): Unit
fun writePacket(p: ByteReadPacket, n: Long): Unit

expect val PACKET_MAX_COPY_SIZE: Int
expect fun String(bytes: ByteArray, offset: Int = 0, length: Int = bytes.size, charset: Charset = Charsets.UTF_8): String
fun Buffer.append(c: Char): Buffer
fun Buffer.append(csq: CharSequence?): Buffer
fun Buffer.append(csq: CharSequence?, start: Int, end: Int): Buffer
fun Buffer.append(csq: CharArray, start: Int, end: Int): 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
inline fun buildPacket(headerSizeHint: Int = 0, block: BytePacketBuilder.() -> Unit): ByteReadPacket
var Buffer.byteOrder: ByteOrder
inline fun Buffer.canRead(): Boolean
inline fun Buffer.canWrite(): Boolean
fun Input.copyTo(output: Output): Long
fun Input.discard(): Long
fun Input.discardExact(n: Long): Unit
fun Input.discardExact(n: Int): Unit
fun Input.discardUntilDelimiter(delimiter: Byte): Long
fun Input.discardUntilDelimiters(delimiter1: Byte, delimiter2: Byte): Long
fun Buffer.fill(times: Int, value: Byte): Unit
fun Buffer.fill(times: Int, value: <ERROR CLASS>): Unit
fun Buffer.fill(n: Long, v: Byte): Unit
fun Output.fill(times: Long, value: Byte = 0): Unit
fun Buffer.flush(): Unit
inline fun Buffer.forEach(block: (Byte) -> Unit): Unit
inline fun Input.forEach(block: (Byte) -> Unit): Unit
inline val Input.isEmpty: Boolean
inline val ByteReadPacket.isEmpty: Boolean
val Input.isNotEmpty: Boolean
inline val ByteReadPacket.isNotEmpty: Boolean
kotlin.String

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

fun Buffer.makeView(): Buffer
fun ChunkBuffer.makeView(): ChunkBuffer
fun Input.peekCharUtf8(): Char
fun Input.peekTo(destination: ChunkBuffer, offset: Int = 0, min: Int = 1, max: Int = Int.MAX_VALUE): Int
fun Input.peekTo(destination: Buffer, offset: Int = 0, min: Int = 1, max: Int = Int.MAX_VALUE): Int
inline fun <R> BytePacketBuilder.preview(block: (tmp: ByteReadPacket) -> R): R
fun Buffer.pushBack(n: Int): Unit
inline fun Buffer.read(block: (memory: Memory, start: Int, endExclusive: Int) -> Int): Int
fun Buffer.readAvailable(destination: ByteArray, offset: Int = 0, length: Int = destination.size - offset): Int
inline fun ChunkBuffer.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
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
fun Buffer.readAvailable(dst: Buffer, length: Int = dst.writeRemaining): Int
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 Buffer.readAvailable(dst: ByteBuffer, length: Int = dst.remaining()): Int
fun ByteReadPacket.readAvailable(dst: ByteBuffer): Int
fun Input.readAvailable(dst: ByteBuffer, length: Int = dst.remaining()): Int
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 ByteReadPacket.readByteBuffer(n: Int = remaining.coerceAtMostMaxIntOrFail("Unable to make a ByteBuffer: packet is too big"), direct: Boolean = false): ByteBuffer
fun Buffer.readBytes(count: Int = readRemaining): ByteArray
fun ByteReadPacket.readBytes(n: Int = remaining.coerceAtMostMaxIntOrFail("Unable to convert to a ByteArray: packet is too big")): ByteArray
fun Input.readBytes(n: Int): ByteArray
fun Input.readBytes(): ByteArray
fun Input.readBytesOf(min: Int = 0, max: Int = Int.MAX_VALUE): ByteArray
inline fun ChunkBuffer.readDirect(block: (ByteBuffer) -> Unit): Int
inline fun Buffer.readDirect(block: (ByteBuffer) -> Unit): Int
inline fun ByteReadPacket.readDirect(size: Int, block: (ByteBuffer) -> Unit): Unit
inline fun Input.readDirect(size: Int, block: (ByteBuffer) -> Unit): Unit
fun Buffer.readDouble(): Double
inline fun ChunkBuffer.readDouble(): Double
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
inline fun ChunkBuffer.readFloat(): Float
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 Buffer.readFully(destination: ByteArray, offset: Int = 0, length: Int = destination.size - offset): Unit
inline fun ChunkBuffer.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
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
fun Buffer.readFully(dst: Buffer, length: Int = dst.writeRemaining): Int
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
@ExperimentalUnsignedTypes inline fun Input.readFully(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit
fun Buffer.readFully(destination: ByteBuffer): Unit
fun Buffer.readFully(dst: ByteBuffer, length: Int): Unit
fun ByteReadPacket.readFully(dst: ByteBuffer): Int
fun Input.readFully(dst: ByteBuffer, length: Int = dst.remaining()): Unit
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 Buffer.readInt(): Int
inline fun ChunkBuffer.readInt(): Int
fun Input.readInt(byteOrder: ByteOrder): Int
fun Input.readInt(): Int
fun Input.readIntLittleEndian(): Int
fun Buffer.readIntLittleEndian(): Int
fun Buffer.readLong(): Long
inline fun ChunkBuffer.readLong(): Long
fun Input.readLong(byteOrder: ByteOrder): Long
fun Input.readLong(): Long
fun Input.readLongLittleEndian(): Long
fun Buffer.readLongLittleEndian(): Long
fun Buffer.readShort(): Short
inline fun ChunkBuffer.readShort(): Short
fun Input.readShort(byteOrder: ByteOrder): Short
fun Input.readShort(): Short
fun Input.readShortLittleEndian(): Short
fun Buffer.readShortLittleEndian(): Short
fun Buffer.readText(decoder: CharsetDecoder, out: Appendable, lastBuffer: Boolean, max: Int = Int.MAX_VALUE): Int
fun Input.readText(out: Appendable, decoder: CharsetDecoder, max: Int = Int.MAX_VALUE): Int
fun Input.readText(out: Appendable, charset: Charset = Charsets.UTF_8, max: Int = Int.MAX_VALUE): Int
fun Input.readText(decoder: CharsetDecoder, max: Int = Int.MAX_VALUE): String
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
fun ByteReadPacket.readText(decoder: CharsetDecoder, out: Appendable, max: Int = Int.MAX_VALUE): Int
fun Input.readTextExact(charset: Charset = Charsets.UTF_8, n: Int): String
fun Input.readTextExactBytes(charset: Charset = Charsets.UTF_8, bytes: Int): String
fun Input.readTextExactBytes(bytesCount: Int, charset: Charset = Charsets.UTF_8): String
fun Input.readTextExactCharacters(charactersCount: Int, charset: Charset = Charsets.UTF_8): String
fun Buffer.readUByte(): <ERROR CLASS>
inline fun ChunkBuffer.readUByte(): <ERROR CLASS>
@ExperimentalUnsignedTypes inline fun Input.readUByte(): <ERROR CLASS>
fun Buffer.readUInt(): <ERROR CLASS>
inline fun ChunkBuffer.readUInt(): <ERROR CLASS>
@ExperimentalUnsignedTypes inline fun Input.readUInt(): <ERROR CLASS>
fun Buffer.readULong(): <ERROR CLASS>
inline fun ChunkBuffer.readULong(): <ERROR CLASS>
@ExperimentalUnsignedTypes inline fun Input.readULong(): <ERROR CLASS>
fun Buffer.readUShort(): <ERROR CLASS>
inline fun ChunkBuffer.readUShort(): <ERROR CLASS>
@ExperimentalUnsignedTypes inline 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?
fun Input.readUTF8LineTo(out: Appendable, limit: Int): Boolean
fun Input.readUTF8UntilDelimiter(delimiters: String, limit: Int = Int.MAX_VALUE): String
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
fun Input.readUntilDelimiter(delimiter: Byte, dst: ByteArray, offset: Int = 0, length: Int = dst.size): Int
fun Input.readUntilDelimiter(delimiter: Byte, dst: Output): Long
fun Input.readUntilDelimiters(delimiter1: Byte, delimiter2: Byte, dst: ByteArray, offset: Int = 0, length: Int = dst.size): Int
fun Input.readUntilDelimiters(delimiter1: Byte, delimiter2: Byte, dst: Output): Long
fun ChunkBuffer.remainingAll(): Long
fun BytePacketBuilder.reset(): Unit
fun ChunkBuffer.resetFromContentToWrite(child: ByteBuffer): Unit
inline fun Input.takeWhile(block: (Buffer) -> Boolean): Unit
inline fun Input.takeWhileSize(initialSize: Int = 1, block: (Buffer) -> Int): Unit
fun Buffer.tryPeek(): Int
inline fun <C, R> C.use(block: (C) -> R): R
inline fun <I : Input, R> I.use(block: (I) -> R): R
inline fun <O : Output, R> O.use(block: (O) -> R): R
inline fun <R> withBuffer(size: Int, block: Buffer.() -> R): R
inline fun <R> withBuffer(pool: ObjectPool<Buffer>, block: Buffer.() -> R): R
inline fun Buffer.write(block: (memory: Memory, start: Int, endExclusive: Int) -> Int): Int
inline fun BytePacketBuilder.writeByteBufferDirect(size: Int, block: (ByteBuffer) -> Unit): Int
inline fun ChunkBuffer.writeDirect(size: Int, block: (ByteBuffer) -> Unit): Int
inline fun Buffer.writeDirect(size: Int = 1, block: (ByteBuffer) -> Unit): Int
inline fun BytePacketBuilder.writeDirect(size: Int, block: (ByteBuffer) -> Unit): Unit
fun Buffer.writeDouble(value: Double): Unit
inline fun ChunkBuffer.writeDouble(value: Double): Unit
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
inline fun ChunkBuffer.writeFloat(value: Float): Unit
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
inline fun ChunkBuffer.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
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
fun Buffer.writeFully(src: Buffer): Unit
fun Buffer.writeFully(src: Buffer, length: Int): Unit
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: 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
@ExperimentalUnsignedTypes inline fun Output.writeFully(array: <ERROR CLASS>, offset: Int = 0, length: Int = array.size - offset): Unit
fun Buffer.writeFully(source: ByteBuffer): Unit
fun BytePacketBuilder.writeFully(src: ByteBuffer): Unit
fun Output.writeFully(bb: ByteBuffer): Unit
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
inline fun ChunkBuffer.writeInt(value: Int): Unit
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
inline fun ChunkBuffer.writeLong(value: Long): Unit
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 Buffer.writeShort(value: Short): Unit
inline fun ChunkBuffer.writeShort(value: Short): Unit
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.writeText(text: CharSequence, fromIndex: Int = 0, toIndex: Int = text.length, encoder: CharsetEncoder): Unit
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
fun Buffer.writeUByte(value: <ERROR CLASS>): Unit
fun ChunkBuffer.writeUByte(value: <ERROR CLASS>): Unit
@ExperimentalUnsignedTypes inline fun Output.writeUByte(v: <ERROR CLASS>): Unit
fun Buffer.writeUInt(value: <ERROR CLASS>): Unit
inline fun ChunkBuffer.writeUInt(value: <ERROR CLASS>): Unit
@ExperimentalUnsignedTypes inline fun Output.writeUInt(v: <ERROR CLASS>): Unit
fun Buffer.writeULong(value: <ERROR CLASS>): Unit
inline fun ChunkBuffer.writeULong(value: <ERROR CLASS>): Unit
@ExperimentalUnsignedTypes inline fun Output.writeULong(v: <ERROR CLASS>): Unit
fun Buffer.writeUShort(value: <ERROR CLASS>): Unit
inline fun ChunkBuffer.writeUShort(value: <ERROR CLASS>): Unit
@ExperimentalUnsignedTypes inline fun Output.writeUShort(v: <ERROR CLASS>): Unit
inline fun Output.writeWhile(block: (Buffer) -> Boolean): Unit
inline fun Output.writeWhileSize(initialSize: Int = 1, block: (Buffer) -> Int): Unit

package io.ktor.utils.io.core.internal

fun ByteReadPacket.$unsafeAppend$(builder: BytePacketBuilder): Unit
open class ChunkBuffer : Buffer

val Empty: ChunkBuffer
val EmptyPool: ObjectPool<ChunkBuffer>
val Pool: ObjectPool<ChunkBuffer>
fun cleanNext(): ChunkBuffer?
open fun duplicate(): ChunkBuffer
var next: ChunkBuffer?
var origin: ChunkBuffer?
val referenceCount: Int
open fun release(pool: ObjectPool<ChunkBuffer>): Unit
fun reset(): Unit

annotation class DangerousInternalIoApi

DangerousInternalIoApi()

class MalformedUTF8InputException : Exception

MalformedUTF8InputException(message: String)

fun Input.completeReadHead(current: ChunkBuffer): Unit
inline fun Buffer.decodeUTF8(consumer: (Char) -> Boolean): Int
suspend fun decodeUTF8LineLoopSuspend(out: Appendable, limit: Int, nextChunk: suspend (Int) -> Input?): Boolean
fun Input.prepareReadFirstHead(minSize: Int): ChunkBuffer?
fun Input.prepareReadNextHead(current: ChunkBuffer): ChunkBuffer?
fun Output.prepareWriteHead(capacity: Int, current: ChunkBuffer?): ChunkBuffer

package io.ktor.utils.io.errors

open expect class EOFException : IOException

EOFException(message: String)

open expect class IOException : Exception

IOException(message: String)
IOException(message: String, cause: Throwable?)

fun <R> TODO_ERROR(value: R): Nothing
fun TODO_ERROR(): Nothing

package io.ktor.utils.io.jvm.javaio

suspend fun ByteReadChannel.copyTo(out: OutputStream, limit: Long = Long.MAX_VALUE): Long
java.io.InputStream

suspend fun InputStream.copyTo(channel: ByteWriteChannel, limit: Long = Long.MAX_VALUE): Long
fun InputStream.toByteReadChannel(context: <ERROR CLASS> = Dispatchers.IO, pool: ObjectPool<ByteBuffer>): ByteReadChannel
@JvmName("toByteReadChannelWithArrayPool") fun InputStream.toByteReadChannel(context: <ERROR CLASS> = Dispatchers.IO, pool: ObjectPool<ByteArray> = ByteArrayPool): ByteReadChannel

fun ByteReadChannel.toInputStream(parent: Job? = null): InputStream
fun ByteWriteChannel.toOutputStream(parent: Job? = null): OutputStream

package io.ktor.utils.io.jvm.nio

suspend fun ByteReadChannel.copyTo(channel: WritableByteChannel, limit: Long = Long.MAX_VALUE): Long
suspend fun ByteReadChannel.copyTo(pipe: Pipe, limit: Long = Long.MAX_VALUE): Long
java.nio.channels.Pipe

suspend fun Pipe.copyTo(ch: ByteWriteChannel, limit: Long = Long.MAX_VALUE): Long

java.nio.channels.ReadableByteChannel

suspend fun ReadableByteChannel.copyTo(ch: ByteWriteChannel, limit: Long = Long.MAX_VALUE): Long

package io.ktor.utils.io.nio

java.nio.channels.ReadableByteChannel

fun ReadableByteChannel.asInput(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool): Input
fun ReadableByteChannel.read(buffer: Buffer): Int
fun ReadableByteChannel.read(destination: Memory, destinationOffset: Int = 0, maxLength: Int = destination.size32 - destinationOffset): Int
fun ReadableByteChannel.readPacketAtLeast(n: Long): ByteReadPacket
fun ReadableByteChannel.readPacketAtMost(n: Long): ByteReadPacket
fun ReadableByteChannel.readPacketExact(n: Long): ByteReadPacket

java.nio.channels.WritableByteChannel

fun WritableByteChannel.asOutput(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool): Output
fun WritableByteChannel.write(buffer: Buffer): Int
fun WritableByteChannel.write(source: Memory, sourceOffset: Int = 0, maxLength: Int = source.size32 - sourceOffset): Int
fun WritableByteChannel.writePacket(builder: BytePacketBuilder.() -> Unit): ByteReadPacket?
fun WritableByteChannel.writePacket(p: ByteReadPacket): Boolean

package io.ktor.utils.io.pool

class ByteBufferPool : DefaultPool<ByteBuffer>

ByteBufferPool(capacity: Int = DEFAULT_POOL_CAPACITY, bufferSize: Int = DEFAULT_BUFFER_SIZE)
val bufferSize: Int
protected fun clearInstance(instance: ByteBuffer): ByteBuffer
protected fun produceInstance(): ByteBuffer
protected fun validateInstance(instance: ByteBuffer): Unit

abstract expect class DefaultPool<T : Any> : ObjectPool<T>

DefaultPool(capacity: Int)
fun borrow(): T
val capacity: Int
protected open fun clearInstance(instance: T): T
fun dispose(): Unit
protected open fun disposeInstance(instance: T): Unit
protected abstract fun produceInstance(): T
fun recycle(instance: T): Unit
protected open fun validateInstance(instance: T): Unit

class DirectByteBufferPool : DefaultPool<ByteBuffer>

DirectByteBufferPool(capacity: Int = DEFAULT_POOL_CAPACITY, bufferSize: Int = DEFAULT_BUFFER_SIZE)
val bufferSize: Int
protected fun clearInstance(instance: ByteBuffer): ByteBuffer
protected fun produceInstance(): ByteBuffer
protected fun validateInstance(instance: ByteBuffer): Unit

abstract class NoPoolImpl<T : Any> : ObjectPool<T>

NoPoolImpl()
open val capacity: Int
open fun dispose(): Unit
open fun recycle(instance: T): Unit

interface ObjectPool<T : Any> : Closeable

abstract fun borrow(): T
abstract val capacity: Int
open fun close(): Unit
abstract fun dispose(): Unit
abstract fun recycle(instance: T): Unit

abstract class SingleInstancePool<T : Any> : ObjectPool<T>

SingleInstancePool()
fun borrow(): T
val capacity: Int
fun dispose(): Unit
protected abstract fun disposeInstance(instance: T): Unit
protected abstract fun produceInstance(): T
fun recycle(instance: T): Unit

inline fun <T : Any, R> ObjectPool<T>.useBorrowed(block: (T) -> R): R
inline fun <T : Any, R> ObjectPool<T>.useInstance(block: (T) -> R): R

package io.ktor.utils.io.streams

fun ByteReadPacket.inputStream(): InputStream
java.io.InputStream

fun InputStream.asInput(pool: ObjectPool<ChunkBuffer> = ChunkBuffer.Pool): Input
fun InputStream.readPacketAtLeast(n: Long): ByteReadPacket
fun InputStream.readPacketAtMost(n: Long): ByteReadPacket
fun InputStream.readPacketExact(n: Long): ByteReadPacket

java.io.OutputStream

fun OutputStream.asOutput(): Output
fun OutputStream.writePacket(builder: BytePacketBuilder.() -> Unit): Unit
fun OutputStream.writePacket(packet: ByteReadPacket): Unit

fun BytePacketBuilder.outputStream(): OutputStream
fun ByteReadPacket.readerUTF8(): Reader
fun BytePacketBuilder.writerUTF8(): Writer