Package Summary Overview Summary

### class:MemoryAddress [NONE]
All Superinterfaces: `AddressablePREVIEW` public sealed interface MemoryAddress extends AddressablePREVIEW `MemoryAddress` is a preview API of the Java platform. Programs can only use `MemoryAddress` when preview features are enabled. Preview features may be removed in a future release, or upgraded to permanent features of the Java platform. A memory address models a reference into a memory location. Memory addresses are typically obtained in one of the following ways: By calling `Addressable.address()`PREVIEW on an instance of type `Addressable`PREVIEW (e.g. a memory segment); By invoking a downcall method handle PREVIEW which returns a pointer; By reading an address from memory, e.g. via `MemorySegment.get(ValueLayout.OfAddress, long)` PREVIEW; and By the invocation of an upcall stub PREVIEW which accepts a pointer. A memory address is backed by a raw machine pointer, expressed as a long value . ## Dereferencing memory addresses A memory address can be read or written using various methods provided in this class (e.g. `get(ValueLayout.OfInt, long)` ). Each dereference method takes a value layout PREVIEW, which specifies the size, alignment constraints, byte order as well as the Java type associated with the dereference operation, and an offset. For instance, to read an int from a segment, using default endianness , the following code can be used:
    MemoryAddress address = ...
    int value = address.get(ValueLayout.JAVA_INT, 0);
If the value to be read is stored in memory using `big-endian` encoding, the dereference operation can be expressed as follows:
    MemoryAddress address = ...
    int value = address.get(ValueLayout.JAVA_INT.withOrder(BIG_ENDIAN), 0);
All the dereference methods in this class are restricted: since a memory address does not feature temporal nor spatial bounds, the runtime has no way to check the correctness of the memory dereference operation. Implementation Requirements: Implementations of this interface are immutable, thread-safe and value-based. Since: 19

### field:NULL [NONE]
### NULL static final MemoryAddressPREVIEW NULL The memory address instance modelling the `NULL` address.

### method:toRawLongValue() [NONE]
### toRawLongValue long toRawLongValue() Returns the raw long value associated with this memory address. Returns: the raw long value associated with this memory address

### method:addOffset(long) [NONE]
### addOffset MemoryAddressPREVIEW addOffset (long offset) Returns a memory address at given offset from this address. Parameters: `offset` - specified offset (in bytes), relative to this address, which should be used to create the new address. Might be negative. Returns: a memory address with the given offset from current one.

### method:getUtf8String(long) [NONE]
### getUtf8String String getUtf8String (long offset) Reads a UTF-8 encoded, null-terminated string from this address at the given offset. This method always replaces malformed-input and unmappable-character sequences with this charset's default replacement string. The `CharsetDecoder` class should be used when more control over the decoding process is required. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a Java string constructed from the bytes read from the given starting address (`toRowLongValue() + offset` ) up to (but not including) the first `'\0'` terminator character (assuming one is found). Throws: `IllegalArgumentException` - if the size of the UTF-8 string is greater than the largest string supported by the platform. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setUtf8String(long,java.lang.String) [NONE]
### setUtf8String void setUtf8String (long offset, String str) Writes the given string to this address at the given offset, converting it to a null-terminated byte sequence using UTF-8 encoding. This method always replaces malformed-input and unmappable-character sequences with this charset's default replacement string. The `CharsetDecoder` class should be used when more control over the decoding process is required. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . `str` - the Java string to be written at this address. Throws: `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:equals(java.lang.Object) [NONE]
### equals boolean equals (Object that) Compares the specified object with this address for equality. Returns `true` if and only if the specified object is also an address, and it refers to the same memory location as this address. Overrides: `equals` in class `Object` Parameters: `that` - the object to be compared for equality with this address. Returns: `true` if the specified object is equal to this address. See Also: `Object.hashCode()` `HashMap`

### method:hashCode() [NONE]
### hashCode int hashCode() Returns the hash code value for this address. Overrides: `hashCode` in class `Object` Returns: the hash code value for this address See Also: `Object.equals(java.lang.Object)` `System.identityHashCode(java.lang.Object)`

### method:ofLong(long) [NONE]
### ofLong static MemoryAddressPREVIEW ofLong (long value) Creates a memory address from the given long value. Parameters: `value` - the long value representing a raw address. Returns: a memory address with the given raw long value.

### method:get(java.lang.foreign.ValueLayout.OfByte,long) [NONE]
### get byte get (ValueLayout.OfBytePREVIEW layout, long offset) Reads a byte at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a byte value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfByte,long,byte) [NONE]
### set void set (ValueLayout.OfBytePREVIEW layout, long offset, byte value) Writes a byte at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the byte value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfBoolean,long) [NONE]
### get boolean get (ValueLayout.OfBooleanPREVIEW layout, long offset) Reads a boolean at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a boolean value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfBoolean,long,boolean) [NONE]
### set void set (ValueLayout.OfBooleanPREVIEW layout, long offset, boolean value) Writes a boolean at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the boolean value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfChar,long) [NONE]
### get char get (ValueLayout.OfCharPREVIEW layout, long offset) Reads a char at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a char value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfChar,long,char) [NONE]
### set void set (ValueLayout.OfCharPREVIEW layout, long offset, char value) Writes a char at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the char value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfShort,long) [NONE]
### get short get (ValueLayout.OfShortPREVIEW layout, long offset) Reads a short at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a short value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfShort,long,short) [NONE]
### set void set (ValueLayout.OfShortPREVIEW layout, long offset, short value) Writes a short at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the short value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfInt,long) [NONE]
### get int get (ValueLayout.OfIntPREVIEW layout, long offset) Reads an int at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: an int value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfInt,long,int) [NONE]
### set void set (ValueLayout.OfIntPREVIEW layout, long offset, int value) Writes an int at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the int value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfFloat,long) [NONE]
### get float get (ValueLayout.OfFloatPREVIEW layout, long offset) Reads a float at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a float value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfFloat,long,float) [NONE]
### set void set (ValueLayout.OfFloatPREVIEW layout, long offset, float value) Writes a float at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the float value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfLong,long) [NONE]
### get long get (ValueLayout.OfLongPREVIEW layout, long offset) Reads a long at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a long value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfLong,long,long) [NONE]
### set void set (ValueLayout.OfLongPREVIEW layout, long offset, long value) Writes a long at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the long value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfDouble,long) [NONE]
### get double get (ValueLayout.OfDoublePREVIEW layout, long offset) Reads a double at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: a double value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfDouble,long,double) [NONE]
### set void set (ValueLayout.OfDoublePREVIEW layout, long offset, double value) Writes a double at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the double value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:get(java.lang.foreign.ValueLayout.OfAddress,long) [NONE]
### get MemoryAddressPREVIEW get (ValueLayout.OfAddressPREVIEW layout, long offset) Reads an address at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + offset` . Returns: an address value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:set(java.lang.foreign.ValueLayout.OfAddress,long,java.lang.foreign.Addressable) [NONE]
### set void set (ValueLayout.OfAddressPREVIEW layout, long offset, AddressablePREVIEW value) Writes an address at the given offset from this address, with the given layout. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `offset` - offset in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + offset` . `value` - the address value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:getAtIndex(java.lang.foreign.ValueLayout.OfChar,long) [NONE]
### getAtIndex char getAtIndex (ValueLayout.OfCharPREVIEW layout, long index) Reads a char from this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `index` - index in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . Returns: a char value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setAtIndex(java.lang.foreign.ValueLayout.OfChar,long,char) [NONE]
### setAtIndex void setAtIndex (ValueLayout.OfCharPREVIEW layout, long index, char value) Writes a char to this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `index` - index in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . `value` - the char value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:getAtIndex(java.lang.foreign.ValueLayout.OfShort,long) [NONE]
### getAtIndex short getAtIndex (ValueLayout.OfShortPREVIEW layout, long index) Reads a short from this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `index` - index in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . Returns: a short value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setAtIndex(java.lang.foreign.ValueLayout.OfShort,long,short) [NONE]
### setAtIndex void setAtIndex (ValueLayout.OfShortPREVIEW layout, long index, short value) Writes a short to this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `index` - index in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . `value` - the short value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:getAtIndex(java.lang.foreign.ValueLayout.OfInt,long) [NONE]
### getAtIndex int getAtIndex (ValueLayout.OfIntPREVIEW layout, long index) Reads an int from this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `index` - index in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . Returns: an int value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setAtIndex(java.lang.foreign.ValueLayout.OfInt,long,int) [NONE]
### setAtIndex void setAtIndex (ValueLayout.OfIntPREVIEW layout, long index, int value) Writes an int to this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `index` - index in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . `value` - the int value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:getAtIndex(java.lang.foreign.ValueLayout.OfFloat,long) [NONE]
### getAtIndex float getAtIndex (ValueLayout.OfFloatPREVIEW layout, long index) Reads a float from this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `index` - index in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . Returns: a float value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setAtIndex(java.lang.foreign.ValueLayout.OfFloat,long,float) [NONE]
### setAtIndex void setAtIndex (ValueLayout.OfFloatPREVIEW layout, long index, float value) Writes a float to this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `index` - index in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . `value` - the float value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:getAtIndex(java.lang.foreign.ValueLayout.OfLong,long) [NONE]
### getAtIndex long getAtIndex (ValueLayout.OfLongPREVIEW layout, long index) Reads a long from this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `index` - index in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . Returns: a long value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setAtIndex(java.lang.foreign.ValueLayout.OfLong,long,long) [NONE]
### setAtIndex void setAtIndex (ValueLayout.OfLongPREVIEW layout, long index, long value) Writes a long to this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `index` - index in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . `value` - the long value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:getAtIndex(java.lang.foreign.ValueLayout.OfDouble,long) [NONE]
### getAtIndex double getAtIndex (ValueLayout.OfDoublePREVIEW layout, long index) Reads a double from this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `index` - index in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . Returns: a double value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setAtIndex(java.lang.foreign.ValueLayout.OfDouble,long,double) [NONE]
### setAtIndex void setAtIndex (ValueLayout.OfDoublePREVIEW layout, long index, double value) Writes a double to this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `index` - index in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . `value` - the double value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:getAtIndex(java.lang.foreign.ValueLayout.OfAddress,long) [NONE]
### getAtIndex MemoryAddressPREVIEW getAtIndex (ValueLayout.OfAddressPREVIEW layout, long index) Reads an address from this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be read. `index` - index in bytes (relative to this address). Might be negative. The final address of this read operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . Returns: an address value read from this address. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.

### method:setAtIndex(java.lang.foreign.ValueLayout.OfAddress,long,java.lang.foreign.Addressable) [NONE]
### setAtIndex void setAtIndex (ValueLayout.OfAddressPREVIEW layout, long index, AddressablePREVIEW value) Writes an address to this address at the given index, scaled by the given layout size. This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on restricted methods, and use safe and supported functionalities, where possible. Parameters: `layout` - the layout of the memory region to be written. `index` - index in bytes (relative to this address). Might be negative. The final address of this write operation can be expressed as `toRowLongValue() + (index * layout.byteSize())` . `value` - the address value to be written. Throws: `IllegalArgumentException` - if the dereference operation is incompatible with the alignment constraints in the provided layout, or if the layout alignment is greater than its size. `IllegalCallerException` - if access to this method occurs from a module `M` and the command line option `--enable-native-access` is specified, but does not mention the module name `M`, or `ALL-UNNAMED` in case `M` is an unnamed module.