Memory

expect class Memory

Represents a linear range of bytes. All operations are guarded by range-checks by default however at some platforms they could be disabled in release builds.

Instance of this class has no additional state except the bytes themselves.

actual class Memory

Represents a linear range of bytes.

@JvmInline

actual value class Memory

actual class Memory

Constructors

Memory

fun Memory(view: DataView)

Types

Companion

expect object Companion

actual object Companion

Functions

copyTo

expect fun copyTo(destination: Memory, offset: Int, length: Int, destinationOffset: Int)

expect fun copyTo(destination: Memory, offset: Long, length: Long, destinationOffset: Long)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset. Copying bytes from a memory to itself is allowed.

actual fun copyTo(destination: Memory, offset: Int, length: Int, destinationOffset: Int)

actual fun copyTo(destination: Memory, offset: Long, length: Long, destinationOffset: Long)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset. Copying bytes from a memory to itself is allowed.

actual fun copyTo(destination: Memory, offset: Int, length: Int, destinationOffset: Int)

actual fun copyTo(destination: Memory, offset: Long, length: Long, destinationOffset: Long)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset. Copying bytes from a memory to itself is allowed.

actual fun copyTo(destination: Memory, offset: Int, length: Int, destinationOffset: Int)

actual fun copyTo(destination: Memory, offset: Long, length: Long, destinationOffset: Long)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset. Copying bytes from a memory to itself is allowed.

loadAt

expect inline fun loadAt(index: Int): Byte

expect inline fun loadAt(index: Long): Byte

Returns byte at index position.

actual inline fun loadAt(index: Int): Byte

actual inline fun loadAt(index: Long): Byte

Returns byte at index position.

actual inline fun loadAt(index: Int): Byte

actual inline fun loadAt(index: Long): Byte

Returns byte at index position.

actual inline fun loadAt(index: Int): Byte

actual inline fun loadAt(index: Long): Byte

Returns byte at index position.

slice

expect fun slice(offset: Int, length: Int): Memory

expect fun slice(offset: Long, length: Long): Memory

Returns memory's subrange. On some platforms it could do range checks but it is not guaranteed to be safe. It also could lead to memory allocations on some platforms.

actual fun slice(offset: Int, length: Int): Memory

actual fun slice(offset: Long, length: Long): Memory

Returns memory's subrange. On some platforms it could do range checks but it is not guaranteed to be safe. It also could lead to memory allocations on some platforms.

actual fun slice(offset: Int, length: Int): Memory

actual fun slice(offset: Long, length: Long): Memory

actual fun slice(offset: Int, length: Int): Memory

actual fun slice(offset: Long, length: Long): Memory

storeAt

expect inline fun storeAt(index: Int, value: Byte)

Write value at the specified index.

expect inline fun storeAt(index: Long, value: Byte)

Write value at the specified index

actual inline fun storeAt(index: Int, value: Byte)

Write value at the specified index.

actual inline fun storeAt(index: Long, value: Byte)

Write value at the specified index

actual inline fun storeAt(index: Int, value: Byte)

Write value at the specified index.

actual inline fun storeAt(index: Long, value: Byte)

Write value at the specified index

actual inline fun storeAt(index: Int, value: Byte)

Write value at the specified index.

actual inline fun storeAt(index: Long, value: Byte)

Write value at the specified index

Properties

buffer

val buffer: ByteBuffer

pointer

val pointer: <ERROR CLASS><<ERROR CLASS>>

size

expect val size: Long

Size of memory range in bytes.

actual val size: Long

Size of memory range in bytes.

actual val size: Long

Size of memory range in bytes.

actual val size: Long

size32

expect val size32: Int

Size of memory range in bytes represented as signed 32bit integer

actual val size32: Int

Size of memory range in bytes represented as signed 32bit integer

actual val size32: Int

Size of memory range in bytes represented as signed 32bit integer

actual val size32: Int

Size of memory range in bytes represented as signed 32bit integer

view

val view: DataView

Extensions

copyTo

fun Memory.copyTo(destination: ByteArray, offset: Int, length: Int)

fun Memory.copyTo(destination: ByteArray, offset: Long, length: Int)

Copies bytes from this memory range from the specified offset and length to the destination.

expect fun Memory.copyTo(destination: ByteArray, offset: Int, length: Int, destinationOffset: Int)

expect fun Memory.copyTo(destination: ByteArray, offset: Long, length: Int, destinationOffset: Int)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset.

fun Memory.copyTo(destination: ArrayBuffer, offset: Int, length: Int, destinationOffset: Int)

fun Memory.copyTo(destination: ArrayBufferView, offset: Int, length: Int, destinationOffset: Int)

actual fun Memory.copyTo(destination: ByteArray, offset: Int, length: Int, destinationOffset: Int)

actual fun Memory.copyTo(destination: ByteArray, offset: Long, length: Int, destinationOffset: Int)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset.

fun Memory.copyTo(destination: ByteBuffer, offset: Int)

fun Memory.copyTo(destination: ByteBuffer, offset: Long)

Copies bytes from this memory range from the specified offset to the destination buffer.

actual fun Memory.copyTo(destination: ByteArray, offset: Int, length: Int, destinationOffset: Int)

actual fun Memory.copyTo(destination: ByteArray, offset: Long, length: Int, destinationOffset: Int)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset.

fun Memory.copyTo(destination: <ERROR CLASS><<ERROR CLASS>>, offset: Int, length: Int, destinationOffset: Int)

fun Memory.copyTo(destination: <ERROR CLASS><<ERROR CLASS>>, offset: Long, length: Long, destinationOffset: Long)

Copy content bytes to the memory addressed by the destination pointer with the specified destinationOffset in bytes.

actual fun Memory.copyTo(destination: ByteArray, offset: Int, length: Int, destinationOffset: Int)

actual fun Memory.copyTo(destination: ByteArray, offset: Long, length: Int, destinationOffset: Int)

Copies bytes from this memory range from the specified offset and length to the destination at destinationOffset.

fill

expect fun Memory.fill(offset: Long, count: Long, value: Byte)

expect fun Memory.fill(offset: Int, count: Int, value: Byte)

Fill memory range starting at the specified offset with value repeated count times.

actual fun Memory.fill(offset: Long, count: Long, value: Byte)

actual fun Memory.fill(offset: Int, count: Int, value: Byte)

Fill memory range starting at the specified offset with value repeated count times.

actual fun Memory.fill(offset: Long, count: Long, value: Byte)

actual fun Memory.fill(offset: Int, count: Int, value: Byte)

Fill memory range starting at the specified offset with value repeated count times.

actual fun Memory.fill(offset: Long, count: Long, value: Byte)

actual fun Memory.fill(offset: Int, count: Int, value: Byte)

Fill memory range starting at the specified offset with value repeated count times.

get

inline operator fun Memory.get(index: Int): Byte

inline operator fun Memory.get(index: Long): Byte

Read byte at the specified index.

loadByteArray

inline fun Memory.loadByteArray(offset: Int, destination: ByteArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies bytes from this memory range from the specified offset and count to the destination at destinationOffset.

inline fun Memory.loadByteArray(offset: Long, destination: ByteArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies unsigned shorts integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadDoubleArray

expect fun Memory.loadDoubleArray(offset: Int, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

expect fun Memory.loadDoubleArray(offset: Long, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadDoubleArray(offset: Int, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadDoubleArray(offset: Long, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadDoubleArray(offset: Int, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadDoubleArray(offset: Long, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadDoubleArray(offset: Int, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadDoubleArray(offset: Long, destination: DoubleArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadDoubleAt

expect inline fun Memory.loadDoubleAt(offset: Int): Double

expect inline fun Memory.loadDoubleAt(offset: Long): Double

Read short signed 64bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.loadDoubleAt(offset: Int): Double

actual inline fun Memory.loadDoubleAt(offset: Long): Double

actual inline fun Memory.loadDoubleAt(offset: Int): Double

actual inline fun Memory.loadDoubleAt(offset: Long): Double

actual inline fun Memory.loadDoubleAt(offset: Int): Double

actual inline fun Memory.loadDoubleAt(offset: Long): Double

loadFloatArray

expect fun Memory.loadFloatArray(offset: Int, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

expect fun Memory.loadFloatArray(offset: Long, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadFloatArray(offset: Int, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadFloatArray(offset: Long, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadFloatArray(offset: Int, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadFloatArray(offset: Long, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadFloatArray(offset: Int, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadFloatArray(offset: Long, destination: FloatArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies floating point numbers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadFloatAt

expect inline fun Memory.loadFloatAt(offset: Int): Float

expect inline fun Memory.loadFloatAt(offset: Long): Float

Read short signed 32bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.loadFloatAt(offset: Int): Float

actual inline fun Memory.loadFloatAt(offset: Long): Float

actual inline fun Memory.loadFloatAt(offset: Int): Float

actual inline fun Memory.loadFloatAt(offset: Long): Float

actual inline fun Memory.loadFloatAt(offset: Int): Float

actual inline fun Memory.loadFloatAt(offset: Long): Float

loadIntArray

expect fun Memory.loadIntArray(offset: Int, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

expect fun Memory.loadIntArray(offset: Long, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies regular integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadIntArray(offset: Int, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadIntArray(offset: Long, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies regular integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadIntArray(offset: Int, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadIntArray(offset: Long, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies regular integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadIntArray(offset: Int, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadIntArray(offset: Long, destination: IntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies regular integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadIntAt

expect inline fun Memory.loadIntAt(offset: Int): Int

expect inline fun Memory.loadIntAt(offset: Long): Int

Read regular signed 32bit integer in the network byte order (Big Endian)

actual inline fun Memory.loadIntAt(offset: Int): Int

actual inline fun Memory.loadIntAt(offset: Long): Int

actual inline fun Memory.loadIntAt(offset: Int): Int

actual inline fun Memory.loadIntAt(offset: Long): Int

actual inline fun Memory.loadIntAt(offset: Int): Int

actual inline fun Memory.loadIntAt(offset: Long): Int

loadLongArray

expect fun Memory.loadLongArray(offset: Int, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

expect fun Memory.loadLongArray(offset: Long, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies long integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadLongArray(offset: Int, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadLongArray(offset: Long, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies regular integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadLongArray(offset: Int, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadLongArray(offset: Long, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies regular integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadLongArray(offset: Int, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadLongArray(offset: Long, destination: LongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies regular integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadLongAt

expect inline fun Memory.loadLongAt(offset: Int): Long

expect inline fun Memory.loadLongAt(offset: Long): Long

Read short signed 64bit integer in the network byte order (Big Endian)

actual inline fun Memory.loadLongAt(offset: Int): Long

actual inline fun Memory.loadLongAt(offset: Long): Long

actual inline fun Memory.loadLongAt(offset: Int): Long

actual inline fun Memory.loadLongAt(offset: Long): Long

actual inline fun Memory.loadLongAt(offset: Int): Long

actual inline fun Memory.loadLongAt(offset: Long): Long

loadShortArray

expect fun Memory.loadShortArray(offset: Int, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

expect fun Memory.loadShortArray(offset: Long, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies short integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadShortArray(offset: Int, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadShortArray(offset: Long, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies short integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadShortArray(offset: Int, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadShortArray(offset: Long, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies short integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

actual fun Memory.loadShortArray(offset: Int, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

actual fun Memory.loadShortArray(offset: Long, destination: ShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies short integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadShortAt

expect inline fun Memory.loadShortAt(offset: Int): Short

expect inline fun Memory.loadShortAt(offset: Long): Short

Read short signed 16bit integer in the network byte order (Big Endian)

actual inline fun Memory.loadShortAt(offset: Int): Short

actual inline fun Memory.loadShortAt(offset: Long): Short

actual inline fun Memory.loadShortAt(offset: Int): Short

actual inline fun Memory.loadShortAt(offset: Long): Short

actual inline fun Memory.loadShortAt(offset: Int): Short

actual inline fun Memory.loadShortAt(offset: Long): Short

loadUByteArray

inline fun Memory.loadUByteArray(offset: Int, destination: UByteArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

inline fun Memory.loadUByteArray(offset: Long, destination: UByteArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies unsigned shorts integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadUIntArray

inline fun Memory.loadUIntArray(offset: Int, destination: UIntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

inline fun Memory.loadUIntArray(offset: Long, destination: UIntArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies unsigned integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadUIntAt

inline fun Memory.loadUIntAt(offset: Int): UInt

inline fun Memory.loadUIntAt(offset: Long): UInt

Read regular unsigned 32bit integer in the network byte order (Big Endian)

loadULongArray

inline fun Memory.loadULongArray(offset: Int, destination: ULongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

inline fun Memory.loadULongArray(offset: Long, destination: ULongArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies unsigned long integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadULongAt

inline fun Memory.loadULongAt(offset: Int): ULong

inline fun Memory.loadULongAt(offset: Long): ULong

Read short signed 64bit integer in the network byte order (Big Endian)

loadUShortArray

inline fun Memory.loadUShortArray(offset: Int, destination: UShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

inline fun Memory.loadUShortArray(offset: Long, destination: UShortArray, destinationOffset: Int = 0, count: Int = destination.size - destinationOffset)

Copies unsigned shorts integers from this memory range from the specified offset and count to the destination at destinationOffset interpreting numbers in the network order (Big Endian).

loadUShortAt

inline fun Memory.loadUShortAt(offset: Int): UShort

inline fun Memory.loadUShortAt(offset: Long): UShort

Read short unsigned 16bit integer in the network byte order (Big Endian)

set

inline operator fun Memory.set(index: Long, value: Byte)

inline operator fun Memory.set(index: Int, value: Byte)

Index write operator to write value at the specified index

storeAt

inline fun Memory.storeAt(index: Long, value: UByte)

inline fun Memory.storeAt(index: Int, value: UByte)

Index write operator to write value at the specified index

storeByteArray

inline fun Memory.storeByteArray(offset: Int, source: ByteArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

inline fun Memory.storeByteArray(offset: Long, source: ByteArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies unsigned shorts integers from the source array at sourceOffset to this memory at the specified offset.

storeDoubleArray

expect fun Memory.storeDoubleArray(offset: Int, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

expect fun Memory.storeDoubleArray(offset: Long, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeDoubleArray(offset: Int, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeDoubleArray(offset: Long, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeDoubleArray(offset: Int, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeDoubleArray(offset: Long, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeDoubleArray(offset: Int, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeDoubleArray(offset: Long, source: DoubleArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeDoubleAt

expect inline fun Memory.storeDoubleAt(offset: Int, value: Double)

expect inline fun Memory.storeDoubleAt(offset: Long, value: Double)

Write short signed 64bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.storeDoubleAt(offset: Int, value: Double)

actual inline fun Memory.storeDoubleAt(offset: Long, value: Double)

Write short signed 64bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.storeDoubleAt(offset: Int, value: Double)

actual inline fun Memory.storeDoubleAt(offset: Long, value: Double)

Write short signed 64bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.storeDoubleAt(offset: Int, value: Double)

actual inline fun Memory.storeDoubleAt(offset: Long, value: Double)

Write short signed 64bit floating point number in the network byte order (Big Endian)

storeFloatArray

expect fun Memory.storeFloatArray(offset: Int, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

expect fun Memory.storeFloatArray(offset: Long, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeFloatArray(offset: Int, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeFloatArray(offset: Long, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeFloatArray(offset: Int, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeFloatArray(offset: Long, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeFloatArray(offset: Int, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeFloatArray(offset: Long, source: FloatArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies floating point numbers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeFloatAt

expect inline fun Memory.storeFloatAt(offset: Int, value: Float)

expect inline fun Memory.storeFloatAt(offset: Long, value: Float)

Write short signed 32bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.storeFloatAt(offset: Int, value: Float)

actual inline fun Memory.storeFloatAt(offset: Long, value: Float)

Write short signed 32bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.storeFloatAt(offset: Int, value: Float)

actual inline fun Memory.storeFloatAt(offset: Long, value: Float)

Write short signed 32bit floating point number in the network byte order (Big Endian)

actual inline fun Memory.storeFloatAt(offset: Int, value: Float)

actual inline fun Memory.storeFloatAt(offset: Long, value: Float)

Write short signed 32bit floating point number in the network byte order (Big Endian)

storeIntArray

expect fun Memory.storeIntArray(offset: Int, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

expect fun Memory.storeIntArray(offset: Long, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies regular integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeIntArray(offset: Int, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeIntArray(offset: Long, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies regular integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeIntArray(offset: Int, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeIntArray(offset: Long, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies regular integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeIntArray(offset: Int, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeIntArray(offset: Long, source: IntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies regular integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeIntAt

expect inline fun Memory.storeIntAt(offset: Int, value: Int)

expect inline fun Memory.storeIntAt(offset: Long, value: Int)

Write regular signed 32bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeIntAt(offset: Int, value: Int)

actual inline fun Memory.storeIntAt(offset: Long, value: Int)

Write regular signed 32bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeIntAt(offset: Int, value: Int)

actual inline fun Memory.storeIntAt(offset: Long, value: Int)

Write regular signed 32bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeIntAt(offset: Int, value: Int)

actual inline fun Memory.storeIntAt(offset: Long, value: Int)

Write regular signed 32bit integer in the network byte order (Big Endian)

storeLongArray

expect fun Memory.storeLongArray(offset: Int, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

expect fun Memory.storeLongArray(offset: Long, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies long integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeLongArray(offset: Int, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeLongArray(offset: Long, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies regular integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeLongArray(offset: Int, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeLongArray(offset: Long, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies regular integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeLongArray(offset: Int, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeLongArray(offset: Long, source: LongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies regular integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeLongAt

expect inline fun Memory.storeLongAt(offset: Int, value: Long)

Write short signed 64bit integer in the network byte order (Big Endian)

expect inline fun Memory.storeLongAt(offset: Long, value: Long)

write short signed 64bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeLongAt(offset: Int, value: Long)

actual inline fun Memory.storeLongAt(offset: Long, value: Long)

Write short signed 64bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeLongAt(offset: Int, value: Long)

actual inline fun Memory.storeLongAt(offset: Long, value: Long)

Write short signed 64bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeLongAt(offset: Int, value: Long)

actual inline fun Memory.storeLongAt(offset: Long, value: Long)

Write short signed 64bit integer in the network byte order (Big Endian)

storeShortArray

expect fun Memory.storeShortArray(offset: Int, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

expect fun Memory.storeShortArray(offset: Long, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies short integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeShortArray(offset: Int, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeShortArray(offset: Long, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies short integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeShortArray(offset: Int, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeShortArray(offset: Long, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies short integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

actual fun Memory.storeShortArray(offset: Int, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

actual fun Memory.storeShortArray(offset: Long, source: ShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies short integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeShortAt

expect inline fun Memory.storeShortAt(offset: Int, value: Short)

expect inline fun Memory.storeShortAt(offset: Long, value: Short)

Write short signed 16bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeShortAt(offset: Int, value: Short)

actual inline fun Memory.storeShortAt(offset: Long, value: Short)

Write short signed 16bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeShortAt(offset: Int, value: Short)

actual inline fun Memory.storeShortAt(offset: Long, value: Short)

Write short signed 16bit integer in the network byte order (Big Endian)

actual inline fun Memory.storeShortAt(offset: Int, value: Short)

actual inline fun Memory.storeShortAt(offset: Long, value: Short)

Write short signed 16bit integer in the network byte order (Big Endian)

storeUByteArray

inline fun Memory.storeUByteArray(offset: Int, source: UByteArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

inline fun Memory.storeUByteArray(offset: Long, source: UByteArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies unsigned shorts integers from the source array at sourceOffset to this memory at the specified offset.

storeUIntArray

inline fun Memory.storeUIntArray(offset: Int, source: UIntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

inline fun Memory.storeUIntArray(offset: Long, source: UIntArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies unsigned integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeUIntAt

inline fun Memory.storeUIntAt(offset: Int, value: UInt)

inline fun Memory.storeUIntAt(offset: Long, value: UInt)

Write regular unsigned 32bit integer in the network byte order (Big Endian)

storeULongArray

inline fun Memory.storeULongArray(offset: Int, source: ULongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

inline fun Memory.storeULongArray(offset: Long, source: ULongArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies unsigned long integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeULongAt

inline fun Memory.storeULongAt(offset: Int, value: ULong)

inline fun Memory.storeULongAt(offset: Long, value: ULong)

Write short signed 64bit integer in the network byte order (Big Endian)

storeUShortArray

inline fun Memory.storeUShortArray(offset: Int, source: UShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

inline fun Memory.storeUShortArray(offset: Long, source: UShortArray, sourceOffset: Int = 0, count: Int = source.size - sourceOffset)

Copies unsigned shorts integers from the source array at sourceOffset to this memory at the specified offset interpreting numbers in the network order (Big Endian).

storeUShortAt

inline fun Memory.storeUShortAt(offset: Int, value: UShort)

inline fun Memory.storeUShortAt(offset: Long, value: UShort)

Write short unsigned 16bit integer in the network byte order (Big Endian)