korge-foundation/korlibs.memory

Package-level declarations

Types

BaseBuffer

interface BaseBuffer

BaseFloatBuffer

interface BaseFloatBuffer : BaseBuffer

BaseIntBuffer

interface BaseIntBuffer : BaseBuffer

Buffer

expect class Buffer

actual class Buffer

ByteArrayBuilder

class ByteArrayBuilder(var data: ByteArray, size: Int = data.size, val allowGrow: Boolean = true)

Analogous to StringBuilder but for ByteArray. Allows to append values to end calling toByteArray. Provides some methods like s16LE or f32BE to append specific bit representations easily.

ByteArrayBuilderBE

inline class ByteArrayBuilderBE(val bab: ByteArrayBuilder)

ByteArrayBuilderLE

inline class ByteArrayBuilderLE(val bab: ByteArrayBuilder)

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>?)

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

_high

val Long._high: Int

Get high 32-bits of this Long

_low

val Long._low: Int

Get low 32-bits of this Long

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

high

val Long.high: Int

Get high 32-bits of this Long

i16

val Buffer.~~i16~~: Int16Buffer

i32

val Buffer.~~i32~~: Int32Buffer

i64

val Buffer.~~i64~~: Int64Buffer

val Buffer.i8: Int8Buffer

KmemGC

expect val KmemGC: KmemGCImpl

actual val KmemGC: KmemGCImpl

low

val Long.low: Int

Get low 32-bits of this Long

nioBuffer

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

nioFloatBuffer

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

nioIntBuffer

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

remaining

val ByteArrayReaderBE.remaining: Int

val ByteArrayReaderLE.remaining: Int

size

val Buffer.size: Int

val ByteArrayBuilderBE.size: Int

val ByteArrayBuilderLE.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

append

fun ByteArrayBuilderBE.append(v: Byte): ByteArrayBuilder

fun ByteArrayBuilderBE.append(vararg v: Byte)

fun ByteArrayBuilderBE.append(vararg v: Int): ByteArrayBuilder

fun ByteArrayBuilderLE.append(v: Byte): ByteArrayBuilder

fun ByteArrayBuilderLE.append(vararg v: Byte)

fun ByteArrayBuilderLE.append(vararg v: Int): ByteArrayBuilder

fun ByteArrayBuilderBE.append(array: ByteArray, offset: Int = 0, len: Int = array.size - offset)

fun ByteArrayBuilderLE.append(array: ByteArray, offset: Int = 0, len: Int = array.size - offset)

appendByte

fun ByteArrayBuilderBE.appendByte(v: Int): ByteArrayBuilder

fun ByteArrayBuilderLE.appendByte(v: Int): ByteArrayBuilder

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

bit

fun bit(bit: Int): Int

Creates an integer with only bit bit set

BufferTemp

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

buildByteArray

inline fun buildByteArray(capacity: Int = 4096, callback: ByteArrayBuilder.() -> Unit): ByteArray

Analogous to buildString but for ByteArray

buildByteArrayBE

inline fun buildByteArrayBE(capacity: Int = 4096, callback: ByteArrayBuilderBE.() -> Unit): ByteArray

Analogous to buildString but for ByteArray (Provides shortcuts for writing Big Endian bit values)

buildByteArrayLE

inline fun buildByteArrayLE(capacity: Int = 4096, callback: ByteArrayBuilderLE.() -> Unit): ByteArray

Analogous to buildString but for ByteArray (Provides shortcuts for writing Little Endian bit values)

clear

fun ByteArrayBuilderBE.clear()

fun ByteArrayBuilderLE.clear()

clearSafe

fun <Error class: unknown class>.clearSafe()

clone

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

copyOf

fun Buffer.copyOf(newSize: Int): Buffer

countLeadingOnes

fun Int.countLeadingOnes(): Int

Returns the number of leading ones of the bits of this integer

countLeadingZeros

inline fun Int.countLeadingZeros(): Int

Returns the number of leading zeros of the bits of this integer

countTrailingOnes

fun Int.countTrailingOnes(): Int

Returns the number of trailing ones of the bits of this integer

countTrailingZeros

fun Int.countTrailingZeros(): Int

Returns the number of trailing zeros of the bits of this integer

extract

inline fun Int.extract(offset: Int): Boolean

Extracts a bits at offset from this (returning a Boolean)

fun Int.extract(offset: Int, count: Int): Int

Extracts count bits at offset from this

extract1

inline fun Int.extract1(offset: Int): Int

Extracts 1 bit at offset from this

extract10

inline fun Int.extract10(offset: Int): Int

Extracts 10 bits at offset from this

extract11

inline fun Int.extract11(offset: Int): Int

Extracts 11 bits at offset from this

extract12

inline fun Int.extract12(offset: Int): Int

Extracts 12 bits at offset from this

extract13

inline fun Int.extract13(offset: Int): Int

Extracts 13 bits at offset from this

extract14

inline fun Int.extract14(offset: Int): Int

Extracts 14 bits at offset from this

extract15

inline fun Int.extract15(offset: Int): Int

Extracts 15 bits at offset from this

extract16

inline fun Int.extract16(offset: Int): Int

Extracts 16 bits at offset from this

extract16Signed

fun Int.extract16Signed(offset: Int): Int

Extracts 16 bits at offset from this sign-extending its result

extract2

inline fun Int.extract2(offset: Int): Int

Extracts 2 bits at offset from this

extract24

inline fun Int.extract24(offset: Int): Int

Extracts 24 bits at offset from this

extract3

inline fun Int.extract3(offset: Int): Int

Extracts 3 bits at offset from this

extract4

inline fun Int.extract4(offset: Int): Int

Extracts 4 bits at offset from this

extract5

inline fun Int.extract5(offset: Int): Int

Extracts 5 bits at offset from this

extract6

inline fun Int.extract6(offset: Int): Int

Extracts 6 bits at offset from this

extract7

inline fun Int.extract7(offset: Int): Int

Extracts 7 bits at offset from this

extract8

inline fun Int.extract8(offset: Int): Int

Extracts 8 bits at offset from this

extract8Signed

fun Int.extract8Signed(offset: Int): Int

Extracts 8 bits at offset from this sign-extending its result

extract9

inline fun Int.extract9(offset: Int): Int

Extracts 9 bits at offset from this

extractBool

inline fun Int.extractBool(offset: Int): Boolean

Extracts a bits at offset from this (returning a Boolean)

extractByte

fun Int.extractByte(offset: Int): Byte

Extracts 8 bits at offset from this as Byte

extractScaled

fun Int.extractScaled(offset: Int, count: Int, scale: Int): Int

Extracts count at offset from this and convert the possible values into the range 0x00..scale

extractScaledf01

fun Int.extractScaledf01(offset: Int, count: Int): Float

Extracts count at offset from this and convert the possible values into the range 0.0..1.0

extractScaledFF

fun Int.extractScaledFF(offset: Int, count: Int): Int

Extracts count at offset from this and convert the possible values into the range 0x00..0xFF

extractScaledFFDefault

fun Int.extractScaledFFDefault(offset: Int, count: Int, default: Int): Int

Extracts count at offset from this and convert the possible values into the range 0x00..0xFF (if there are 0 bits, returns default)

extractShort

fun Int.extractShort(offset: Int): Short

Extracts 16 bits at offset from this as Short

extractSigned

fun Int.extractSigned(offset: Int, count: Int): Int

Extracts count bits at offset from this sign-extending its result

f16

fun ByteArrayReaderBE.f16(): Half

fun ByteArrayReaderLE.f16(): Half

fun ByteArrayBuilderBE.f16(v: Half): ByteArrayBuilder

fun ByteArrayBuilderLE.f16(v: Half): ByteArrayBuilder

f32

fun ByteArrayReaderBE.f32(): Float

fun ByteArrayReaderLE.f32(): Float

fun ByteArrayBuilderBE.f32(v: Float): ByteArrayBuilder

fun ByteArrayBuilderLE.f32(v: Float): ByteArrayBuilder

f64

fun ByteArrayReaderBE.f64(): Double

fun ByteArrayReaderLE.f64(): Double

fun ByteArrayBuilderBE.f64(v: Double): ByteArrayBuilder

fun ByteArrayBuilderLE.f64(v: Double): ByteArrayBuilder

fastForEachOneBits

inline fun Int.fastForEachOneBits(block: (Int) -> Unit)

finsert

fun Int.finsert(value: Boolean, offset: Int): Int

fun Int.finsert(value: Int, offset: Int): Int

Fast Insert: do not clear bits, assume affecting bits are 0

finsert1

fun Int.finsert1(value: Int, offset: Int): Int

finsert12

fun Int.finsert12(value: Int, offset: Int): Int

finsert16

fun Int.finsert16(value: Int, offset: Int): Int

finsert2

fun Int.finsert2(value: Int, offset: Int): Int

finsert24

fun Int.finsert24(value: Int, offset: Int): Int

finsert3

fun Int.finsert3(value: Int, offset: Int): Int

finsert4

fun Int.finsert4(value: Int, offset: Int): Int

finsert5

fun Int.finsert5(value: Int, offset: Int): Int

finsert6

fun Int.finsert6(value: Int, offset: Int): Int

finsert7

fun Int.finsert7(value: Int, offset: Int): Int

finsert8

fun Int.finsert8(value: Int, offset: Int): Int

flipSafe

fun <Error class: unknown class>.flipSafe()

fromLowHigh

fun Long.Companion.fromLowHigh(low: Int, high: Int): Long

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

getF16

fun ByteArray.getF16(offset: Int, littleEndian: Boolean): Half

getF16BE

fun ByteArray.getF16BE(offset: Int): Half

getF16LE

fun ByteArray.getF16LE(offset: Int): Half

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

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

hasBits

infix fun Int.hasBits(bits: Int): Boolean

infix fun Long.hasBits(bits: Long): Boolean

hasBitSet

infix fun Int.hasBitSet(index: Int): Boolean

Check if a specific bit at index is set

hasFlags

infix fun Int.hasFlags(bits: Int): Boolean

Check if this has all the bits set in bits set

infix fun Long.hasFlags(bits: Long): Boolean

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

insert

fun Int.insert(value: Boolean, offset: Int): Int

Replaces 1 bit at offset with value and returns the result of doing such replacement

fun Int.insert(value: Int, offset: Int, count: Int): Int

Replaces this bits from offset to offset+count with value and returns the result of doing such replacement

insert1

fun Int.insert1(value: Int, offset: Int): Int

insert10

fun Int.insert10(value: Int, offset: Int): Int

insert11

fun Int.insert11(value: Int, offset: Int): Int

insert12

fun Int.insert12(value: Int, offset: Int): Int

insert13

fun Int.insert13(value: Int, offset: Int): Int

insert14

fun Int.insert14(value: Int, offset: Int): Int

insert15

fun Int.insert15(value: Int, offset: Int): Int

insert16

fun Int.insert16(value: Int, offset: Int): Int

insert2

fun Int.insert2(value: Int, offset: Int): Int

insert24

fun Int.insert24(value: Int, offset: Int): Int

insert3

fun Int.insert3(value: Int, offset: Int): Int

insert4

fun Int.insert4(value: Int, offset: Int): Int

insert5

fun Int.insert5(value: Int, offset: Int): Int

insert6

fun Int.insert6(value: Int, offset: Int): Int

insert7

fun Int.insert7(value: Int, offset: Int): Int

insert8

fun Int.insert8(value: Int, offset: Int): Int

insert9

fun Int.insert9(value: Int, offset: Int): Int

insertMask

inline fun Int.insertMask(value: Int, offset: Int, mask: Int): Int

insertScaled

fun Int.insertScaled(value: Int, offset: Int, count: Int, scale: Int): Int

insertScaledf01

fun Int.insertScaledf01(value: Float, offset: Int, count: Int): Int

Extracts count at offset from this and convert the possible values into the range 0.0..1.0

insertScaledFF

fun Int.insertScaledFF(value: Int, offset: Int, count: Int): 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 <Error class: unknown class>.limitSafe(newLimit: Int)

mask

fun Int.mask(): Int

Creates an Int with this bits set to 1

fun Long.mask(): Long

Creates a Long with this bits set to 1

positionSafe

fun <Error class: unknown class>.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

readByteArray

fun ByteArray.~~readByteArray~~(o: Int, count: Int): ByteArray

readCharArray

fun ByteArray.~~readCharArray~~(o: Int, count: Int, little: Boolean): CharArray

readCharArrayBE

fun ByteArray.~~readCharArrayBE~~(o: Int, count: Int): CharArray

readCharArrayLE

fun ByteArray.~~readCharArrayLE~~(o: Int, count: Int): CharArray

readDoubleArray

fun ByteArray.~~readDoubleArray~~(o: Int, count: Int, little: Boolean): DoubleArray

readDoubleArrayBE

fun ByteArray.~~readDoubleArrayBE~~(o: Int, count: Int): DoubleArray

readDoubleArrayLE

fun ByteArray.~~readDoubleArrayLE~~(o: Int, count: Int): DoubleArray

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

readF16

fun ByteArray.~~readF16~~(o: Int, little: Boolean): Half

readF16BE

fun ByteArray.~~readF16BE~~(o: Int): Half

readF16LE

fun ByteArray.~~readF16LE~~(o: Int): Half

readF32

fun ByteArray.~~readF32~~(o: Int, little: Boolean): Float

readF32BE

fun ByteArray.~~readF32BE~~(o: Int): Float

readF32LE

fun ByteArray.~~readF32LE~~(o: Int): Float

readF64

fun ByteArray.~~readF64~~(o: Int, little: Boolean): Double

readF64BE

fun ByteArray.~~readF64BE~~(o: Int): Double

readF64LE

fun ByteArray.~~readF64LE~~(o: Int): Double

readFloatArray

fun ByteArray.~~readFloatArray~~(o: Int, count: Int, little: Boolean): FloatArray

readFloatArrayBE

fun ByteArray.~~readFloatArrayBE~~(o: Int, count: Int): FloatArray

readFloatArrayLE

fun ByteArray.~~readFloatArrayLE~~(o: Int, count: Int): FloatArray

readIntArray

fun ByteArray.~~readIntArray~~(o: Int, count: Int, little: Boolean): IntArray

readIntArrayBE

fun ByteArray.~~readIntArrayBE~~(o: Int, count: Int): IntArray

readIntArrayLE

fun ByteArray.~~readIntArrayLE~~(o: Int, count: Int): IntArray

readLE

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

readLongArray

fun ByteArray.~~readLongArray~~(o: Int, count: Int, little: Boolean): LongArray

readLongArrayBE

fun ByteArray.~~readLongArrayBE~~(o: Int, count: Int): LongArray

readLongArrayLE

fun ByteArray.~~readLongArrayLE~~(o: Int, count: Int): LongArray

fun ByteArray.~~readS16~~(o: Int, little: Boolean): Int

readS16BE

fun ByteArray.~~readS16BE~~(o: Int): Int

readS16LE

fun ByteArray.~~readS16LE~~(o: Int): Int

fun ByteArray.~~readS24~~(o: Int, little: Boolean): Int

readS24BE

fun ByteArray.~~readS24BE~~(o: Int): Int

readS24LE

fun ByteArray.~~readS24LE~~(o: Int): Int

fun ByteArray.~~readS32~~(o: Int, little: Boolean): Int

readS32BE

fun ByteArray.~~readS32BE~~(o: Int): Int

readS32LE

fun ByteArray.~~readS32LE~~(o: Int): Int

fun ByteArray.~~readS64~~(o: Int, little: Boolean): Long

readS64BE

fun ByteArray.~~readS64BE~~(o: Int): Long

readS64LE

fun ByteArray.~~readS64LE~~(o: Int): Long

fun ByteArray.~~readS8~~(o: Int): Int

readShortArray

fun ByteArray.~~readShortArray~~(o: Int, count: Int, little: Boolean): ShortArray

readShortArrayBE

fun ByteArray.~~readShortArrayBE~~(o: Int, count: Int): ShortArray

readShortArrayLE

fun ByteArray.~~readShortArrayLE~~(o: Int, count: Int): ShortArray

readU16

fun ByteArray.~~readU16~~(o: Int, little: Boolean): Int

readU16BE

fun ByteArray.~~readU16BE~~(o: Int): Int

readU16LE

fun ByteArray.~~readU16LE~~(o: Int): Int

readU24

fun ByteArray.~~readU24~~(o: Int, little: Boolean): Int

readU24BE

fun ByteArray.~~readU24BE~~(o: Int): Int

readU24LE

fun ByteArray.~~readU24LE~~(o: Int): Int

readU32

fun ByteArray.~~readU32~~(o: Int, little: Boolean): Long

readU32BE

fun ByteArray.~~readU32BE~~(o: Int): Long

readU32LE

fun ByteArray.~~readU32LE~~(o: Int): Long

readU8

fun ByteArray.~~readU8~~(o: Int): Int

reinterpretAsDouble

inline fun Long.reinterpretAsDouble(): Double

Returns the float representation of this memory bits

reinterpretAsFloat

inline fun Int.reinterpretAsFloat(): Float

Returns the float representation of this memory bits

reinterpretAsInt

inline fun Float.reinterpretAsInt(): Int

Returns the bits in memory of this float

reinterpretAsLong

inline fun Double.reinterpretAsLong(): Long

Returns the bits in memory of this float

reverseBits

fun Int.reverseBits(): Int

Reverse the bits of this Int: abcdef...z -> z...fedcba

reverseBytes

fun Char.reverseBytes(): Char

Reverses the bytes of this: AABB -> BBAA

fun Int.reverseBytes(): Int

Reverses the bytes of this: AABBCCDD -> DDCCBBAA

fun Long.reverseBytes(): Long

Reverses the bytes of this: AABBCCDDEEFFGGHH -> HHGGFFEEDDCCBBAA

fun Short.reverseBytes(): Short

Reverses the bytes of this: AABB -> BBAA

rotateLeft

fun Int.rotateLeft(bits: Int): Int

fun Long.rotateLeft(bits: Int): Long

fun UInt.rotateLeft(bits: Int): UInt

Rotates this bits to the left

rotateRight

fun Int.rotateRight(bits: Int): Int

fun Long.rotateRight(bits: Int): Long

fun UInt.rotateRight(bits: Int): UInt

Rotates this bits to the right

s16

fun ByteArrayReaderBE.s16(): Int

fun ByteArrayReaderLE.s16(): Int

fun ByteArrayBuilderBE.s16(v: Int): ByteArrayBuilder

fun ByteArrayBuilderLE.s16(v: Int): ByteArrayBuilder

s24

fun ByteArrayReaderBE.s24(): Int

fun ByteArrayReaderLE.s24(): Int

fun ByteArrayBuilderBE.s24(v: Int): ByteArrayBuilder

fun ByteArrayBuilderLE.s24(v: Int): ByteArrayBuilder

s32

fun ByteArrayReaderBE.s32(): Int

fun ByteArrayReaderLE.s32(): Int

fun ByteArrayBuilderBE.s32(v: Int): ByteArrayBuilder

fun ByteArrayBuilderLE.s32(v: Int): ByteArrayBuilder

fun ByteArrayReaderBE.s8(): Int

fun ByteArrayReaderLE.s8(): Int

fun ByteArrayBuilderBE.s8(v: Int): ByteArrayBuilder

fun ByteArrayBuilderLE.s8(v: Int): ByteArrayBuilder

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)

setBits

fun Int.setBits(bits: Int): Int

Returns the integer this with the bits set

fun Int.setBits(bits: Int, set: Boolean): Int

Returns the integer this with the bits set or unset depending on the set parameter

setBytes

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

setF16

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

setF16BE

fun ByteArray.setF16BE(offset: Int, value: Half)

setF16LE

fun ByteArray.setF16LE(offset: Int, value: Half)

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)

signExtend

fun Int.signExtend(bits: Int): Int

Takes nbits of this, and extends the last bit, creating a plain Int in one's complement

fun Long.signExtend(bits: Int): Long

Takes nbits of this, and extends the last bit, creating a plain Long in one's complement

sliceBuffer

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

fun <Error class: unknown class>.sliceBuffer(offset: Int, size: Int): <Error class: unknown class>

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

sliceWithSize

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

toByteArray

fun ByteArrayBuilderBE.toByteArray(): ByteArray

fun ByteArrayBuilderLE.toByteArray(): ByteArray

toFloatArray

fun BaseFloatBuffer.toFloatArray(): FloatArray

toIntArray

fun BaseIntBuffer.toIntArray(): IntArray

toNBufferUInt8

fun ByteArray.toNBufferUInt8(): Uint8Buffer

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

unsetBits

fun Int.unsetBits(bits: Int): Int

Returns the integer this without the bits set

ushortArrayIntOf

fun ushortArrayIntOf(vararg values: Int): UShortArrayInt

with

fun Int.with(bits: Int): Int

fun Long.with(bits: Long): Long

without

fun Int.without(bits: Int): Int

fun Long.without(bits: Long): Long

write16

fun ByteArray.~~write16~~(o: Int, v: Int, little: Boolean)

write16BE

fun ByteArray.~~write16BE~~(o: Int, v: Int)

write16LE

fun ByteArray.~~write16LE~~(o: Int, v: Int)

write24

fun ByteArray.~~write24~~(o: Int, v: Int, little: Boolean)

write24BE

fun ByteArray.~~write24BE~~(o: Int, v: Int)

write24LE

fun ByteArray.~~write24LE~~(o: Int, v: Int)

write32

fun ByteArray.~~write32~~(o: Int, v: Int, little: Boolean)

write32BE

fun ByteArray.~~write32BE~~(o: Int, v: Int)

fun ByteArray.~~write32BE~~(o: Int, v: Long)

write32LE

fun ByteArray.~~write32LE~~(o: Int, v: Int)

fun ByteArray.~~write32LE~~(o: Int, v: Long)

write64

fun ByteArray.~~write64~~(o: Int, v: Long, little: Boolean)

write64BE

fun ByteArray.~~write64BE~~(o: Int, v: Long)

write64LE

fun ByteArray.~~write64LE~~(o: Int, v: Long)

write8

fun ByteArray.~~write8~~(o: Int, v: Int)

fun ByteArray.~~write8~~(o: Int, v: Long)

writeArrayBE

fun ByteArray.~~writeArrayBE~~(o: Int, array: CharArray)

fun ByteArray.~~writeArrayBE~~(o: Int, array: DoubleArray)

fun ByteArray.~~writeArrayBE~~(o: Int, array: FloatArray)

fun ByteArray.~~writeArrayBE~~(o: Int, array: IntArray)

fun ByteArray.~~writeArrayBE~~(o: Int, array: LongArray)

fun ByteArray.~~writeArrayBE~~(o: Int, array: ShortArray)

writeArrayLE

fun ByteArray.~~writeArrayLE~~(o: Int, array: CharArray)

fun ByteArray.~~writeArrayLE~~(o: Int, array: DoubleArray)

fun ByteArray.~~writeArrayLE~~(o: Int, array: FloatArray)

fun ByteArray.~~writeArrayLE~~(o: Int, array: IntArray)

fun ByteArray.~~writeArrayLE~~(o: Int, array: LongArray)

fun ByteArray.~~writeArrayLE~~(o: Int, array: ShortArray)

writeBytes

fun ByteArray.~~writeBytes~~(o: Int, bytes: ByteArray)

writeF16

fun ByteArray.~~writeF16~~(o: Int, v: Half, little: Boolean)

writeF16BE

fun ByteArray.~~writeF16BE~~(o: Int, v: Half)

writeF16LE

fun ByteArray.~~writeF16LE~~(o: Int, v: Half)

writeF32

fun ByteArray.~~writeF32~~(o: Int, v: Float, little: Boolean)

writeF32BE

fun ByteArray.~~writeF32BE~~(o: Int, v: Float)

writeF32LE

fun ByteArray.~~writeF32LE~~(o: Int, v: Float)

writeF64

fun ByteArray.~~writeF64~~(o: Int, v: Double, little: Boolean)

writeF64BE

fun ByteArray.~~writeF64BE~~(o: Int, v: Double)

writeF64LE

fun ByteArray.~~writeF64LE~~(o: Int, v: Double)