korlibs-memory/korlibs.memory

Package-level declarations

Types

BaseBuffer

interface BaseBuffer

BaseFloatBuffer

interface BaseFloatBuffer : BaseBuffer

BaseIntBuffer

interface BaseIntBuffer : BaseBuffer

Buffer

actual class Buffer : AutoCloseable

expect class Buffer : AutoCloseable

actual class Buffer : AutoCloseable

BufferMapMode

enum BufferMapMode : Enum<BufferMapMode>

ByteArrayReader

class ByteArrayReader(val data: ByteArray, val start: Int, val size: Int = 0)

ByteArrayReaderBE

inline class ByteArrayReaderBE(val bar: ByteArrayReader)

ByteArrayReaderLE

inline class ByteArrayReaderLE(val bar: ByteArrayReader)

DataView

typealias DataView = Buffer

FixedSizeByteArrayBuilder

class FixedSizeByteArrayBuilder(val data: ByteArray)

Float32Buffer

@JvmInline

value class Float32Buffer(val buffer: Buffer) : TypedBuffer, BaseFloatBuffer

Float64Buffer

@JvmInline

value class Float64Buffer(val buffer: Buffer) : TypedBuffer

FloatArrayBuffer

@JvmInline

value class FloatArrayBuffer(val array: FloatArray) : BaseFloatBuffer

FloatArrayFromIntArray

inline class FloatArrayFromIntArray(val base: IntArray)

View of base reinterpreted as Float

Int16Buffer

@JvmInline

value class Int16Buffer(val buffer: Buffer) : TypedBuffer

Int32Buffer

@JvmInline

value class Int32Buffer(val buffer: Buffer) : TypedBuffer, BaseIntBuffer

Int64Buffer

@JvmInline

value class Int64Buffer(val buffer: Buffer) : TypedBuffer

Int8Buffer

@JvmInline

value class Int8Buffer(val buffer: Buffer) : TypedBuffer

IntArrayBuffer

@JvmInline

value class IntArrayBuffer(val array: IntArray) : BaseIntBuffer

KmemGCImpl

open class KmemGCImpl

NBufferTempAddress

class NBufferTempAddress

NInt

inline class NInt(val data: CPointer<IntVar>?)

SimpleBytesDeque

class SimpleBytesDeque(val initialBits: Int = 10, val allowGrow: Boolean = true)

SimpleChunkedByteDeque

class SimpleChunkedByteDeque

SimpleRingBuffer

class SimpleRingBuffer(val bits: Int)

TypedBuffer

interface TypedBuffer : BaseBuffer

UByteArrayInt

inline class UByteArrayInt(val data: ByteArray)

View of bytes reinterpreted as Int

Uint16Buffer

@JvmInline

value class Uint16Buffer(val buffer: Buffer) : TypedBuffer, BaseIntBuffer

Uint32Buffer

@JvmInline

value class Uint32Buffer(val buffer: Buffer) : TypedBuffer

Uint8Buffer

@JvmInline

value class Uint8Buffer(val buffer: Buffer) : TypedBuffer, BaseIntBuffer

Uint8ClampedBuffer

@JvmInline

value class Uint8ClampedBuffer(val buffer: Buffer) : TypedBuffer, BaseIntBuffer

UShortArrayInt

inline class UShortArrayInt(val data: ShortArray)

View of shorts reinterpreted as Int

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.buffer: ArrayBuffer

f32

val Buffer.~~f32~~: Float32Buffer

f64

val Buffer.~~f64~~: Float64Buffer

hasMore

val ByteArrayReaderBE.hasMore: Boolean

val ByteArrayReaderLE.hasMore: Boolean

i16

val Buffer.~~i16~~: Int16Buffer

i32

val Buffer.~~i32~~: Int32Buffer

i64

val Buffer.~~i64~~: Int64Buffer

val Buffer.i8: Int8Buffer

KmemGC

actual val KmemGC: KmemGCImpl

expect val KmemGC: KmemGCImpl

actual val KmemGC: KmemGCImpl

nioBuffer

val Buffer.nioBuffer: ByteBuffer

nioFloatBuffer

val Buffer.nioFloatBuffer: FloatBuffer

nioIntBuffer

val Buffer.nioIntBuffer: IntBuffer

remaining

val ByteArrayReaderBE.remaining: Int

val ByteArrayReaderLE.remaining: Int

size

val Buffer.size: Int

val ByteArrayReaderBE.size: Int

val ByteArrayReaderLE.size: Int

startAddressOf

val Pinned<ByteArray>.startAddressOf: CPointer<ByteVar>

val Pinned<DoubleArray>.startAddressOf: CPointer<DoubleVar>

val Pinned<FloatArray>.startAddressOf: CPointer<FloatVar>

val Pinned<IntArray>.startAddressOf: CPointer<IntVar>

val Pinned<LongArray>.startAddressOf: CPointer<LongVar>

val Pinned<ShortArray>.startAddressOf: CPointer<ShortVar>

val Pinned<UByteArray>.startAddressOf: CPointer<UByteVar>

val Pinned<UIntArray>.startAddressOf: CPointer<UIntVar>

val Pinned<ULongArray>.startAddressOf: CPointer<ULongVar>

val Pinned<UShortArray>.startAddressOf: CPointer<UShortVar>

Returns the address of the beginning of this array or if it is empty another valid non-null address

u16

val Buffer.~~u16~~: Uint16Buffer

val Buffer.u8: Uint8Buffer

Functions

allocDirect

fun Buffer.Companion.allocDirect(size: Int): Buffer

allocNoDirect

fun Buffer.Companion.allocNoDirect(size: Int): Buffer

arrayadd

fun arrayadd(array: Float32Buffer, value: Float, start: Int = 0, end: Int = array.size)

fun arrayadd(array: Float64Buffer, value: Double, start: Int = 0, end: Int = array.size)

fun arrayadd(array: Int16Buffer, value: Short, start: Int = 0, end: Int = array.size)

fun arrayadd(array: Int32Buffer, value: Int, start: Int = 0, end: Int = array.size)

fun arrayadd(array: Int8Buffer, value: Byte, start: Int = 0, end: Int = array.size)

fun arrayadd(array: Uint16Buffer, value: Short, start: Int = 0, end: Int = array.size)

fun arrayadd(array: Uint8Buffer, value: Byte, start: Int = 0, end: Int = array.size)

fun arrayadd(array: ByteArray, value: Byte, start: Int = 0, end: Int = array.size)

fun arrayadd(array: DoubleArray, value: Double, start: Int = 0, end: Int = array.size)

fun arrayadd(array: FloatArray, value: Float, start: Int = 0, end: Int = array.size)

fun arrayadd(array: IntArray, value: Int, start: Int = 0, end: Int = array.size)

fun arrayadd(array: LongArray, value: Long, start: Int = 0, end: Int = array.size)

fun arrayadd(array: ShortArray, value: Short, start: Int = 0, end: Int = array.size)

arraycmp

fun arraycmp(src: Buffer, srcPos: Int, dst: Buffer, dstPos: Int, size: Int): Int

fun <T : Comparable<T>> arraycmp(src: Array<T>, srcPos: Int, dst: Array<T>, dstPos: Int, size: Int): Int

fun arraycmp(src: BooleanArray, srcPos: Int, dst: BooleanArray, dstPos: Int, size: Int): Int

fun arraycmp(src: ByteArray, srcPos: Int, dst: ByteArray, dstPos: Int, size: Int): Int

fun arraycmp(src: CharArray, srcPos: Int, dst: CharArray, dstPos: Int, size: Int): Int

fun arraycmp(src: DoubleArray, srcPos: Int, dst: DoubleArray, dstPos: Int, size: Int): Int

fun arraycmp(src: FloatArray, srcPos: Int, dst: FloatArray, dstPos: Int, size: Int): Int

fun arraycmp(src: IntArray, srcPos: Int, dst: IntArray, dstPos: Int, size: Int): Int

fun arraycmp(src: LongArray, srcPos: Int, dst: LongArray, dstPos: Int, size: Int): Int

fun arraycmp(src: ShortArray, srcPos: Int, dst: ShortArray, dstPos: Int, size: Int): Int

fun <T : Comparable<T>> arraycmp(src: List<T>, srcPos: Int, dst: List<T>, dstPos: Int, size: Int): Int

arraycopy

fun arraycopy(src: Buffer, srcPos: Int, dst: Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Buffer, srcPos: Int, dst: ByteArray, dstPos: Int, size: Int)

fun arraycopy(src: Float32Buffer, srcPos: Int, dst: Float32Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Float32Buffer, srcPos: Int, dst: FloatArray, dstPos: Int, size: Int)

fun arraycopy(src: Float64Buffer, srcPos: Int, dst: Float64Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Float64Buffer, srcPos: Int, dst: DoubleArray, dstPos: Int, size: Int)

fun arraycopy(src: Int16Buffer, srcPos: Int, dst: Int16Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Int16Buffer, srcPos: Int, dst: ShortArray, dstPos: Int, size: Int)

fun arraycopy(src: Int32Buffer, srcPos: Int, dst: Int32Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Int32Buffer, srcPos: Int, dst: IntArray, dstPos: Int, size: Int)

fun arraycopy(src: Int64Buffer, srcPos: Int, dst: Int64Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Int64Buffer, srcPos: Int, dst: LongArray, dstPos: Int, size: Int)

fun arraycopy(src: Int8Buffer, srcPos: Int, dst: Int8Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Int8Buffer, srcPos: Int, dst: ByteArray, dstPos: Int, size: Int)

fun arraycopy(src: UByteArrayInt, srcPos: Int, dst: UByteArrayInt, dstPos: Int, size: Int)

fun arraycopy(src: UByteArrayInt, srcPos: Int, dst: Uint8Buffer, dstPos: Int, size: Int)

fun arraycopy(src: UShortArrayInt, srcPos: Int, dst: UShortArrayInt, dstPos: Int, size: Int)

fun arraycopy(src: UShortArrayInt, srcPos: Int, dst: Uint16Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Uint16Buffer, srcPos: Int, dst: UShortArrayInt, dstPos: Int, size: Int)

fun arraycopy(src: Uint16Buffer, srcPos: Int, dst: Uint16Buffer, dstPos: Int, size: Int)

fun arraycopy(src: Uint8Buffer, srcPos: Int, dst: UByteArrayInt, dstPos: Int, size: Int)

fun arraycopy(src: Uint8Buffer, srcPos: Int, dst: Uint8Buffer, dstPos: Int, size: Int)

fun arraycopy(src: ByteArray, srcPos: Int, dst: Buffer, dstPos: Int, size: Int)

fun arraycopy(src: ByteArray, srcPos: Int, dst: Int8Buffer, dstPos: Int, size: Int)

fun arraycopy(src: DoubleArray, srcPos: Int, dst: Float64Buffer, dstPos: Int, size: Int)

fun arraycopy(src: FloatArray, srcPos: Int, dst: Float32Buffer, dstPos: Int, size: Int)

fun arraycopy(src: IntArray, srcPos: Int, dst: Int32Buffer, dstPos: Int, size: Int)

fun arraycopy(src: LongArray, srcPos: Int, dst: Int64Buffer, dstPos: Int, size: Int)

fun arraycopy(src: ShortArray, srcPos: Int, dst: Int16Buffer, dstPos: Int, size: Int)

inline fun <T> arraycopy(size: Int, src: Any?, srcPos: Int, dst: Any?, dstPos: Int, setDst: (Int, T) -> Unit, getSrc: (Int) -> T)

fun <T> arraycopy(src: Array<out T>, srcPos: Int, dst: Array<out T>, dstPos: Int, size: Int)

fun arraycopy(src: BooleanArray, srcPos: Int, dst: BooleanArray, dstPos: Int, size: Int)

fun arraycopy(src: ByteArray, srcPos: Int, dst: ByteArray, dstPos: Int, size: Int)

fun arraycopy(src: CharArray, srcPos: Int, dst: CharArray, dstPos: Int, size: Int)

fun arraycopy(src: DoubleArray, srcPos: Int, dst: DoubleArray, dstPos: Int, size: Int)

fun arraycopy(src: FloatArray, srcPos: Int, dst: FloatArray, dstPos: Int, size: Int)

fun arraycopy(src: IntArray, srcPos: Int, dst: IntArray, dstPos: Int, size: Int)

fun arraycopy(src: LongArray, srcPos: Int, dst: LongArray, dstPos: Int, size: Int)

fun arraycopy(src: ShortArray, srcPos: Int, dst: ShortArray, dstPos: Int, size: Int)

fun <T> arraycopy(src: List<T>, srcPos: Int, dst: MutableList<T>, dstPos: Int, size: Int)

Copies size elements of src starting at srcPos into dst at dstPos

arraycopyStride

fun arraycopyStride(src: ByteArray, srcPos: Int, srcStride: Int, dst: ByteArray, dstPos: Int, dstStride: Int, size: Int)

fun arraycopyStride(src: FloatArray, srcPos: Int, srcStride: Int, dst: FloatArray, dstPos: Int, dstStride: Int, size: Int)

inline fun <T> arraycopyStride(src: (Int) -> T, srcPos: Int, srcStride: Int, dst: (Int, T) -> Unit, dstPos: Int, dstStride: Int, size: Int)

fun arraycopyStride(src: IntArray, srcPos: Int, srcStride: Int, dst: IntArray, dstPos: Int, dstStride: Int, size: Int)

fun arraycopyStride(src: ShortArray, srcPos: Int, srcStride: Int, dst: ShortArray, dstPos: Int, dstStride: Int, size: Int)

arrayequal

fun arrayequal(src: Buffer, srcPos: Int, dst: Buffer, dstPos: Int, size: Int): Boolean

fun <T> arrayequal(src: Array<T>, srcPos: Int, dst: Array<T>, dstPos: Int, size: Int): Boolean

fun arrayequal(src: BooleanArray, srcPos: Int, dst: BooleanArray, dstPos: Int, size: Int): Boolean

fun arrayequal(src: ByteArray, srcPos: Int, dst: ByteArray, dstPos: Int, size: Int): Boolean

fun arrayequal(src: CharArray, srcPos: Int, dst: CharArray, dstPos: Int, size: Int): Boolean

fun arrayequal(src: DoubleArray, srcPos: Int, dst: DoubleArray, dstPos: Int, size: Int): Boolean

fun arrayequal(src: FloatArray, srcPos: Int, dst: FloatArray, dstPos: Int, size: Int): Boolean

fun arrayequal(src: IntArray, srcPos: Int, dst: IntArray, dstPos: Int, size: Int): Boolean

fun arrayequal(src: LongArray, srcPos: Int, dst: LongArray, dstPos: Int, size: Int): Boolean

fun arrayequal(src: ShortArray, srcPos: Int, dst: ShortArray, dstPos: Int, size: Int): Boolean

fun <T> arrayequal(src: List<T>, srcPos: Int, dst: List<T>, dstPos: Int, size: Int): Boolean

arrayfill

fun arrayfill(array: Buffer, value: Int, start: Int = 0, end: Int = array.size)

fun <T> arrayfill(array: Array<T>, value: T, start: Int = 0, end: Int = array.size)

fun arrayfill(array: BooleanArray, value: Boolean, start: Int = 0, end: Int = array.size)

fun arrayfill(array: ByteArray, value: Byte, start: Int = 0, end: Int = array.size)

fun arrayfill(array: DoubleArray, value: Double, start: Int = 0, end: Int = array.size)

fun arrayfill(array: FloatArray, value: Float, start: Int = 0, end: Int = array.size)

fun arrayfill(array: IntArray, value: Int, start: Int = 0, end: Int = array.size)

fun arrayfill(array: LongArray, value: Long, start: Int = 0, end: Int = array.size)

fun arrayfill(array: ShortArray, value: Short, start: Int = 0, end: Int = array.size)

Fills the array with the value starting a start end ending at end (end is not inclusive)

arrayinterleave

fun arrayinterleave(out: ByteArray, outPos: Int, array1: ByteArray, array1Pos: Int, array2: ByteArray, array2Pos: Int, size: Int)

fun arrayinterleave(out: FloatArray, outPos: Int, array1: FloatArray, array1Pos: Int, array2: FloatArray, array2Pos: Int, size: Int)

fun arrayinterleave(out: IntArray, outPos: Int, array1: IntArray, array1Pos: Int, array2: IntArray, array2Pos: Int, size: Int)

fun arrayinterleave(out: ShortArray, outPos: Int, array1: ShortArray, array1Pos: Int, array2: ShortArray, array2Pos: Int, size: Int)

asByteArray

fun UByteArrayInt.asByteArray(): ByteArray

Gets the underlying array of this

fun ArrayBuffer.asByteArray(): ByteArray

asDoubleArray

fun ArrayBuffer.asDoubleArray(): DoubleArray

asFloat32

fun Buffer.asFloat32(): Float32Buffer

fun TypedBuffer.asFloat32(): Float32Buffer

asFloat32Array

fun ArrayBuffer.asFloat32Array(): Float32Array

asFloat64

fun Buffer.asFloat64(): Float64Buffer

fun TypedBuffer.asFloat64(): Float64Buffer

asFloat64Array

fun ArrayBuffer.asFloat64Array(): Float64Array

asFloatArray

fun IntArray.asFloatArray(): FloatArrayFromIntArray

Creates a view of this reinterpreted as Float

fun ArrayBuffer.asFloatArray(): FloatArray

asInt16

fun Buffer.asInt16(): Int16Buffer

fun TypedBuffer.asInt16(): Int16Buffer

asInt16Array

fun ArrayBuffer.asInt16Array(): Int16Array

asInt32

fun Buffer.asInt32(): Int32Buffer

fun TypedBuffer.asInt32(): Int32Buffer

asInt32Array

fun ArrayBuffer.asInt32Array(): Int32Array

asInt64

fun Buffer.asInt64(): Int64Buffer

fun TypedBuffer.asInt64(): Int64Buffer

asInt8

fun Buffer.asInt8(): Int8Buffer

fun TypedBuffer.asInt8(): Int8Buffer

asInt8Array

fun ArrayBuffer.asInt8Array(): Int8Array

asIntArray

fun FloatArrayFromIntArray.asIntArray(): IntArray

Gets the underlying array of this

fun ArrayBuffer.asIntArray(): IntArray

asShortArray

fun UShortArrayInt.asShortArray(): ShortArray

Gets the underlying array of this

fun ArrayBuffer.asShortArray(): ShortArray

asUByteArray

fun ArrayBuffer.asUByteArray(): UByteArray

asUByteArrayInt

fun ByteArray.asUByteArrayInt(): UByteArrayInt

Creates a view of this reinterpreted as Int

asUInt16

fun Buffer.asUInt16(): Uint16Buffer

fun TypedBuffer.asUInt16(): Uint16Buffer

asUInt8

fun Buffer.asUInt8(): Uint8Buffer

fun TypedBuffer.asUInt8(): Uint8Buffer

asUint8Array

fun ArrayBuffer.asUint8Array(): Uint8Array

asUint8ClampedArray

fun ArrayBuffer.asUint8ClampedArray(): Uint8ClampedArray

asUShortArrayInt

fun ShortArray.asUShortArrayInt(): UShortArrayInt

Creates a view of this reinterpreted as Int

BufferTemp

inline fun <T> BufferTemp(size: Int, callback: (Buffer) -> T): T

clearSafe

fun Buffer.clearSafe()

clone

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

copyOf

fun Buffer.copyOf(newSize: Int): Buffer

f32

fun ByteArrayReaderBE.f32(): Float

fun ByteArrayReaderLE.f32(): Float

f64

fun ByteArrayReaderBE.f64(): Double

fun ByteArrayReaderLE.f64(): Double

flipSafe

fun Buffer.flipSafe()

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

fun ByteArray.getF32(offset: Int, littleEndian: Boolean): Float

getF32Array

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

fun ByteArray.getF32Array(offset: Int, count: Int, littleEndian: Boolean): 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 ByteArray.getF32ArrayBE(offset: Int, count: 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 ByteArray.getF32ArrayLE(offset: Int, count: Int): FloatArray

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

getF32BE

fun ByteArray.getF32BE(offset: Int): Float

getF32LE

fun ByteArray.getF32LE(offset: Int): Float

getF64

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

fun ByteArray.getF64(offset: Int, littleEndian: Boolean): Double

getF64Array

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

fun ByteArray.getF64Array(offset: Int, count: Int, littleEndian: Boolean): 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 ByteArray.getF64ArrayBE(offset: Int, count: 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 ByteArray.getF64ArrayLE(offset: Int, count: Int): DoubleArray

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

getF64BE

fun ByteArray.getF64BE(offset: Int): Double

getF64LE

fun ByteArray.getF64LE(offset: 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

fun ByteArray.getS16(offset: Int, littleEndian: Boolean): Int

getS16Array

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

fun ByteArray.getS16Array(offset: Int, count: Int, littleEndian: Boolean): 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 ByteArray.getS16ArrayBE(offset: Int, count: 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 ByteArray.getS16ArrayLE(offset: Int, count: Int): ShortArray

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

getS16BE

fun ByteArray.getS16BE(offset: Int): Int

getS16LE

fun ByteArray.getS16LE(offset: Int): Int

getS24

fun ByteArray.getS24(offset: Int, littleEndian: Boolean): Int

getS24BE

fun ByteArray.getS24BE(offset: Int): Int

getS24LE

fun ByteArray.getS24LE(offset: Int): Int

getS32

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

fun ByteArray.getS32(offset: Int, littleEndian: Boolean): Int

getS32Array

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

fun ByteArray.getS32Array(offset: Int, count: Int, littleEndian: Boolean): 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 ByteArray.getS32ArrayBE(offset: Int, count: 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 ByteArray.getS32ArrayLE(offset: Int, count: Int): IntArray

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

getS32BE

fun ByteArray.getS32BE(offset: Int): Int

getS32LE

fun ByteArray.getS32LE(offset: Int): Int

getS64

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

fun ByteArray.getS64(offset: Int, littleEndian: Boolean): Long

getS64Array

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

fun ByteArray.getS64Array(offset: Int, count: Int, littleEndian: Boolean): 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 ByteArray.getS64ArrayBE(offset: Int, count: 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 ByteArray.getS64ArrayLE(offset: Int, count: Int): LongArray

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

getS64BE

fun ByteArray.getS64BE(offset: Int): Long

getS64LE

fun ByteArray.getS64LE(offset: Int): Long

getS8

fun ByteArray.getS8(offset: Int): Int

getS8Array

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

fun ByteArray.getS8Array(offset: Int, count: Int): ByteArray

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

getSampled

fun ByteArray.getSampled(index: Float): Byte

fun CharArray.getSampled(index: Float): Char

fun FloatArray.getSampled(index: Float): Float

fun ShortArray.getSampled(index: Float): Short

fun UByteArray.getSampled(index: Float): UByte

fun UShortArray.getSampled(index: Float): UShort

getSampledGeneric

inline fun <T> getSampledGeneric(index: Float, get: (Int) -> T, scale: (T, Float) -> Float, convert: (Float) -> T, unit: Unit = Unit): T

getU16

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

fun ByteArray.getU16(offset: Int, littleEndian: Boolean): Int

getU16Array

fun ByteArray.getU16Array(offset: Int, count: Int, littleEndian: Boolean): CharArray

getU16ArrayBE

fun ByteArray.getU16ArrayBE(offset: Int, count: Int): CharArray

getU16ArrayLE

fun ByteArray.getU16ArrayLE(offset: Int, count: Int): CharArray

getU16BE

fun Buffer.getU16BE(byteOffset: Int): Int

fun ByteArray.getU16BE(offset: Int): Int

getU16LE

fun Buffer.getU16LE(byteOffset: Int): Int

fun ByteArray.getU16LE(offset: Int): Int

getU24

fun ByteArray.getU24(offset: Int, littleEndian: Boolean): Int

getU24BE

fun ByteArray.getU24BE(offset: Int): Int

getU24LE

fun ByteArray.getU24LE(offset: Int): Int

getU32

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

fun ByteArray.getU32(offset: Int, littleEndian: Boolean): Long

getU32BE

fun Buffer.getU32BE(byteOffset: Int): Long

fun ByteArray.getU32BE(offset: Int): Long

getU32LE

fun Buffer.getU32LE(byteOffset: Int): Long

fun ByteArray.getU32LE(offset: Int): Long

getU8

fun Buffer.getU8(byteOffset: Int): Int

fun ByteArray.getU8(offset: 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

hex

fun Buffer.hex(): String

indexOf

fun <T> Array<T>.indexOf(sub: Array<T>, starting: Int = 0): Int

fun BooleanArray.indexOf(sub: BooleanArray, starting: Int = 0): Int

fun ByteArray.indexOf(sub: ByteArray, starting: Int = 0): Int

fun CharArray.indexOf(sub: CharArray, starting: Int = 0): Int

fun DoubleArray.indexOf(sub: DoubleArray, starting: Int = 0): Int

fun FloatArray.indexOf(sub: FloatArray, starting: Int = 0): Int

fun IntArray.indexOf(sub: IntArray, starting: Int = 0): Int

fun LongArray.indexOf(sub: LongArray, starting: Int = 0): Int

fun ShortArray.indexOf(sub: ShortArray, starting: Int = 0): Int

lastIndexOf

fun <T> Array<T>.lastIndexOf(sub: Array<T>, starting: Int = 0): Int

fun BooleanArray.lastIndexOf(sub: BooleanArray, starting: Int = 0): Int

fun ByteArray.lastIndexOf(sub: ByteArray, starting: Int = 0): Int

fun CharArray.lastIndexOf(sub: CharArray, starting: Int = 0): Int

fun DoubleArray.lastIndexOf(sub: DoubleArray, starting: Int = 0): Int

fun FloatArray.lastIndexOf(sub: FloatArray, starting: Int = 0): Int

fun IntArray.lastIndexOf(sub: IntArray, starting: Int = 0): Int

fun LongArray.lastIndexOf(sub: LongArray, starting: Int = 0): Int

fun ShortArray.lastIndexOf(sub: ShortArray, starting: Int = 0): Int

limitSafe

fun Buffer.limitSafe(newLimit: Int)

positionSafe

fun Buffer.positionSafe(newPosition: Int)

read

fun <T> ByteArray.read(offset: Int = 0, size: Int = this.size, callback: ByteArrayReader.() -> T): T

readBE

fun <T> ByteArray.readBE(offset: Int = 0, size: Int = this.size, callback: ByteArrayReaderBE.() -> T): T

reader

fun ByteArray.reader(offset: Int = 0, size: Int = this.size): ByteArrayReader

readerBE

fun ByteArray.readerBE(offset: Int = 0, size: Int = this.size): ByteArrayReaderBE

readerLE

fun ByteArray.readerLE(offset: Int = 0, size: Int = this.size): ByteArrayReaderLE

readLE

fun <T> ByteArray.readLE(offset: Int = 0, size: Int = this.size, callback: ByteArrayReaderLE.() -> T): T

s16

fun ByteArrayReaderBE.s16(): Int

fun ByteArrayReaderLE.s16(): Int

s24

fun ByteArrayReaderBE.s24(): Int

fun ByteArrayReaderLE.s24(): Int

s32

fun ByteArrayReaderBE.s32(): Int

fun ByteArrayReaderLE.s32(): Int

fun ByteArrayReaderBE.s8(): Int

fun ByteArrayReaderLE.s8(): Int

set16

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

fun ByteArray.set16(offset: Int, value: Int, littleEndian: Boolean)

set16BE

fun ByteArray.set16BE(offset: Int, value: Int)

set16BEClamped

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

set16Clamped

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

set16LE

fun ByteArray.set16LE(offset: Int, value: Int)

set16LEClamped

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

set24

fun ByteArray.set24(offset: Int, value: Int, littleEndian: Boolean)

set24BE

fun ByteArray.set24BE(offset: Int, value: Int)

set24LE

fun ByteArray.set24LE(offset: Int, value: Int)

set32

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

fun ByteArray.set32(offset: Int, value: Int, littleEndian: Boolean)

set32BE

fun ByteArray.set32BE(offset: Int, value: Int)

fun ByteArray.set32BE(offset: Int, value: Long)

set32LE

fun ByteArray.set32LE(offset: Int, value: Int)

fun ByteArray.set32LE(offset: Int, value: Long)

set64

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

fun ByteArray.set64(offset: Int, value: Long, littleEndian: Boolean)

set64BE

fun ByteArray.set64BE(offset: Int, value: Long)

set64LE

fun ByteArray.set64LE(offset: Int, value: Long)

set8

fun ByteArray.set8(offset: Int, value: Int)

fun ByteArray.set8(offset: Int, value: Long)

set8Clamped

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

setArray

fun ByteArray.setArray(offset: Int, bytes: ByteArray)

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 ByteArray.setArrayBE(offset: Int, array: CharArray)

fun ByteArray.setArrayBE(offset: Int, array: DoubleArray)

fun ByteArray.setArrayBE(offset: Int, array: FloatArray)

fun ByteArray.setArrayBE(offset: Int, array: IntArray)

fun ByteArray.setArrayBE(offset: Int, array: LongArray)

fun ByteArray.setArrayBE(offset: Int, array: ShortArray)

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 ByteArray.setArrayLE(offset: Int, array: CharArray)

fun ByteArray.setArrayLE(offset: Int, array: DoubleArray)

fun ByteArray.setArrayLE(offset: Int, array: FloatArray)

fun ByteArray.setArrayLE(offset: Int, array: IntArray)

fun ByteArray.setArrayLE(offset: Int, array: LongArray)

fun ByteArray.setArrayLE(offset: Int, array: ShortArray)

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)

setBytes

fun ByteArray.setBytes(offset: Int, bytes: ByteArray)

setF32

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

fun ByteArray.setF32(offset: Int, value: Float, littleEndian: Boolean)

setF32BE

fun ByteArray.setF32BE(offset: Int, value: Float)

setF32LE

fun ByteArray.setF32LE(offset: Int, value: Float)

setF64

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

fun ByteArray.setF64(offset: Int, value: Double, littleEndian: Boolean)

setF64BE

fun ByteArray.setF64BE(offset: Int, value: Double)

setF64LE

fun ByteArray.setF64LE(offset: 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 ByteBuffer.sliceBuffer(offset: Int, size: Int): ByteBuffer

fun DoubleBuffer.sliceBuffer(offset: Int, size: Int): DoubleBuffer

fun FloatBuffer.sliceBuffer(offset: Int, size: Int): FloatBuffer

fun IntBuffer.sliceBuffer(offset: Int, size: Int): IntBuffer

fun ShortBuffer.sliceBuffer(offset: Int, size: Int): ShortBuffer

inline fun <T : Buffer> T.sliceBuffer(offset: Int, size: Int, dup: (T) -> T): T

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

fun ByteBuffer.sliceBuffer(offset: Int, size: Int): ByteBuffer

fun DoubleBuffer.sliceBuffer(offset: Int, size: Int): DoubleBuffer

fun FloatBuffer.sliceBuffer(offset: Int, size: Int): FloatBuffer

fun IntBuffer.sliceBuffer(offset: Int, size: Int): IntBuffer

fun ShortBuffer.sliceBuffer(offset: Int, size: Int): ShortBuffer

inline fun <T : Buffer> T.sliceBuffer(offset: Int, size: Int, dup: (T) -> T): T

sliceWithSize

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

toByteArray

fun ArrayBuffer.toByteArray(): ByteArray

toDoubleArray

fun ArrayBuffer.toDoubleArray(): DoubleArray

toFloatArray

fun BaseFloatBuffer.toFloatArray(): FloatArray

fun ArrayBuffer.toFloatArray(): FloatArray

toIntArray

fun BaseIntBuffer.toIntArray(): IntArray

fun ArrayBuffer.toIntArray(): IntArray

toNBufferUInt8

fun ByteArray.toNBufferUInt8(): Uint8Buffer

toShortArray

fun ArrayBuffer.toShortArray(): ShortArray

toUByteArray

fun ArrayBuffer.toUByteArray(): UByteArray

u16

fun ByteArrayReaderBE.u16(): Int

fun ByteArrayReaderLE.u16(): Int

u24

fun ByteArrayReaderBE.u24(): Int

fun ByteArrayReaderLE.u24(): Int

u32

fun ByteArrayReaderBE.u32(): Long

fun ByteArrayReaderLE.u32(): Long

fun ByteArrayReaderBE.u8(): Int

fun ByteArrayReaderLE.u8(): Int

ubyteArrayIntOf

fun ubyteArrayIntOf(vararg values: Int): UByteArrayInt

ushortArrayIntOf

fun ushortArrayIntOf(vararg values: Int): UShortArrayInt