Package Summary Overview Summary

Module java.base
Package java.lang.foreign

# Interface MemoryAddress

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 Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final MemoryAddressPREVIEW`
  `NULL`
  The memory address instance modelling the `NULL` address.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `MemoryAddressPREVIEW`
  `addOffset (long offset)`
  Returns a memory address at given offset from this address.
  `boolean`
  `equals (Object that)`
  Compares the specified object with this address for equality.
  `MemoryAddressPREVIEW`
  `get (ValueLayout.OfAddressPREVIEW layout, long offset)`
  Reads an address at the given offset from this address, with the given layout.
  `boolean`
  `get (ValueLayout.OfBooleanPREVIEW layout, long offset)`
  Reads a boolean at the given offset from this address, with the given layout.
  `byte`
  `get (ValueLayout.OfBytePREVIEW layout, long offset)`
  Reads a byte at the given offset from this address, with the given layout.
  `char`
  `get (ValueLayout.OfCharPREVIEW layout, long offset)`
  Reads a char at the given offset from this address, with the given layout.
  `double`
  `get (ValueLayout.OfDoublePREVIEW layout, long offset)`
  Reads a double at the given offset from this address, with the given layout.
  `float`
  `get (ValueLayout.OfFloatPREVIEW layout, long offset)`
  Reads a float at the given offset from this address, with the given layout.
  `int`
  `get (ValueLayout.OfIntPREVIEW layout, long offset)`
  Reads an int at the given offset from this address, with the given layout.
  `long`
  `get (ValueLayout.OfLongPREVIEW layout, long offset)`
  Reads a long at the given offset from this address, with the given layout.
  `short`
  `get (ValueLayout.OfShortPREVIEW layout, long offset)`
  Reads a short at the given offset from this address, with the given layout.
  `MemoryAddressPREVIEW`
  `getAtIndex (ValueLayout.OfAddressPREVIEW layout, long index)`
  Reads an address from this address at the given index, scaled by the given layout size.
  `char`
  `getAtIndex (ValueLayout.OfCharPREVIEW layout, long index)`
  Reads a char from this address at the given index, scaled by the given layout size.
  `double`
  `getAtIndex (ValueLayout.OfDoublePREVIEW layout, long index)`
  Reads a double from this address at the given index, scaled by the given layout size.
  `float`
  `getAtIndex (ValueLayout.OfFloatPREVIEW layout, long index)`
  Reads a float from this address at the given index, scaled by the given layout size.
  `int`
  `getAtIndex (ValueLayout.OfIntPREVIEW layout, long index)`
  Reads an int from this address at the given index, scaled by the given layout size.
  `long`
  `getAtIndex (ValueLayout.OfLongPREVIEW layout, long index)`
  Reads a long from this address at the given index, scaled by the given layout size.
  `short`
  `getAtIndex (ValueLayout.OfShortPREVIEW layout, long index)`
  Reads a short from this address at the given index, scaled by the given layout size.
  `String`
  `getUtf8String (long offset)`
  Reads a UTF-8 encoded, null-terminated string from this address at the given offset.
  `int`
  `hashCode()`
  Returns the hash code value for this address.
  `static MemoryAddressPREVIEW`
  `ofLong (long value)`
  Creates a memory address from the given long value.
  `void`
  `set (ValueLayout.OfAddressPREVIEW layout, long offset, AddressablePREVIEW value)`
  Writes an address at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfBooleanPREVIEW layout, long offset, boolean value)`
  Writes a boolean at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfBytePREVIEW layout, long offset, byte value)`
  Writes a byte at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfCharPREVIEW layout, long offset, char value)`
  Writes a char at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfDoublePREVIEW layout, long offset, double value)`
  Writes a double at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfFloatPREVIEW layout, long offset, float value)`
  Writes a float at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfIntPREVIEW layout, long offset, int value)`
  Writes an int at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfLongPREVIEW layout, long offset, long value)`
  Writes a long at the given offset from this address, with the given layout.
  `void`
  `set (ValueLayout.OfShortPREVIEW layout, long offset, short value)`
  Writes a short at the given offset from this address, with the given layout.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `long`
  `toRawLongValue()`
  Returns the raw long value associated with this memory address.

  ### Methods declared in interface java.lang.foreign.AddressablePREVIEW

  `address`

- ## Field Details

  - ### NULL

    static final MemoryAddressPREVIEW NULL
    The memory address instance modelling the `NULL` address.

- ## Method Details

  - ### toRawLongValue

    long toRawLongValue()
    Returns the raw long value associated with this memory address.
    Returns:
      the raw long value associated with this memory address

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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`

  - ### 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)`

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.

  - ### 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.