korge-core/korlibs.io.stream

Package-level declarations

Types

AsyncBaseStream

interface AsyncBaseStream : AsyncCloseable

AsyncBufferedInputStream

class AsyncBufferedInputStream(val base: AsyncInputStream, val bufferSize: Int = 8192) : AsyncInputStream

AsyncGetLengthStream

interface AsyncGetLengthStream : AsyncBaseStream

AsyncGetPositionStream

interface AsyncGetPositionStream : AsyncBaseStream

AsyncInputOpenable

interface AsyncInputOpenable

AsyncInputStream

interface AsyncInputStream : AsyncBaseStream

AsyncInputStreamWithLength

interface AsyncInputStreamWithLength : AsyncInputStream, AsyncGetPositionStream, AsyncGetLengthStream

AsyncLengthStream

interface AsyncLengthStream : AsyncGetLengthStream

AsyncOutputStream

interface AsyncOutputStream : AsyncBaseStream

AsyncPositionLengthStream

interface AsyncPositionLengthStream : AsyncPositionStream, AsyncLengthStream

AsyncPositionStream

interface AsyncPositionStream : AsyncGetPositionStream

AsyncRAInputStream

interface AsyncRAInputStream

AsyncRAOutputStream

interface AsyncRAOutputStream

class AsyncStream(val base: AsyncStreamBase, var position: Long = 0, val queue: Boolean = false) : Extra, AsyncInputStream, AsyncInputStreamWithLength, AsyncOutputStream, AsyncPositionLengthStream, AsyncCloseable

AsyncStreamBase

open class AsyncStreamBase : AsyncCloseable, AsyncRAInputStream, AsyncRAOutputStream, AsyncLengthStream

BufferedStreamBase

class BufferedStreamBase(val base: AsyncStreamBase, val blockSize: Int = 2048, val blocksToRead: Int = 16) : AsyncStreamBase

ByteArrayBitReader

class ByteArrayBitReader(val data: ByteArray)

ByteArrayDequeSyncStream

class ByteArrayDequeSyncStream(val deque: ByteArrayDeque) : SyncStreamBase

interface CharReader

CharReaderFromSyncStream

class CharReaderFromSyncStream(val stream: SyncStream, val charset: Charset, val chunkSize: Int = 1024) : CharReader

DequeSyncStreamBase

class DequeSyncStreamBase(val deque: ByteArrayDeque = ByteArrayDeque()) : SyncStreamBase

DummyAsyncOutputStream

open class DummyAsyncOutputStream : AsyncOutputStream

FastByteArrayInputStream

class FastByteArrayInputStream(val ba: ByteArray, offset: Int = 0, val start: Int = 0, val end: Int = ba.size)

FileSyncStreamBase

class FileSyncStreamBase(val file: File, val mode: String = "r") : SyncStreamBase

FillSyncStreamBase

class FillSyncStreamBase(val fill: Byte, var length: Long) : SyncStreamBase

MarkableSyncInputStream

interface MarkableSyncInputStream : SyncInputStream

MarkableSyncStream

open class MarkableSyncStream(val inp: SyncInputStream) : MarkableSyncInputStream

MemoryAsyncStreamBase

class MemoryAsyncStreamBase(var data: ByteArrayBuilder) : AsyncStreamBase

MemorySyncStreamBase

class MemorySyncStreamBase(var data: ByteArrayBuilder) : SyncStreamBase

ReadonlySyncStreamBase

class ReadonlySyncStreamBase(var data: ByteArray, val offset: Int = 0, val size: Int = data.size - offset) : SyncStreamBase

SeekNotSupportedException

open class SeekNotSupportedException(message: String = "Seeking not supported!") : UnsupportedOperationException

SequenceSyncStreamBase

class SequenceSyncStreamBase(val sequence: Sequence<ByteArray>) : SyncStreamBase

SliceAsyncStreamBase

class SliceAsyncStreamBase(base: AsyncStreamBase, baseStart: Long, baseEnd: Long, closeParent: Boolean) : AsyncStreamBase

SliceSyncStreamBase

class SliceSyncStreamBase(base: SyncStreamBase, baseStart: Long, baseEnd: Long) : SyncStreamBase

SyncAsyncStreamBase

class SyncAsyncStreamBase(val sync: SyncStreamBase) : AsyncStreamBase

SyncAsyncStreamBaseInWorker

class SyncAsyncStreamBaseInWorker(val sync: SyncStreamBase) : AsyncStreamBase

SyncInputStream

interface SyncInputStream : OptionalCloseable

SyncLengthStream

interface SyncLengthStream

SyncOutputStream

interface SyncOutputStream : OptionalCloseable

SyncPositionStream

interface SyncPositionStream

SyncRAInputStream

interface SyncRAInputStream

SyncRAOutputStream

interface SyncRAOutputStream

class SyncStream(val base: SyncStreamBase, position: Long = 0) : Extra, Closeable, SyncInputStream, SyncPositionStream, SyncOutputStream, SyncLengthStream, MarkableSyncInputStream

open class SyncStreamBase : Closeable, SyncRAInputStream, SyncRAOutputStream, SyncLengthStream

Properties

EMPTY_BYTE_ARRAY

val EMPTY_BYTE_ARRAY: ByteArray

val SyncStream.eof: Boolean

val SyncStream.hasAvailable: Boolean

val SyncStream.hasLength: Boolean

val SyncStream.hasMore: Boolean

Functions

fun AsyncStream.asVfsFile(name: String = "unknown.bin"): VfsFile

asyncStreamWriter

suspend fun asyncStreamWriter(bufferSize: Int = AsyncByteArrayDequeChunked.DEFAULT_MAX_SIZE, name: String? = null, lazy: Boolean = false, process: suspend (out: AsyncOutputStream) -> Unit): AsyncInputStream

Creates a an AsyncInputStream from a process function that writes to a AsyncOutputStream.

fun AsyncStream.buffered(blockSize: Int = 2048, blocksToRead: Int = 16): AsyncStream

fun AsyncInputStream.bufferedInput(bufferSize: Int = 8192): AsyncBufferedInputStream

fun List<AsyncInputStreamWithLength>.combine(): AsyncInputStreamWithLength

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

fun SyncInputStream.copyTo(target: SyncOutputStream)

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

DequeSyncStream

fun DequeSyncStream(): SyncStream

suspend fun AsyncPositionLengthStream.eof(): Boolean

fun FillSyncStream(fillByte: Int = 0, length: Long = Long.MAX_VALUE): SyncStream

suspend fun AsyncInputStreamWithLength.getAvailable(): Long

suspend fun AsyncPositionLengthStream.getAvailable(): Long

getWrittenRange

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

suspend fun AsyncInputStreamWithLength.hasAvailable(): Boolean

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

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

fun SyncInputStream.markable(): MarkableSyncInputStream

MemorySyncStream

fun MemorySyncStream(data: ByteArrayBuilder): SyncStream

fun MemorySyncStream(data: ByteArray = EMPTY_BYTE_ARRAY): SyncStream

MemorySyncStreamToByteArray

inline fun MemorySyncStreamToByteArray(initialCapacity: Int = 4096, callback: SyncStream.() -> Unit): ByteArray

fun ByteArray.openAsync(mode: String = "r"): AsyncStream

fun String.openAsync(charset: Charset = UTF8): AsyncStream

fun ByteArray.openFastStream(offset: Int = 0): FastByteArrayInputStream

fun ByteArray.openSync(mode: String = "r"): SyncStream

fun String.openSync(charset: Charset = UTF8): SyncStream

fun File.openSync(mode: String = "r"): SyncStream

inline suspend fun <T> AsyncInputOpenable.openUse(block: (AsyncInputStream) -> T): T

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

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

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

fun CharReader.read(count: Int): String

fun SyncInputStream.read(data: ByteArray): Int

fun SyncInputStream.read(data: UByteArray): Int

suspend fun AsyncInputStream.readAll(): ByteArray

fun SyncStream.readAll(): ByteArray

readAllAsFastStream

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

suspend fun AsyncInputStream.readAvailable(): ByteArray

fun SyncStream.readAvailable(): ByteArray

readBufferedLine

suspend fun AsyncBufferedInputStream.readBufferedLine(limit: Int = 4096, charset: Charset = UTF8): String

fun SyncInputStream.readBytes(len: Int): ByteArray

suspend fun AsyncStreamBase.readBytes(position: Long, count: Int): ByteArray

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

fun SyncInputStream.readBytesExact(len: Int): ByteArray

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

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

readCharArrayBE

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

fun SyncInputStream.readCharArrayBE(count: Int): CharArray

readCharArrayLE

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

fun SyncInputStream.readCharArrayLE(count: Int): CharArray

readDoubleArray

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

readDoubleArrayBE

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

fun SyncInputStream.readDoubleArrayBE(count: Int): DoubleArray

readDoubleArrayLE

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

fun SyncInputStream.readDoubleArrayLE(count: Int): DoubleArray

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

fun SyncInputStream.readExact(out: ByteArray, offset: Int, len: Int)

fun SyncInputStream.readExactTo(buffer: ByteArray, offset: Int = 0, length: Int = buffer.size - offset): Int

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

suspend fun AsyncInputStream.readF32BE(): Float

fun SyncInputStream.readF32BE(): Float

suspend fun AsyncInputStream.readF32LE(): Float

fun SyncInputStream.readF32LE(): Float

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

suspend fun AsyncInputStream.readF64BE(): Double

fun SyncInputStream.readF64BE(): Double

suspend fun AsyncInputStream.readF64LE(): Double

fun SyncInputStream.readF64LE(): Double

readFastByteArrayInputStream

fun SyncStream.readFastByteArrayInputStream(length: Int): FastByteArrayInputStream

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

readFloatArrayBE

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

fun SyncInputStream.readFloatArrayBE(count: Int): FloatArray

readFloatArrayLE

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

fun SyncInputStream.readFloatArrayLE(count: Int): FloatArray

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

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

fun SyncInputStream.readIntArrayBE(count: Int): IntArray

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

fun SyncInputStream.readIntArrayLE(count: Int): IntArray

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

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

readLongArrayBE

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

fun SyncInputStream.readLongArrayBE(count: Int): LongArray

readLongArrayLE

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

fun SyncInputStream.readLongArrayLE(count: Int): LongArray

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

suspend fun AsyncInputStream.readS16BE(): Int

fun SyncInputStream.readS16BE(): Int

suspend fun AsyncInputStream.readS16LE(): Int

fun SyncInputStream.readS16LE(): Int

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

suspend fun AsyncInputStream.readS24BE(): Int

fun SyncInputStream.readS24BE(): Int

suspend fun AsyncInputStream.readS24LE(): Int

fun SyncInputStream.readS24LE(): Int

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

suspend fun AsyncInputStream.readS32BE(): Int

fun SyncInputStream.readS32BE(): Int

suspend fun AsyncInputStream.readS32LE(): Int

fun SyncInputStream.readS32LE(): Int

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

suspend fun AsyncInputStream.readS64BE(): Long

fun SyncInputStream.readS64BE(): Long

suspend fun AsyncInputStream.readS64LE(): Long

fun SyncInputStream.readS64LE(): Long

suspend fun AsyncInputStream.readS8(): Int

fun SyncInputStream.readS8(): Int

fun SyncInputStream.readS_VL(): Int

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

readShortArrayBE

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

fun SyncInputStream.readShortArrayBE(count: Int): ShortArray

readShortArrayLE

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

fun SyncInputStream.readShortArrayLE(count: Int): ShortArray

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

fun SyncStream.readSlice(length: Long): SyncStream

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

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

fun SyncStream.readStream(length: Int): SyncStream

fun SyncStream.readStream(length: Long): SyncStream

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

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

fun SyncStream.readStringVL(charset: Charset = UTF8): String

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

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

fun SyncInputStream.readStringz(charset: Charset = UTF8, zero: Byte = 0): String

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

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

suspend fun AsyncInputStream.readU16BE(): Int

fun SyncInputStream.readU16BE(): Int

suspend fun AsyncInputStream.readU16LE(): Int

fun SyncInputStream.readU16LE(): Int

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

suspend fun AsyncInputStream.readU24BE(): Int

fun SyncInputStream.readU24BE(): Int

suspend fun AsyncInputStream.readU24LE(): Int

fun SyncInputStream.readU24LE(): Int

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

suspend fun AsyncInputStream.readU32BE(): Long

fun SyncInputStream.readU32BE(): Long

suspend fun AsyncInputStream.readU32LE(): Long

fun SyncInputStream.readU32LE(): Long

suspend fun AsyncInputStream.readU8(): Int

fun SyncInputStream.readU8(): Int

fun SyncInputStream.readU_VL(): Int

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

fun SyncInputStream.readUByteArray(count: Int): UByteArray

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

sequenceSyncStream

fun sequenceSyncStream(block: suspend SequenceScope<ByteArray>.() -> Unit): SyncStream

suspend fun AsyncInputStream.skip(count: Int)

fun AsyncStream.skip(count: Int): AsyncStream

fun SyncStream.skip(count: Int): SyncStream

fun AsyncStream.skipToAlign(alignment: Int)

fun SyncStream.skipToAlign(alignment: Int)

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

fun SyncStream.slice(range: IntRange): SyncStream

fun SyncStream.slice(range: LongRange): SyncStream

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

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

fun SyncStream.sliceHere(): SyncStream

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

fun SyncStream.sliceStart(start: Long = 0): SyncStream

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

sliceWithBounds

fun SyncStream.sliceWithBounds(start: Long, end: Long): SyncStream

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

fun SyncStream.sliceWithSize(position: Int, length: Int): SyncStream

fun SyncStream.sliceWithSize(position: Long, length: Long): SyncStream

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

fun SyncStream.toAsync(): AsyncStream

fun SyncStreamBase.toAsync(): AsyncStreamBase

fun InputStream.toAsync(length: Long? = null): AsyncInputStream

toAsyncInputStream

fun SyncInputStream.toAsyncInputStream(): AsyncInputStreamWithLength

toAsyncInWorker

fun SyncStream.toAsyncInWorker(): AsyncStream

fun SyncStreamBase.toAsyncInWorker(): AsyncStreamBase

toAsyncOutputStream

fun SyncOutputStream.toAsyncOutputStream(): AsyncOutputStream

fun AsyncBaseStream.toAsyncStream(): AsyncStream

fun FastByteArrayInputStream.toAsyncStream(): AsyncStream

fun AsyncStreamBase.toAsyncStream(position: Long = 0): AsyncStream

fun SyncStream.toByteArray(): ByteArray

fun SyncStream.toCharReader(charset: Charset, chunkSize: Int = 1024): CharReader

fun ByteArray.toCharReader(charset: Charset, chunkSize: Int = 1024): CharReader

fun SyncStream.toInputStream(): InputStream

toSyncInputStream

fun <Error class: unknown class>.toSyncInputStream(): SyncInputStream

fun AsyncStream.toSyncOrNull(): SyncStream?

fun AsyncStreamBase.toSyncOrNull(): SyncStreamBase?

toSyncOutputStream

fun <Error class: unknown class>.toSyncOutputStream(): SyncOutputStream

fun ByteArrayDeque.toSyncStream(): SyncStream

fun FastByteArrayInputStream.toSyncStream(): SyncStream

fun SyncStreamBase.toSyncStream(position: Long = 0): SyncStream

fun InputStream.toSyncStream(): SyncInputStream

suspend fun AsyncStream.truncate()

fun SyncStream.truncate()

fun AsyncInputStream.withLength(length: Long): AsyncInputStream

suspend fun AsyncOutputStream.write16BE(v: Int)

fun SyncOutputStream.write16BE(v: Int)

suspend fun AsyncOutputStream.write16LE(v: Int)

fun SyncOutputStream.write16LE(v: Int)

suspend fun AsyncOutputStream.write24BE(v: Int)

fun SyncOutputStream.write24BE(v: Int)

suspend fun AsyncOutputStream.write24LE(v: Int)

fun SyncOutputStream.write24LE(v: Int)

suspend fun AsyncOutputStream.write32BE(v: Int)

suspend fun AsyncOutputStream.write32BE(v: Long)

fun SyncOutputStream.write32BE(v: Int)

fun SyncOutputStream.write32BE(v: Long)

suspend fun AsyncOutputStream.write32LE(v: Int)

suspend fun AsyncOutputStream.write32LE(v: Long)

fun SyncOutputStream.write32LE(v: Int)

fun SyncOutputStream.write32LE(v: Long)

suspend fun AsyncOutputStream.write64BE(v: Long)

fun SyncOutputStream.write64BE(v: Long)

suspend fun AsyncOutputStream.write64LE(v: Long)

fun SyncOutputStream.write64LE(v: Long)

suspend fun AsyncOutputStream.write8(v: Int)

fun SyncOutputStream.write8(v: Int)

suspend fun AsyncOutputStream.writeBytes(data: ByteArray)

fun SyncOutputStream.writeBytes(data: ByteArray)

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

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

writeCharArrayBE

suspend fun AsyncOutputStream.writeCharArrayBE(array: CharArray)

fun SyncOutputStream.writeCharArrayBE(array: CharArray)

writeCharArrayLE

suspend fun AsyncOutputStream.writeCharArrayLE(array: CharArray)

fun SyncOutputStream.writeCharArrayLE(array: CharArray)

writeDoubleArrayBE

suspend fun AsyncOutputStream.writeDoubleArrayBE(array: DoubleArray)

fun SyncOutputStream.writeDoubleArrayBE(array: DoubleArray)

writeDoubleArrayLE

suspend fun AsyncOutputStream.writeDoubleArrayLE(array: DoubleArray)

fun SyncOutputStream.writeDoubleArrayLE(array: DoubleArray)

suspend fun AsyncOutputStream.writeF32BE(v: Float)

fun SyncOutputStream.writeF32BE(v: Float)

suspend fun AsyncOutputStream.writeF32LE(v: Float)

fun SyncOutputStream.writeF32LE(v: Float)

suspend fun AsyncOutputStream.writeF64BE(v: Double)

fun SyncOutputStream.writeF64BE(v: Double)

suspend fun AsyncOutputStream.writeF64LE(v: Double)

fun SyncOutputStream.writeF64LE(v: Double)

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

writeFloatArrayBE

suspend fun AsyncOutputStream.writeFloatArrayBE(array: FloatArray)

fun SyncOutputStream.writeFloatArrayBE(array: FloatArray)

writeFloatArrayLE

suspend fun AsyncOutputStream.writeFloatArrayLE(array: FloatArray)

fun SyncOutputStream.writeFloatArrayLE(array: FloatArray)

writeIntArrayBE

suspend fun AsyncOutputStream.writeIntArrayBE(array: IntArray)

fun SyncOutputStream.writeIntArrayBE(array: IntArray)

writeIntArrayLE

suspend fun AsyncOutputStream.writeIntArrayLE(array: IntArray)

fun SyncOutputStream.writeIntArrayLE(array: IntArray)

writeLongArrayBE

suspend fun AsyncOutputStream.writeLongArrayBE(array: LongArray)

fun SyncOutputStream.writeLongArrayBE(array: LongArray)

writeLongArrayLE

suspend fun AsyncOutputStream.writeLongArrayLE(array: LongArray)

fun SyncOutputStream.writeLongArrayLE(array: LongArray)

fun SyncOutputStream.writeS_VL(v: Int)

writeShortArrayBE

suspend fun AsyncOutputStream.writeShortArrayBE(array: ShortArray)

fun SyncOutputStream.writeShortArrayBE(array: ShortArray)

writeShortArrayLE

suspend fun AsyncOutputStream.writeShortArrayLE(array: ShortArray)

fun SyncOutputStream.writeShortArrayLE(array: ShortArray)

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

fun SyncOutputStream.writeStream(source: SyncInputStream)

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

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

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

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

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

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

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

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

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

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

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

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

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

fun SyncOutputStream.writeU_VL(v: Int)