inline suspend fun AsyncInputStream.consume(autoclose: Boolean = true, temp: ByteArray = ByteArray(0x10000), block: (data: ByteArray, offset: Int, size: Int) -> Unit)

copyTo

suspend fun AsyncInputStream.copyTo(target: AsyncOutputStream, chunkSize: Int = 8 * 1024 * 1024): Long

duplicate

fun duplicate(): AsyncStream

eof

suspend fun eof(): Boolean

eof

suspend fun AsyncPositionLengthStream.eof(): Boolean

getAvailable

suspend fun getAvailable(): Long

getAvailable

suspend fun AsyncInputStreamWithLength.getAvailable(): Long

suspend fun AsyncPositionLengthStream.getAvailable(): Long

getLength

open suspend override fun getLength(): Long

getPosition

open suspend override fun getPosition(): Long

getWrittenRange

inline fun AsyncStream.getWrittenRange(callback: () -> Unit): LongRange

hasAvailable

suspend fun hasAvailable(): Boolean

hasAvailable

suspend fun AsyncInputStreamWithLength.hasAvailable(): Boolean

hash

suspend fun AsyncInputStream.hash(algo: HasherFactory): Hash

hasLength

open suspend fun hasLength(): Boolean

keepPosition

inline fun <T> AsyncStream.keepPosition(callback: () -> T): T

md5

suspend fun AsyncInputStream.md5(): Hash

openAsIso

suspend fun AsyncStream.openAsIso(): VfsFile

suspend fun <R> AsyncStream.openAsIso(callback: suspend (VfsFile) -> R): R

openAsZip

suspend fun AsyncStream.openAsZip(caseSensitive: Boolean = true, useNativeDecompression: Boolean = true): VfsFile

suspend fun <R> AsyncStream.openAsZip(caseSensitive: Boolean = true, useNativeDecompression: Boolean = true, callback: suspend (VfsFile) -> R): R

plus

operator fun AsyncInputStreamWithLength.plus(other: AsyncInputStreamWithLength): AsyncInputStreamWithLength

read

open suspend fun read(): Int

open suspend override fun read(buffer: ByteArray, offset: Int, len: Int): Int

read

suspend fun AsyncInputStream.read(data: ByteArray): Int

suspend fun AsyncInputStream.read(data: UByteArray): Int

readAll

suspend fun AsyncInputStream.readAll(): ByteArray

readAllAsFastStream

suspend fun AsyncStream.readAllAsFastStream(offset: Int = 0): FastByteArrayInputStream

readAvailable

suspend fun AsyncInputStream.readAvailable(): ByteArray

readBitmap

suspend fun AsyncInputStream.readBitmap(props: BaseImageDecodingProps = ImageDecodingProps("file.bin")): Bitmap

readBitmapListNoNative

suspend fun AsyncInputStream.readBitmapListNoNative(props: ImageDecodingProps = ImageDecodingProps.DEFAULT): List<Bitmap>

readBytesExact

suspend fun AsyncInputStream.readBytesExact(len: Int): ByteArray

readBytesUpTo

suspend fun AsyncInputStream.readBytesUpTo(len: Int): ByteArray

suspend fun AsyncInputStream.readBytesUpTo(out: ByteArray, offset: Int, len: Int): Int

readBytesUpToCopy

suspend fun AsyncInputStream.readBytesUpToCopy(out: ByteArray): ByteArray

readBytesUpToFirst

suspend fun AsyncInputStream.readBytesUpToFirst(len: Int): ByteArray

readCharArray

suspend fun AsyncInputStream.readCharArray(count: Int, endian: Endian): CharArray

readCharArrayBE

suspend fun AsyncInputStream.readCharArrayBE(count: Int): CharArray

readCharArrayLE

suspend fun AsyncInputStream.readCharArrayLE(count: Int): CharArray

readDoubleArray

suspend fun AsyncInputStream.readDoubleArray(count: Int, endian: Endian): DoubleArray

readDoubleArrayBE

suspend fun AsyncInputStream.readDoubleArrayBE(count: Int): DoubleArray

readDoubleArrayLE

suspend fun AsyncInputStream.readDoubleArrayLE(count: Int): DoubleArray

readExact

suspend fun AsyncInputStream.readExact(buffer: ByteArray, offset: Int, len: Int)

readF32

suspend fun AsyncInputStream.readF32(endian: Endian): Float

readF32BE

suspend fun AsyncInputStream.readF32BE(): Float

readF32LE

suspend fun AsyncInputStream.readF32LE(): Float

readF64

suspend fun AsyncInputStream.readF64(endian: Endian): Double

readF64BE

suspend fun AsyncInputStream.readF64BE(): Double

readF64LE

suspend fun AsyncInputStream.readF64LE(): Double

readFloatArray

suspend fun AsyncInputStream.readFloatArray(count: Int, endian: Endian): FloatArray

readFloatArrayBE

suspend fun AsyncInputStream.readFloatArrayBE(count: Int): FloatArray

readFloatArrayLE

suspend fun AsyncInputStream.readFloatArrayLE(count: Int): FloatArray

readImageData

suspend fun AsyncInputStream.readImageData(props: BaseImageDecodingProps = ImageDecodingProps.DEFAULT): ImageData

readIntArray

suspend fun AsyncInputStream.readIntArray(count: Int, endian: Endian): IntArray

readIntArrayBE

suspend fun AsyncInputStream.readIntArrayBE(count: Int): IntArray

readIntArrayLE

suspend fun AsyncInputStream.readIntArrayLE(count: Int): IntArray

readLine

suspend fun AsyncInputStream.readLine(eol: Char = '\n', charset: Charset = UTF8, initialCapacity: Int = 4096): String

readLongArray

suspend fun AsyncInputStream.readLongArray(count: Int, endian: Endian): LongArray

readLongArrayBE

suspend fun AsyncInputStream.readLongArrayBE(count: Int): LongArray

readLongArrayLE

suspend fun AsyncInputStream.readLongArrayLE(count: Int): LongArray

readNativeImage

suspend fun AsyncInputStream.readNativeImage(props: BaseImageDecodingProps = ImageDecodingProps.DEFAULT): NativeImage

suspend fun AsyncInputStream.readS16(endian: Endian): Int

readS16BE

suspend fun AsyncInputStream.readS16BE(): Int

readS16LE

suspend fun AsyncInputStream.readS16LE(): Int

suspend fun AsyncInputStream.readS24(endian: Endian): Int

readS24BE

suspend fun AsyncInputStream.readS24BE(): Int

readS24LE

suspend fun AsyncInputStream.readS24LE(): Int

suspend fun AsyncInputStream.readS32(endian: Endian): Int

readS32BE

suspend fun AsyncInputStream.readS32BE(): Int

readS32LE

suspend fun AsyncInputStream.readS32LE(): Int

suspend fun AsyncInputStream.readS64(endian: Endian): Long

readS64BE

suspend fun AsyncInputStream.readS64BE(): Long

readS64LE

suspend fun AsyncInputStream.readS64LE(): Long

suspend fun AsyncInputStream.readS8(): Int

readShortArray

suspend fun AsyncInputStream.readShortArray(count: Int, endian: Endian): ShortArray

readShortArrayBE

suspend fun AsyncInputStream.readShortArrayBE(count: Int): ShortArray

readShortArrayLE

suspend fun AsyncInputStream.readShortArrayLE(count: Int): ShortArray

readSlice

suspend fun AsyncStream.readSlice(length: Long): AsyncStream

readStream

suspend fun AsyncStream.readStream(length: Int): AsyncStream

suspend fun AsyncStream.readStream(length: Long): AsyncStream

readString

suspend fun AsyncInputStream.readString(len: Int, charset: Charset = UTF8): String

readStringz

suspend fun AsyncInputStream.readStringz(charset: Charset = UTF8): String

suspend fun AsyncInputStream.readStringz(len: Int, charset: Charset = UTF8): String

readU16

suspend fun AsyncInputStream.readU16(endian: Endian): Int

readU16BE

suspend fun AsyncInputStream.readU16BE(): Int

readU16LE

suspend fun AsyncInputStream.readU16LE(): Int

readU24

suspend fun AsyncInputStream.readU24(endian: Endian): Int

readU24BE

suspend fun AsyncInputStream.readU24BE(): Int

readU24LE

suspend fun AsyncInputStream.readU24LE(): Int

readU32

suspend fun AsyncInputStream.readU32(endian: Endian): Long

readU32BE

suspend fun AsyncInputStream.readU32BE(): Long

readU32LE

suspend fun AsyncInputStream.readU32LE(): Long

readU8

suspend fun AsyncInputStream.readU8(): Int

readUByteArray

suspend fun AsyncInputStream.readUByteArray(count: Int): UByteArray

readUntil

suspend fun AsyncInputStream.readUntil(endByte: Byte, limit: Int = 4096, temp: ByteArray = ByteArray(1)): ByteArray

setLength

open suspend override fun setLength(value: Long)

setPosition

open suspend override fun setPosition(value: Long)

sha1

suspend fun AsyncInputStream.sha1(): Hash

size

suspend fun size(): Long

skip

suspend fun AsyncInputStream.skip(count: Int)

fun AsyncStream.skip(count: Int): AsyncStream

skipToAlign

fun AsyncStream.skipToAlign(alignment: Int)

fun AsyncStream.skipToAlign(alignment: Int, offset: Int)

slice

suspend fun AsyncStream.slice(range: IntRange, closeParent: Boolean = false): AsyncStream

suspend fun AsyncStream.slice(range: LongRange, closeParent: Boolean = false): AsyncStream

sliceHere

suspend fun AsyncStream.sliceHere(closeParent: Boolean = false): AsyncStream

sliceStart

suspend fun AsyncStream.sliceStart(start: Long = 0, closeParent: Boolean = false): AsyncStream

sliceWithBounds

suspend fun AsyncStream.sliceWithBounds(start: Long, end: Long, closeParent: Boolean = false): AsyncStream

sliceWithSize

suspend fun AsyncStream.sliceWithSize(start: Int, length: Int, closeParent: Boolean = false): AsyncStream

suspend fun AsyncStream.sliceWithSize(start: Long, length: Long, closeParent: Boolean = false): AsyncStream

supportsAvailable

suspend fun AsyncInputStreamWithLength.supportsAvailable(): Boolean

toAsyncStream

fun AsyncBaseStream.toAsyncStream(): AsyncStream

toString

open override fun toString(): String

toSyncOrNull

fun AsyncStream.toSyncOrNull(): SyncStream?

truncate

suspend fun AsyncStream.truncate()

uncompressed

suspend fun AsyncInputStream.uncompressed(method: CompressionMethod, bufferSize: Int = AsyncByteArrayDequeChunked.DEFAULT_MAX_SIZE): AsyncInputStream

withContentEncoding

suspend fun AsyncInputStream.withContentEncoding(contentEncoding: String): AsyncInputStream

withLength

fun AsyncInputStream.withLength(length: Long): AsyncInputStream

withTransferEncoding

suspend fun AsyncInputStream.withTransferEncoding(transferEncoding: String): AsyncInputStream

write

open suspend fun write(byte: Int)

open suspend override fun write(buffer: ByteArray, offset: Int, len: Int)

write16BE

suspend fun AsyncOutputStream.write16BE(v: Int)

write16LE

suspend fun AsyncOutputStream.write16LE(v: Int)

write24BE

suspend fun AsyncOutputStream.write24BE(v: Int)

write24LE

suspend fun AsyncOutputStream.write24LE(v: Int)

write32BE

suspend fun AsyncOutputStream.write32BE(v: Int)

suspend fun AsyncOutputStream.write32BE(v: Long)

write32LE

suspend fun AsyncOutputStream.write32LE(v: Int)

suspend fun AsyncOutputStream.write32LE(v: Long)

write64BE

suspend fun AsyncOutputStream.write64BE(v: Long)

write64LE

suspend fun AsyncOutputStream.write64LE(v: Long)

write8

suspend fun AsyncOutputStream.write8(v: Int)

writeBytes

suspend fun AsyncOutputStream.writeBytes(data: ByteArray)

suspend fun AsyncOutputStream.writeBytes(data: ByteArray, position: Int, length: Int)

writeCharArrayBE

suspend fun AsyncOutputStream.writeCharArrayBE(array: CharArray)

writeCharArrayLE

suspend fun AsyncOutputStream.writeCharArrayLE(array: CharArray)

writeDoubleArrayBE

suspend fun AsyncOutputStream.writeDoubleArrayBE(array: DoubleArray)

writeDoubleArrayLE

suspend fun AsyncOutputStream.writeDoubleArrayLE(array: DoubleArray)

writeF32BE

suspend fun AsyncOutputStream.writeF32BE(v: Float)

writeF32LE

suspend fun AsyncOutputStream.writeF32LE(v: Float)

writeF64BE

suspend fun AsyncOutputStream.writeF64BE(v: Double)

writeF64LE

suspend fun AsyncOutputStream.writeF64LE(v: Double)

writeFile

suspend fun AsyncOutputStream.writeFile(source: VfsFile): Long

writeFloatArrayBE

suspend fun AsyncOutputStream.writeFloatArrayBE(array: FloatArray)

writeFloatArrayLE

suspend fun AsyncOutputStream.writeFloatArrayLE(array: FloatArray)

writeIntArrayBE

suspend fun AsyncOutputStream.writeIntArrayBE(array: IntArray)

writeIntArrayLE

suspend fun AsyncOutputStream.writeIntArrayLE(array: IntArray)

writeLongArrayBE

suspend fun AsyncOutputStream.writeLongArrayBE(array: LongArray)

writeLongArrayLE

suspend fun AsyncOutputStream.writeLongArrayLE(array: LongArray)

writeShortArrayBE

suspend fun AsyncOutputStream.writeShortArrayBE(array: ShortArray)

writeShortArrayLE

suspend fun AsyncOutputStream.writeShortArrayLE(array: ShortArray)

writeStream

suspend fun AsyncOutputStream.writeStream(source: AsyncInputStream): Long

writeString

suspend fun AsyncOutputStream.writeString(string: String, charset: Charset = UTF8)

writeStringVL

suspend fun AsyncStream.writeStringVL(str: String, charset: Charset = UTF8): AsyncStream

writeStringz

suspend fun AsyncOutputStream.writeStringz(str: String, charset: Charset = UTF8)

suspend fun AsyncOutputStream.writeStringz(str: String, len: Int, charset: Charset = UTF8)

writeSync

inline suspend fun AsyncOutputStream.writeSync(hintSize: Int = 4096, callback: SyncStream.() -> Unit)

writeTempBytes

suspend fun AsyncOutputStream.writeTempBytes(size: Int, block: ByteArray.() -> Unit)

writeToAlign

suspend fun AsyncStream.writeToAlign(alignment: Int, value: Int = 0)

writeU_VL

suspend fun AsyncStream.writeU_VL(value: Int): AsyncStream