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: 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 layoutPREVIEW, 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 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:

    • 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:

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