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: 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.
Since:
19
Implementation Requirements:
Implementations of this interface are immutable, thread-safe and value-based.

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:

    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:

    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.