korge-foundation/korlibs.memory/Buffer

Buffer

expect class Buffer

actual class Buffer

Constructors

Buffer

expect constructor(size: Int, direct: Boolean = false)

expect constructor(array: ByteArray, offset: Int = 0, size: Int = array.size - offset)

constructor(data: ByteArray, offset: Int, size: Int, dummy: Unit)

actual constructor(size: Int, direct: Boolean)

actual constructor(array: ByteArray, offset: Int, size: Int)

constructor(dataView: DataView)

actual constructor(size: Int, direct: Boolean)

actual constructor(array: ByteArray, offset: Int, size: Int)

constructor(buffer: <Error class: unknown class>)

actual constructor(size: Int, direct: Boolean)

actual constructor(array: ByteArray, offset: Int, size: Int)

Types

Companion

expect object Companion

actual object Companion

Properties

arrayByte

val Buffer.arrayByte: Int8Array

arrayDouble

val Buffer.arrayDouble: Float64Array

arrayFloat

val Buffer.arrayFloat: Float32Array

arrayInt

val Buffer.arrayInt: Int32Array

arrayShort

val Buffer.arrayShort: Int16Array

arrayUByte

val Buffer.arrayUByte: Uint8Array

buffer

val buffer: <Error class: unknown class>

buffer

val Buffer.buffer: ArrayBuffer

bufferBE

val bufferBE: <Error class: unknown class>

bufferLE

val bufferLE: <Error class: unknown class>

byteOffset

expect val byteOffset: Int

actual val byteOffset: Int

data

val data: ByteArray

dataView

val dataView: DataView

end

val end: Int

f32

val Buffer.~~f32~~: Float32Buffer

f64

val Buffer.~~f64~~: Float64Buffer

i16

val Buffer.~~i16~~: Int16Buffer

i32

val Buffer.~~i32~~: Int32Buffer

i64

val Buffer.~~i64~~: Int64Buffer

val Buffer.i8: Int8Buffer

nioBuffer

val Buffer.nioBuffer: <Error class: unknown class>

nioFloatBuffer

val Buffer.nioFloatBuffer: <Error class: unknown class>

nioIntBuffer

val Buffer.nioIntBuffer: <Error class: unknown class>

val offset: Int

val size: Int

val Buffer.size: Int

expect val sizeInBytes: Int

actual val sizeInBytes: Int

u16

val Buffer.~~u16~~: Uint16Buffer

val Buffer.u8: Uint8Buffer

Functions

asFloat32

fun Buffer.asFloat32(): Float32Buffer

asFloat64

fun Buffer.asFloat64(): Float64Buffer

asInt16

fun Buffer.asInt16(): Int16Buffer

asInt32

fun Buffer.asInt32(): Int32Buffer

asInt64

fun Buffer.asInt64(): Int64Buffer

asInt8

fun Buffer.asInt8(): Int8Buffer

asUInt16

fun Buffer.asUInt16(): Uint16Buffer

asUInt8

fun Buffer.asUInt8(): Uint8Buffer

clone

fun Buffer.clone(direct: Boolean = false): Buffer

copyOf

fun Buffer.copyOf(newSize: Int): Buffer

equals

open operator override fun equals(other: Any?): Boolean

getArrayFloat32

fun Buffer.~~getArrayFloat32~~(index: Int, out: FloatArray, offset: Int = 0, size: Int = out.size - offset): FloatArray

getArrayFloat64

fun Buffer.~~getArrayFloat64~~(index: Int, out: DoubleArray, offset: Int = 0, size: Int = out.size - offset): DoubleArray

getArrayInt16

fun Buffer.~~getArrayInt16~~(index: Int, out: ShortArray, offset: Int = 0, size: Int = out.size - offset): ShortArray

getArrayInt32

fun Buffer.~~getArrayInt32~~(index: Int, out: IntArray, offset: Int = 0, size: Int = out.size - offset): IntArray

getArrayInt64

fun Buffer.~~getArrayInt64~~(index: Int, out: LongArray, offset: Int = 0, size: Int = out.size - offset): LongArray

getArrayInt8

fun Buffer.~~getArrayInt8~~(index: Int, out: ByteArray, offset: Int = 0, size: Int = out.size - offset): ByteArray

getArrayUInt16

fun Buffer.~~getArrayUInt16~~(index: Int, out: UShortArrayInt, offset: Int = 0, size: Int = out.size - offset): UShortArrayInt

getArrayUInt8

fun Buffer.~~getArrayUInt8~~(index: Int, out: UByteArrayInt, offset: Int = 0, size: Int = out.size - offset): UByteArrayInt

getF32

inline fun Buffer.getF32(byteOffset: Int, littleEndian: Boolean = true): Float

getF32Array

fun Buffer.getF32Array(byteOffset: Int, size: Int, littleEndian: Boolean = true): FloatArray

fun Buffer.getF32Array(byteOffset: Int, out: FloatArray, start: Int = 0, size: Int = out.size - start, littleEndian: Boolean = true): FloatArray

getF32ArrayBE

fun Buffer.getF32ArrayBE(byteOffset: Int, size: Int): FloatArray

fun Buffer.getF32ArrayBE(byteOffset: Int, out: FloatArray, start: Int = 0, size: Int = out.size - start): FloatArray

getF32ArrayLE

fun Buffer.getF32ArrayLE(byteOffset: Int, size: Int): FloatArray

fun Buffer.getF32ArrayLE(byteOffset: Int, out: FloatArray, start: Int = 0, size: Int = out.size - start): FloatArray

getF32BE

expect fun getF32BE(byteOffset: Int): Float

actual fun getF32BE(byteOffset: Int): Float

getF32LE

expect fun getF32LE(byteOffset: Int): Float

actual fun getF32LE(byteOffset: Int): Float

getF64

inline fun Buffer.getF64(byteOffset: Int, littleEndian: Boolean = true): Double

getF64Array

fun Buffer.getF64Array(byteOffset: Int, size: Int, littleEndian: Boolean = true): DoubleArray

fun Buffer.getF64Array(byteOffset: Int, out: DoubleArray, start: Int = 0, size: Int = out.size - start, littleEndian: Boolean = true): DoubleArray

getF64ArrayBE

fun Buffer.getF64ArrayBE(byteOffset: Int, size: Int): DoubleArray

fun Buffer.getF64ArrayBE(byteOffset: Int, out: DoubleArray, start: Int = 0, size: Int = out.size - start): DoubleArray

getF64ArrayLE

fun Buffer.getF64ArrayLE(byteOffset: Int, size: Int): DoubleArray

fun Buffer.getF64ArrayLE(byteOffset: Int, out: DoubleArray, start: Int = 0, size: Int = out.size - start): DoubleArray

getF64BE

expect fun getF64BE(byteOffset: Int): Double

actual fun getF64BE(byteOffset: Int): Double

getF64LE

expect fun getF64LE(byteOffset: Int): Double

actual fun getF64LE(byteOffset: Int): Double

getFloat32

fun Buffer.~~getFloat32~~(index: Int): Float

getFloat64

fun Buffer.~~getFloat64~~(index: Int): Double

getInt16

fun Buffer.~~getInt16~~(index: Int): Short

getInt32

fun Buffer.~~getInt32~~(index: Int): Int

getInt64

fun Buffer.~~getInt64~~(index: Int): Long

getInt8

fun Buffer.~~getInt8~~(index: Int): Byte

getS16

inline fun Buffer.getS16(byteOffset: Int, littleEndian: Boolean = true): Short

getS16Array

fun Buffer.getS16Array(byteOffset: Int, size: Int, littleEndian: Boolean = true): ShortArray

fun Buffer.getS16Array(byteOffset: Int, out: ShortArray, start: Int = 0, size: Int = out.size - start, littleEndian: Boolean = true): ShortArray

getS16ArrayBE

fun Buffer.getS16ArrayBE(byteOffset: Int, size: Int): ShortArray

fun Buffer.getS16ArrayBE(byteOffset: Int, out: ShortArray, start: Int = 0, size: Int = out.size - start): ShortArray

getS16ArrayLE

fun Buffer.getS16ArrayLE(byteOffset: Int, size: Int): ShortArray

fun Buffer.getS16ArrayLE(byteOffset: Int, out: ShortArray, start: Int = 0, size: Int = out.size - start): ShortArray

getS16BE

expect fun getS16BE(byteOffset: Int): Short

actual fun getS16BE(byteOffset: Int): Short

getS16LE

expect fun getS16LE(byteOffset: Int): Short

actual fun getS16LE(byteOffset: Int): Short

getS32

inline fun Buffer.getS32(byteOffset: Int, littleEndian: Boolean = true): Int

getS32Array

fun Buffer.getS32Array(byteOffset: Int, size: Int, littleEndian: Boolean = true): IntArray

fun Buffer.getS32Array(byteOffset: Int, out: IntArray, start: Int = 0, size: Int = out.size - start, littleEndian: Boolean = true): IntArray

getS32ArrayBE

fun Buffer.getS32ArrayBE(byteOffset: Int, size: Int): IntArray

fun Buffer.getS32ArrayBE(byteOffset: Int, out: IntArray, start: Int = 0, size: Int = out.size - start): IntArray

getS32ArrayLE

fun Buffer.getS32ArrayLE(byteOffset: Int, size: Int): IntArray

fun Buffer.getS32ArrayLE(byteOffset: Int, out: IntArray, start: Int = 0, size: Int = out.size - start): IntArray

getS32BE

expect fun getS32BE(byteOffset: Int): Int

actual fun getS32BE(byteOffset: Int): Int

getS32LE

expect fun getS32LE(byteOffset: Int): Int

actual fun getS32LE(byteOffset: Int): Int

getS64

inline fun Buffer.getS64(byteOffset: Int, littleEndian: Boolean = true): Long

getS64Array

fun Buffer.getS64Array(byteOffset: Int, size: Int, littleEndian: Boolean = true): LongArray

fun Buffer.getS64Array(byteOffset: Int, out: LongArray, start: Int = 0, size: Int = out.size - start, littleEndian: Boolean = true): LongArray

getS64ArrayBE

fun Buffer.getS64ArrayBE(byteOffset: Int, size: Int): LongArray

fun Buffer.getS64ArrayBE(byteOffset: Int, out: LongArray, start: Int = 0, size: Int = out.size - start): LongArray

getS64ArrayLE

fun Buffer.getS64ArrayLE(byteOffset: Int, size: Int): LongArray

fun Buffer.getS64ArrayLE(byteOffset: Int, out: LongArray, start: Int = 0, size: Int = out.size - start): LongArray

getS64BE

expect fun getS64BE(byteOffset: Int): Long

actual fun getS64BE(byteOffset: Int): Long

getS64LE

expect fun getS64LE(byteOffset: Int): Long

actual fun getS64LE(byteOffset: Int): Long

getS8

expect fun getS8(byteOffset: Int): Byte

actual fun getS8(byteOffset: Int): Byte

getS8Array

fun Buffer.getS8Array(byteOffset: Int, size: Int): ByteArray

fun Buffer.getS8Array(byteOffset: Int, out: ByteArray, start: Int = 0, size: Int = out.size - start): ByteArray

getU16

inline fun Buffer.getU16(byteOffset: Int, littleEndian: Boolean = true): Int

getU16BE

fun Buffer.getU16BE(byteOffset: Int): Int

getU16LE

fun Buffer.getU16LE(byteOffset: Int): Int

getU32

inline fun Buffer.getU32(byteOffset: Int, littleEndian: Boolean = true): Long

getU32BE

fun Buffer.getU32BE(byteOffset: Int): Long

getU32LE

fun Buffer.getU32LE(byteOffset: Int): Long

getU8

fun Buffer.getU8(byteOffset: Int): Int

inline fun Buffer.getU8(byteOffset: Int, littleEndian: Boolean = true): Int

getUInt16

fun Buffer.~~getUInt16~~(index: Int): Int

getUInt8

fun Buffer.~~getUInt8~~(index: Int): Int

getUnalignedArrayFloat32

fun Buffer.~~getUnalignedArrayFloat32~~(byteOffset: Int, out: FloatArray, offset: Int = 0, size: Int = out.size - offset): FloatArray

getUnalignedArrayFloat64

fun Buffer.~~getUnalignedArrayFloat64~~(byteOffset: Int, out: DoubleArray, offset: Int = 0, size: Int = out.size - offset): DoubleArray

getUnalignedArrayInt16

fun Buffer.~~getUnalignedArrayInt16~~(byteOffset: Int, out: ShortArray, offset: Int = 0, size: Int = out.size - offset): ShortArray

getUnalignedArrayInt32

fun Buffer.~~getUnalignedArrayInt32~~(byteOffset: Int, out: IntArray, offset: Int = 0, size: Int = out.size - offset): IntArray

getUnalignedArrayInt64

fun Buffer.~~getUnalignedArrayInt64~~(byteOffset: Int, out: LongArray, offset: Int = 0, size: Int = out.size - offset): LongArray

getUnalignedArrayInt8

fun Buffer.~~getUnalignedArrayInt8~~(byteOffset: Int, out: ByteArray, offset: Int = 0, size: Int = out.size - offset): ByteArray

getUnalignedFloat32

fun Buffer.~~getUnalignedFloat32~~(byteOffset: Int): Float

getUnalignedFloat64

fun Buffer.~~getUnalignedFloat64~~(byteOffset: Int): Double

getUnalignedInt16

fun Buffer.~~getUnalignedInt16~~(byteOffset: Int): Short

getUnalignedInt32

fun Buffer.~~getUnalignedInt32~~(byteOffset: Int): Int

getUnalignedInt64

fun Buffer.~~getUnalignedInt64~~(byteOffset: Int): Long

getUnalignedInt8

fun Buffer.~~getUnalignedInt8~~(byteOffset: Int): Byte

getUnalignedUInt16

fun Buffer.~~getUnalignedUInt16~~(byteOffset: Int): Int

getUnalignedUInt8

fun Buffer.~~getUnalignedUInt8~~(byteOffset: Int): Int

hashCode

open override fun hashCode(): Int

hex

fun Buffer.hex(): String

set16

inline fun Buffer.set16(byteOffset: Int, value: Short, littleEndian: Boolean = true)

set16BE

expect fun set16BE(byteOffset: Int, value: Short)

actual fun set16BE(byteOffset: Int, value: Short)

set16BEClamped

fun Buffer.set16BEClamped(byteOffset: Int, value: Int)

set16Clamped

inline fun Buffer.set16Clamped(byteOffset: Int, value: Int, littleEndian: Boolean = true)

set16LE

expect fun set16LE(byteOffset: Int, value: Short)

actual fun set16LE(byteOffset: Int, value: Short)

set16LEClamped

fun Buffer.set16LEClamped(byteOffset: Int, value: Int)

set32

inline fun Buffer.set32(byteOffset: Int, value: Int, littleEndian: Boolean = true)

set32BE

expect fun set32BE(byteOffset: Int, value: Int)

actual fun set32BE(byteOffset: Int, value: Int)

set32LE

expect fun set32LE(byteOffset: Int, value: Int)

actual fun set32LE(byteOffset: Int, value: Int)

set64

inline fun Buffer.set64(byteOffset: Int, value: Long, littleEndian: Boolean = true)

set64BE

expect fun set64BE(byteOffset: Int, value: Long)

actual fun set64BE(byteOffset: Int, value: Long)

set64LE

expect fun set64LE(byteOffset: Int, value: Long)

actual fun set64LE(byteOffset: Int, value: Long)

set8

expect fun set8(byteOffset: Int, value: Byte)

actual fun set8(byteOffset: Int, value: Byte)

set8Clamped

fun Buffer.set8Clamped(byteOffset: Int, value: Int)

setArray

fun Buffer.setArray(byteOffset: Int, data: ByteArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArray(byteOffset: Int, data: DoubleArray, start: Int = 0, size: Int = data.size - start, littleEndian: Boolean = true)

fun Buffer.setArray(byteOffset: Int, data: FloatArray, start: Int = 0, size: Int = data.size - start, littleEndian: Boolean = true)

fun Buffer.setArray(byteOffset: Int, data: IntArray, start: Int = 0, size: Int = data.size - start, littleEndian: Boolean = true)

fun Buffer.setArray(byteOffset: Int, data: LongArray, start: Int = 0, size: Int = data.size - start, littleEndian: Boolean = true)

fun Buffer.setArray(byteOffset: Int, data: ShortArray, start: Int = 0, size: Int = data.size - start, littleEndian: Boolean = true)

setArrayBE

fun Buffer.setArrayBE(byteOffset: Int, data: DoubleArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayBE(byteOffset: Int, data: FloatArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayBE(byteOffset: Int, data: IntArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayBE(byteOffset: Int, data: LongArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayBE(byteOffset: Int, data: ShortArray, start: Int = 0, size: Int = data.size - start)

setArrayFloat32

fun Buffer.~~setArrayFloat32~~(index: Int, inp: FloatArray, offset: Int = 0, size: Int = inp.size - offset)

setArrayFloat64

fun Buffer.~~setArrayFloat64~~(index: Int, inp: DoubleArray, offset: Int = 0, size: Int = inp.size - offset)

setArrayInt16

fun Buffer.~~setArrayInt16~~(index: Int, inp: ShortArray, offset: Int = 0, size: Int = inp.size - offset)

setArrayInt32

fun Buffer.~~setArrayInt32~~(index: Int, inp: IntArray, offset: Int = 0, size: Int = inp.size - offset)

setArrayInt64

fun Buffer.~~setArrayInt64~~(index: Int, inp: LongArray, offset: Int = 0, size: Int = inp.size - offset)

setArrayInt8

fun Buffer.~~setArrayInt8~~(index: Int, inp: ByteArray, offset: Int = 0, size: Int = inp.size - offset)

setArrayLE

fun Buffer.setArrayLE(byteOffset: Int, data: DoubleArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayLE(byteOffset: Int, data: FloatArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayLE(byteOffset: Int, data: IntArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayLE(byteOffset: Int, data: LongArray, start: Int = 0, size: Int = data.size - start)

fun Buffer.setArrayLE(byteOffset: Int, data: ShortArray, start: Int = 0, size: Int = data.size - start)

setArrayUInt16

fun Buffer.~~setArrayUInt16~~(index: Int, inp: UShortArrayInt, offset: Int = 0, size: Int = inp.size - offset)

setArrayUInt8

fun Buffer.~~setArrayUInt8~~(index: Int, inp: UByteArrayInt, offset: Int = 0, size: Int = inp.size - offset)

setF32

inline fun Buffer.setF32(byteOffset: Int, value: Float, littleEndian: Boolean = true)

setF32BE

expect fun setF32BE(byteOffset: Int, value: Float)

actual fun setF32BE(byteOffset: Int, value: Float)

setF32LE

expect fun setF32LE(byteOffset: Int, value: Float)

actual fun setF32LE(byteOffset: Int, value: Float)

setF64

inline fun Buffer.setF64(byteOffset: Int, value: Double, littleEndian: Boolean = true)

setF64BE

expect fun setF64BE(byteOffset: Int, value: Double)

actual fun setF64BE(byteOffset: Int, value: Double)

setF64LE

expect fun setF64LE(byteOffset: Int, value: Double)

actual fun setF64LE(byteOffset: Int, value: Double)

setFloat32

fun Buffer.~~setFloat32~~(index: Int, value: Float)

setFloat64

fun Buffer.~~setFloat64~~(index: Int, value: Double)

setInt16

fun Buffer.~~setInt16~~(index: Int, value: Short)

setInt32

fun Buffer.~~setInt32~~(index: Int, value: Int)

setInt64

fun Buffer.~~setInt64~~(index: Int, value: Long)

setInt8

fun Buffer.~~setInt8~~(index: Int, value: Byte)

fun Buffer.~~setInt8~~(index: Int, value: Int)

setUInt16

fun Buffer.~~setUInt16~~(index: Int, value: Int)

setUInt8

fun Buffer.~~setUInt8~~(index: Int, value: Int)

setUInt8Clamped

fun Buffer.~~setUInt8Clamped~~(index: Int, value: Int)

setUnalignedArrayFloat32

fun Buffer.~~setUnalignedArrayFloat32~~(byteOffset: Int, inp: FloatArray, offset: Int = 0, size: Int = inp.size - offset)

setUnalignedArrayFloat64

fun Buffer.~~setUnalignedArrayFloat64~~(byteOffset: Int, inp: DoubleArray, offset: Int = 0, size: Int = inp.size - offset)

setUnalignedArrayInt16

fun Buffer.~~setUnalignedArrayInt16~~(byteOffset: Int, inp: ShortArray, offset: Int = 0, size: Int = inp.size - offset)

setUnalignedArrayInt32

fun Buffer.~~setUnalignedArrayInt32~~(byteOffset: Int, inp: IntArray, offset: Int = 0, size: Int = inp.size - offset)

setUnalignedArrayInt64

fun Buffer.~~setUnalignedArrayInt64~~(byteOffset: Int, inp: LongArray, offset: Int = 0, size: Int = inp.size - offset)

setUnalignedArrayInt8

fun Buffer.~~setUnalignedArrayInt8~~(byteOffset: Int, inp: ByteArray, offset: Int = 0, size: Int = inp.size - offset)

setUnalignedFloat32

fun Buffer.~~setUnalignedFloat32~~(byteOffset: Int, value: Float)

setUnalignedFloat64

fun Buffer.~~setUnalignedFloat64~~(byteOffset: Int, value: Double)

setUnalignedInt16

fun Buffer.~~setUnalignedInt16~~(byteOffset: Int, value: Short)

setUnalignedInt32

fun Buffer.~~setUnalignedInt32~~(byteOffset: Int, value: Int)

setUnalignedInt64

fun Buffer.~~setUnalignedInt64~~(byteOffset: Int, value: Long)

setUnalignedInt8

fun Buffer.~~setUnalignedInt8~~(byteOffset: Int, value: Byte)

fun Buffer.~~setUnalignedInt8~~(byteOffset: Int, value: Int)

setUnalignedUInt16

fun Buffer.~~setUnalignedUInt16~~(byteOffset: Int, value: Int)

setUnalignedUInt8

fun Buffer.~~setUnalignedUInt8~~(byteOffset: Int, value: Int)

setUnalignedUInt8Clamped

fun Buffer.~~setUnalignedUInt8Clamped~~(byteOffset: Int, value: Int)

sliceBuffer

fun Buffer.sliceBuffer(start: Int = 0, end: Int = sizeInBytes): Buffer

slicedBuffer

fun slicedBuffer(roffset: Int = 0, rsize: Int = this.size - roffset): <Error class: unknown class>

sliceUint8Array

fun sliceUint8Array(offset: Int = 0, size: Int = dataView.byteLength - offset): Uint8Array

sliceWithSize

fun Buffer.sliceWithSize(start: Int, size: Int): Buffer

toString

open override fun toString(): String

transferBytes

expect fun transferBytes(bufferOffset: Int, array: ByteArray, arrayOffset: Int, len: Int, toArray: Boolean)

actual fun transferBytes(bufferOffset: Int, array: ByteArray, arrayOffset: Int, len: Int, toArray: Boolean)