Класс MemoryAccess

java.lang.Object

jdk.incubator.foreign.MemoryAccess

public final class MemoryAccess extends Object

Этот класс определяет готовые статические методы доступа, которые могут использоваться для обращений к сегментам памяти различными способами.

Наиболее примитивные методы доступа (см. getIntAtOffset(MemorySegment, long, ByteOrder)) принимают сегмент, смещение (выраженное в байтах) и порядок байтов. Конечный адрес, по которому будет произведено обращение, вычисляется путем смещения базового адреса на указанное смещение, как если бы был вызван MemoryAddress.addOffset(long) для указанного базового адреса.

В случаях, когда смещение не требуется, предоставляются перегрузки (см. getInt(MemorySegment, ByteOrder)), чтобы клиенты могли опустить координату смещения.

Для облегчения доступа в массивоподобных случаях (например, когда макет данного сегмента памяти представляет собой последовательность элементов заданного размера и количества), также предоставляются методы высшего уровня (см. getIntAtIndex(MemorySegment, long, ByteOrder)), которые принимают сегмент и логический индекс элемента. Формула получения байтового смещения O от индекса I задается как O = I * S, где S — размер (в байтах) элемента, к которому осуществляется обращение.

В случаях, когда предпочтительнее использовать порядок байтов по умолчанию, предоставляются перегрузки (см. getIntAtOffset(MemorySegment, long)), чтобы клиенты могли опустить параметр порядка байтов.

Если не указано иное, передача null аргумента или массива, содержащего один или несколько null элементов в метод этого класса приводит к исключению NullPointerException.

Краткое описание методов

Модификатор и тип	Метод	Описание
`static MemoryAddress`	`getAddress(MemorySegment segment)`	Считывает адрес памяти из заданного сегмента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static MemoryAddress`	`getAddressAtIndex(MemorySegment segment, long index)`	Считывает адрес памяти из заданного сегмента и индекса элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static MemoryAddress`	`getAddressAtOffset(MemorySegment segment, long offset)`	Считывает адрес памяти из заданного сегмента и смещения, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static byte`	`getByte(MemorySegment segment)`	Считывает байт из заданного сегмента.
`static byte`	`getByteAtOffset(MemorySegment segment, long offset)`	Считывает байт из заданного сегмента и смещения.
`static char`	`getChar(MemorySegment segment)`	Считывает символ из заданного сегмента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static char`	`getChar(MemorySegment segment, ByteOrder order)`	Считывает символ из заданного сегмента с заданным порядком байтов.
`static char`	`getCharAtIndex(MemorySegment segment, long index)`	Считывает символ из заданного сегмента и индекса элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static char`	`getCharAtIndex(MemorySegment segment, long index, ByteOrder order)`	Считывает символ из заданного сегмента и индекса элемента с заданным порядком байтов.
`static char`	`getCharAtOffset(MemorySegment segment, long offset)`	Считывает символ из заданного сегмента и смещения, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static char`	`getCharAtOffset(MemorySegment segment, long offset, ByteOrder order)`	Считывает символ из заданного сегмента и смещения с заданным порядком байтов.
`static double`	`getDouble(MemorySegment segment)`	Считывает число с плавающей запятой двойной точности из заданного сегмента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static double`	`getDouble(MemorySegment segment, ByteOrder order)`	Считывает число с плавающей запятой двойной точности из заданного сегмента с заданным порядком байтов.
`static double`	`getDoubleAtIndex(MemorySegment segment, long index)`	Считывает число с плавающей запятой двойной точности из заданного сегмента и индекса элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static double`	`getDoubleAtIndex(MemorySegment segment, long index, ByteOrder order)`	Считывает число с плавающей запятой двойной точности из заданного сегмента и индекса элемента с заданным порядком байтов.
`static double`	`getDoubleAtOffset(MemorySegment segment, long offset)`	Считывает число с плавающей запятой двойной точности из заданного сегмента и смещения, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static double`	`getDoubleAtOffset(MemorySegment segment, long offset, ByteOrder order)`	Считывает число с плавающей запятой двойной точности из заданного сегмента и смещения с заданным порядком байтов.
`static float`	`getFloat(MemorySegment segment)`	Считывает число с плавающей запятой одинарной точности из заданного сегмента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static float`	`getFloat(MemorySegment segment, ByteOrder order)`	Считывает число с плавающей запятой одинарной точности из заданного сегмента с заданным порядком байтов.
`static float`	`getFloatAtIndex(MemorySegment segment, long index)`	Считывает число с плавающей запятой одинарной точности из заданного сегмента и индекса элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static float`	`getFloatAtIndex(MemorySegment segment, long index, ByteOrder order)`	Считывает число с плавающей запятой одинарной точности из заданного сегмента и индекса элемента с заданным порядком байтов.
`static float`	`getFloatAtOffset(MemorySegment segment, long offset)`	Считывает число с плавающей запятой одинарной точности из заданного сегмента и смещения, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static float`	`getFloatAtOffset(MemorySegment segment, long offset, ByteOrder order)`	Считывает число с плавающей запятой одинарной точности из заданного сегмента и смещения с заданным порядком байтов.
`static int`	`getInt(MemorySegment segment)`	Считывает целое число из заданного сегмента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static int`	`getInt(MemorySegment segment, ByteOrder order)`	Считывает целое число из заданного сегмента с заданным порядком байтов.
`static int`	`getIntAtIndex(MemorySegment segment, long index)`	Считывает целое число из заданного сегмента и индекса элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static int`	`getIntAtIndex(MemorySegment segment, long index, ByteOrder order)`	Считывает целое число из заданного сегмента и индекса элемента с заданным порядком байтов.
`static int`	`getIntAtOffset(MemorySegment segment, long offset)`	Считывает целое число из заданного сегмента и смещения, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static int`	`getIntAtOffset(MemorySegment segment, long offset, ByteOrder order)`	Считывает целое число из заданного сегмента и смещения с заданным порядком байтов.
`static long`	`getLong(MemorySegment segment)`	Считывает длинное целое число из заданного сегмента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static long`	`getLong(MemorySegment segment, ByteOrder order)`	Считывает длинное целое число из заданного сегмента с заданным порядком байтов.
`static long`	`getLongAtIndex(MemorySegment segment, long index)`	Считывает длинное целое число из заданного сегмента и индекса элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static long`	`getLongAtIndex(MemorySegment segment, long index, ByteOrder order)`	Считывает длинное целое число из заданного сегмента и индекса элемента с заданным порядком байтов.
`static long`	`getLongAtOffset(MemorySegment segment, long offset)`	Считывает длинное целое число из заданного сегмента и смещения, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static long`	`getLongAtOffset(MemorySegment segment, long offset, ByteOrder order)`	Считывает длинное целое число из заданного сегмента и смещения с заданным порядком байтов.
`static short`	`getShort(MemorySegment segment)`	Считывает короткое целое число из заданного сегмента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static short`	`getShort(MemorySegment segment, ByteOrder order)`	Считывает короткое целое число из заданного сегмента с заданным порядком байтов.
`static short`	`getShortAtIndex(MemorySegment segment, long index)`	Считывает короткое целое число из заданного сегмента и индекса элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static short`	`getShortAtIndex(MemorySegment segment, long index, ByteOrder order)`	Считывает короткое целое число из заданного сегмента и индекса элемента с заданным порядком байтов.
`static short`	`getShortAtOffset(MemorySegment segment, long offset)`	Считывает короткое целое число из заданного сегмента и смещения, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static short`	`getShortAtOffset(MemorySegment segment, long offset, ByteOrder order)`	Считывает короткое целое число из заданного сегмента и смещения с заданным порядком байтов.
`static void`	`setAddress(MemorySegment segment, Addressable value)`	Записывает адрес памяти в заданный сегмент, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setAddressAtIndex(MemorySegment segment, long index, Addressable value)`	Записывает адрес памяти в заданный сегмент и индекс элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setAddressAtOffset(MemorySegment segment, long offset, Addressable value)`	Записывает адрес памяти в заданный сегмент и смещение, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setByte(MemorySegment segment, byte value)`	Записывает байт в заданный сегмент.
`static void`	`setByteAtOffset(MemorySegment segment, long offset, byte value)`	Записывает байт в заданный сегмент и смещение.
`static void`	`setChar(MemorySegment segment, char value)`	Записывает символ в заданный сегмент, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setChar(MemorySegment segment, ByteOrder order, char value)`	Записывает символ в заданный сегмент с заданным порядком байтов.
`static void`	`setCharAtIndex(MemorySegment segment, long index, char value)`	Записывает символ в заданный сегмент и индекс элемента, с порядком байтов, установленным в `ByteOrder.nativeOrder()`.

`static void`	`setCharAtIndex(MemorySegment segment, long index, ByteOrder order, char value)`	Записывает символ в заданный сегмент и индекс элемента с заданным порядком байтов.
`static void`	`setCharAtOffset(MemorySegment segment, long offset, char value)`	Записывает символ в заданный сегмент и смещение с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setCharAtOffset(MemorySegment segment, long offset, ByteOrder order, char value)`	Записывает символ в заданный сегмент и смещение с заданным порядком байтов.
`static void`	`setDouble(MemorySegment segment, double value)`	Записывает double в заданный сегмент с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setDouble(MemorySegment segment, ByteOrder order, double value)`	Записывает double в заданный сегмент с заданным порядком байтов.
`static void`	`setDoubleAtIndex(MemorySegment segment, long index, double value)`	Записывает double в заданный сегмент и индекс элемента с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setDoubleAtIndex(MemorySegment segment, long index, ByteOrder order, double value)`	Записывает double в заданный сегмент и индекс элемента с заданным порядком байтов.
`static void`	`setDoubleAtOffset(MemorySegment segment, long offset, double value)`	Записывает double в заданный сегмент и смещение со значением, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setDoubleAtOffset(MemorySegment segment, long offset, ByteOrder order, double value)`	Записывает double в заданный сегмент и смещение с заданным порядком байтов.
`static void`	`setFloat(MemorySegment segment, float value)`	Записывает float в заданный сегмент с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setFloat(MemorySegment segment, ByteOrder order, float value)`	Записывает float в заданный сегмент с заданным порядком байтов.
`static void`	`setFloatAtIndex(MemorySegment segment, long index, float value)`	Записывает float в заданный сегмент и индекс элемента с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setFloatAtIndex(MemorySegment segment, long index, ByteOrder order, float value)`	Записывает float в заданный сегмент и индекс элемента с заданным порядком байтов.
`static void`	`setFloatAtOffset(MemorySegment segment, long offset, float value)`	Записывает float в заданный сегмент и смещение с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setFloatAtOffset(MemorySegment segment, long offset, ByteOrder order, float value)`	Записывает float в заданный сегмент и смещение с заданным порядком байтов.
`static void`	`setInt(MemorySegment segment, int value)`	Записывает int в заданный сегмент с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setInt(MemorySegment segment, ByteOrder order, int value)`	Записывает int в заданный сегмент с заданным порядком байтов.
`static void`	`setIntAtIndex(MemorySegment segment, long index, int value)`	Записывает int в заданный сегмент и индекс элемента с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setIntAtIndex(MemorySegment segment, long index, ByteOrder order, int value)`	Записывает int в заданный сегмент и индекс элемента с заданным порядком байтов.
`static void`	`setIntAtOffset(MemorySegment segment, long offset, int value)`	Записывает int в заданный сегмент и смещение с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setIntAtOffset(MemorySegment segment, long offset, ByteOrder order, int value)`	Записывает int в заданный сегмент и смещение с заданным порядком байтов.
`static void`	`setLong(MemorySegment segment, long value)`	Записывает long в заданный сегмент с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setLong(MemorySegment segment, ByteOrder order, long value)`	Записывает long в заданный сегмент с заданным порядком байтов.
`static void`	`setLongAtIndex(MemorySegment segment, long index, long value)`	Записывает long в заданный сегмент и индекс элемента с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setLongAtIndex(MemorySegment segment, long index, ByteOrder order, long value)`	Записывает long в заданный сегмент и индекс элемента с заданным порядком байтов.
`static void`	`setLongAtOffset(MemorySegment segment, long offset, long value)`	Записывает long в заданный сегмент и смещение с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setLongAtOffset(MemorySegment segment, long offset, ByteOrder order, long value)`	Записывает long в заданный сегмент и смещение с заданным порядком байтов.
`static void`	`setShort(MemorySegment segment, short value)`	Записывает short в заданный сегмент с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setShort(MemorySegment segment, ByteOrder order, short value)`	Записывает short в заданный сегмент с заданным порядком байтов.
`static void`	`setShortAtIndex(MemorySegment segment, long index, short value)`	Записывает short в заданный сегмент и индекс элемента с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setShortAtIndex(MemorySegment segment, long index, ByteOrder order, short value)`	Записывает short в заданный сегмент и индекс элемента с заданным порядком байтов.
`static void`	`setShortAtOffset(MemorySegment segment, long offset, short value)`	Записывает short в заданный сегмент и смещение с порядком байтов, установленным в `ByteOrder.nativeOrder()`.
`static void`	`setShortAtOffset(MemorySegment segment, long offset, ByteOrder order, short value)`	Записывает short в заданный сегмент и смещение с заданным порядком байтов.

Методы, объявленные в классе java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Подробное описание методов

getByteAtOffset

public static byte getByteAtOffset(MemorySegment segment, long offset)

Считывает байт из заданного сегмента и смещения.

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Возвращает:: значение байта, считанного из segment.

setByteAtOffset

public static void setByteAtOffset(MemorySegment segment, long offset, byte value)

Записывает байт в заданный сегмент и смещение.

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; value - значение байта для записи.

getCharAtOffset

public static char getCharAtOffset(MemorySegment segment, long offset)

Считывает символ из заданного сегмента и смещения, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    getCharAtOffset(segment, offset, ByteOrder.nativeOrder());

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Возвращает:: значение символа, считанного из segment.

setCharAtOffset

public static void setCharAtOffset(MemorySegment segment, long offset, char value)

Записывает символ в заданный сегмент и смещение, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    setCharAtOffset(segment, offset, ByteOrder.nativeOrder(), value);

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; value - значение символа для записи.

getShortAtOffset

public static short getShortAtOffset(MemorySegment segment, long offset)

Считывает короткий целочисленный тип из заданного сегмента и смещения, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    getShortAtOffset(segment, offset, ByteOrder.nativeOrder());

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Возвращает:: значение короткого целого типа, считанного из segment.

setShortAtOffset

public static void setShortAtOffset(MemorySegment segment, long offset, short value)

Записывает короткий целочисленный тип в заданный сегмент и смещение, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    setShortAtOffset(segment, offset, ByteOrder.nativeOrder(), value);

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; value - значение короткого целого типа для записи.

getIntAtOffset

public static int getIntAtOffset(MemorySegment segment, long offset)

Считывает целое число из заданного сегмента и смещения, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    getIntAtOffset(segment, offset, ByteOrder.nativeOrder());

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Возвращает:: значение целого числа, считанного из segment.

setIntAtOffset

public static void setIntAtOffset(MemorySegment segment, long offset, int value)

Записывает целое число в заданный сегмент и смещение, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    setIntAtOffset(segment, offset, ByteOrder.nativeOrder(), value);

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; value - значение целого числа для записи.

getFloatAtOffset

public static float getFloatAtOffset(MemorySegment segment, long offset)

Считывает число с плавающей точкой из заданного сегмента и смещения, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    getFloatAtOffset(segment, offset, ByteOrder.nativeOrder());

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Возвращает:: значение числа с плавающей точкой, считанного из segment.

setFloatAtOffset

public static void setFloatAtOffset(MemorySegment segment, long offset, float value)

Записывает число с плавающей точкой в заданный сегмент и смещение, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    setFloatAtOffset(segment, offset, ByteOrder.nativeOrder(), value);

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; value - значение числа с плавающей точкой для записи.

getLongAtOffset

public static long getLongAtOffset(MemorySegment segment, long offset)

Считывает 64-битное целое число из заданного сегмента и смещения, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    getLongAtOffset(segment, offset, ByteOrder.nativeOrder());

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Возвращает:: значение 64-битного целого числа, считанного из segment.

setLongAtOffset

public static void setLongAtOffset(MemorySegment segment, long offset, long value)

Записывает 64-битное целое число в заданный сегмент и смещение, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    setLongAtOffset(segment, offset, ByteOrder.nativeOrder(), value);

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; value - значение 64-битного целого числа для записи.

getDoubleAtOffset

public static double getDoubleAtOffset(MemorySegment segment, long offset)

Считывает число двойной точности из заданного сегмента и смещения, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    getDoubleAtOffset(segment, offset, ByteOrder.nativeOrder());

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Возвращает:: значение числа двойной точности, считанного из segment.

setDoubleAtOffset

public static void setDoubleAtOffset(MemorySegment segment, long offset, double value)

Записывает число двойной точности в заданный сегмент и смещение, с порядком байтов, установленным в ByteOrder.nativeOrder().

Эквивалентно следующему коду:


    setDoubleAtOffset(segment, offset, ByteOrder.nativeOrder(), value);

Параметры:: segment - сегмент для обращений.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; value - значение числа двойной точности для записи.

getAddressAtOffset

public static MemoryAddress getAddressAtOffset(MemorySegment segment, long offset)

Считывает адрес памяти из заданного сегмента и смещения, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно (например, на 64-битной платформе) следующему коду:


    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder()));
    MemoryAddress value = (MemoryAddress)handle.get(segment, offset);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).
Returns:: адрес памяти, считанный из segment.

setAddressAtOffset

public static void setAddressAtOffset(MemorySegment segment, long offset, Addressable value)

Записывает адрес памяти в заданный сегмент и смещение, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно (например, на 64-битной платформе) следующему коду:


    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder()));
    handle.set(segment, offset, value.address());

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции записи можно выразить как segment.address().addOffset(offset).; value - адрес памяти, который будет записан (выраженный как экземпляр Addressable).

getCharAtOffset

public static char getCharAtOffset(MemorySegment segment, long offset, ByteOrder order)

Считывает символ char из заданного сегмента и смещения с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(char.class, 1, order);
    char value = (char)handle.get(segment, offset);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.
Returns:: значение char, считанное из segment.

setCharAtOffset

public static void setCharAtOffset(MemorySegment segment, long offset, ByteOrder order, char value)

Записывает символ char в заданный сегмент и смещение с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(char.class, 1, order);
    handle.set(segment, offset, value);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.; value - значение char, которое будет записано.

getShortAtOffset

public static short getShortAtOffset(MemorySegment segment, long offset, ByteOrder order)

Считывает short из заданного сегмента и смещения с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(short.class, 1, order);
    short value = (short)handle.get(segment, offset);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.
Returns:: значение short, считанное из segment.

setShortAtOffset

public static void setShortAtOffset(MemorySegment segment, long offset, ByteOrder order, short value)

Записывает short в заданный сегмент и смещение с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(short.class, 1, order);
    handle.set(segment, offset, value);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.; value - значение short, которое будет записано.

getIntAtOffset

public static int getIntAtOffset(MemorySegment segment, long offset, ByteOrder order)

Считывает int из заданного сегмента и смещения с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(int.class, 1, order);
    int value = (int)handle.get(segment, offset);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.
Returns:: значение int, считанное из segment.

setIntAtOffset

public static void setIntAtOffset(MemorySegment segment, long offset, ByteOrder order, int value)

Записывает int в заданный сегмент и смещение с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(int.class, 1, order);
    handle.set(segment, offset, value);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.; value - значение int, которое будет записано.

getFloatAtOffset

public static float getFloatAtOffset(MemorySegment segment, long offset, ByteOrder order)

Считывает float из заданного сегмента и смещения с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(float.class, 1, order);
    float value = (float)handle.get(segment, offset);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.
Returns:: значение float, считанное из segment.

setFloatAtOffset

public static void setFloatAtOffset(MemorySegment segment, long offset, ByteOrder order, float value)

Записывает float в заданный сегмент и смещение с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(float.class, 1, order);
    handle.set(segment, offset, value);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.; value - значение float, которое будет записано.

getLongAtOffset

public static long getLongAtOffset(MemorySegment segment, long offset, ByteOrder order)

Считывает long из заданного сегмента и смещения с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(long.class, 1, order);
    long value = (long)handle.get(segment, offset);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.
Returns:: значение long, считанное из segment.

setLongAtOffset

public static void setLongAtOffset(MemorySegment segment, long offset, ByteOrder order, long value)

Записывает long в заданный сегмент и смещение с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(long.class, 1, order);
    handle.set(segment, offset, value);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.; value - значение long, которое будет записано.

getDoubleAtOffset

public static double getDoubleAtOffset(MemorySegment segment, long offset, ByteOrder order)

Считывает double из заданного сегмента и смещения с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(double.class, 1, order);
    double value = (double)handle.get(segment, offset);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.
Returns:: значение double, считанное из segment.

setDoubleAtOffset

public static void setDoubleAtOffset(MemorySegment segment, long offset, ByteOrder order, double value)

Записывает double в заданный сегмент и смещение с заданным порядком байтов.

Это эквивалентно следующему коду:


    VarHandle handle = MemoryHandles.varHandle(double.class, 1, order);
    handle.set(segment, offset, value);

Parameters:: segment - сегмент, подлежащий обращению.; offset - смещение в байтах (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(offset).; order - указанный порядок байтов.; value - значение double, которое будет записано.

END_OF_DOCUMENT_MARKER

getByte

public static byte getByte(MemorySegment segment)

Читает байт из заданного сегмента.

Это эквивалентно следующему коду:


    byte value = getByteAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: значение байта, прочитанного из segment.

setByte

public static void setByte(MemorySegment segment, byte value)

Записывает байт в заданный сегмент.

Это эквивалентно следующему коду:


    setByteAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - значение байта, которое должно быть записано.

getChar

public static char getChar(MemorySegment segment)

Читает символ из заданного сегмента, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    char value = getCharAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: значение символа, прочитанного из segment.

setChar

public static void setChar(MemorySegment segment, char value)

Записывает символ в заданный сегмент, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setCharAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - значение символа, которое должно быть записано.

getShort

public static short getShort(MemorySegment segment)

Читает короткий целого типа из заданного сегмента, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    short value = getShortAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: значение короткого целого типа, прочитанного из segment.

setShort

public static void setShort(MemorySegment segment, short value)

Записывает короткий целого типа в заданный сегмент, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setShortAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - значение короткого целого типа, которое должно быть записано.

getInt

public static int getInt(MemorySegment segment)

Читает целое число из заданного сегмента, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    int value = getIntAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: значение целого числа, прочитанного из segment.

setInt

public static void setInt(MemorySegment segment, int value)

Записывает целое число в заданный сегмент, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setIntAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - значение целого числа, которое должно быть записано.

getFloat

public static float getFloat(MemorySegment segment)

Читает число с плавающей точкой из заданного сегмента, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    float value = getFloatAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: значение числа с плавающей точкой, прочитанного из segment.

setFloat

public static void setFloat(MemorySegment segment, float value)

Записывает число с плавающей точкой в заданный сегмент, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setFloatAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - значение числа с плавающей точкой, которое должно быть записано.

getLong

public static long getLong(MemorySegment segment)

Читает длинное целое число из заданного сегмента, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    long value = getLongAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: значение длинного целого числа, прочитанного из segment.

setLong

public static void setLong(MemorySegment segment, long value)

Записывает длинное целое число в заданный сегмент, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setLongAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - значение длинного целого числа, которое должно быть записано.

getDouble

public static double getDouble(MemorySegment segment)

Читает число двойной точности из заданного сегмента, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    double value = getDoubleAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: значение числа двойной точности, прочитанного из segment.

setDouble

public static void setDouble(MemorySegment segment, double value)

Записывает число двойной точности в заданный сегмент, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setDoubleAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - значение числа двойной точности, которое должно быть записано.

getAddress

public static MemoryAddress getAddress(MemorySegment segment)

Читает адрес памяти из заданного сегмента, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    MemoryAddress value = getAddressAtOffset(segment, 0L);

Parameters:: segment - сегмент, который должен быть обращён.
Returns:: адрес памяти, прочитанный из segment.

setAddress

public static void setAddress(MemorySegment segment, Addressable value)

Записывает адрес памяти в заданный сегмент, с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setAddressAtOffset(segment, 0L, value);

Parameters:: segment - сегмент, который должен быть обращён.; value - адрес памяти, который должен быть записан (выраженный как экземпляр Addressable).

getChar

public static char getChar(MemorySegment segment, ByteOrder order)

Читает символ из заданного сегмента, с заданным порядком байтов.

Это эквивалентно следующему коду:


    char value = getCharAtOffset(segment, 0L, order);

Parameters:: segment - сегмент, который должен быть обращён.; order - указанный порядок байтов.
Returns:: значение символа, прочитанного из segment.

setChar

public static void setChar(MemorySegment segment, ByteOrder order, char value)

Записывает символ в заданный сегмент, с заданным порядком байтов.

Это эквивалентно следующему коду:


    setCharAtOffset(segment, 0L, order, value);

Parameters:: segment - сегмент, который должен быть обращён.; order - указанный порядок байтов.; value - значение символа, которое должно быть записано.

getShort

public static short getShort(MemorySegment segment, ByteOrder order)

Читает короткий целого типа из заданного сегмента, с заданным порядком байтов.

Это эквивалентно следующему коду:


    short value = getShortAtOffset(segment, 0L, order);

Parameters:: segment - сегмент, который должен быть обращён.; order - указанный порядок байтов.
Returns:: значение короткого целого типа, прочитанного из segment.

END_OF_DOCUMENT_MARKER

setShort

public static void setShort(MemorySegment segment, ByteOrder order, short value)

Записывает короткий целочисленный тип данных в заданный сегмент с указанным порядком байтов.

Это эквивалентно следующему коду:


    setShortAtOffset(segment, 0L, order, value);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.; value - значение короткого целочисленного типа данных, которое должно быть записано.

getInt

public static int getInt(MemorySegment segment, ByteOrder order)

Читает целое число из заданного сегмента с указанным порядком байтов.

Это эквивалентно следующему коду:


    int value = getIntAtOffset(segment, 0L, order);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.
Returns:: значение целого числа, прочитанное из segment.

setInt

public static void setInt(MemorySegment segment, ByteOrder order, int value)

Записывает целое число в заданный сегмент с указанным порядком байтов.

Это эквивалентно следующему коду:


    setIntAtOffset(segment, 0L, order, value);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.; value - значение целого числа, которое должно быть записано.

getFloat

public static float getFloat(MemorySegment segment, ByteOrder order)

Читает число с плавающей запятой из заданного сегмента с указанным порядком байтов.

Это эквивалентно следующему коду:


    float value = getFloatAtOffset(segment, 0L, order);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.
Returns:: значение числа с плавающей запятой, прочитанное из segment.

setFloat

public static void setFloat(MemorySegment segment, ByteOrder order, float value)

Записывает число с плавающей запятой в заданный сегмент с указанным порядком байтов.

Это эквивалентно следующему коду:


    setFloatAtOffset(segment, 0L, order, value);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.; value - значение числа с плавающей запятой, которое должно быть записано.

getLong

public static long getLong(MemorySegment segment, ByteOrder order)

Читает длинное целое число из заданного сегмента с указанным порядком байтов.

Это эквивалентно следующему коду:


    long value = getLongAtOffset(segment, 0L, order);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.
Returns:: значение длинного целого числа, прочитанное из segment.

setLong

public static void setLong(MemorySegment segment, ByteOrder order, long value)

Записывает длинное целое число в заданный сегмент с указанным порядком байтов.

Это эквивалентно следующему коду:


    setLongAtOffset(segment, 0L, order, value);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.; value - значение длинного целого числа, которое должно быть записано.

getDouble

public static double getDouble(MemorySegment segment, ByteOrder order)

Читает двойное число с плавающей запятой из заданного сегмента с указанным порядком байтов.

Это эквивалентно следующему коду:


    double value = getDoubleAtOffset(segment, 0L, order);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.
Returns:: значение двойного числа с плавающей запятой, прочитанное из segment.

setDouble

public static void setDouble(MemorySegment segment, ByteOrder order, double value)

Записывает двойное число с плавающей запятой в заданный сегмент с указанным порядком байтов.

Это эквивалентно следующему коду:


    setDoubleAtOffset(segment, 0L, order, value);

Parameters:: segment - сегмент, который должен быть обработан.; order - указанный порядок байтов.; value - значение двойного числа с плавающей запятой, которое должно быть записано.

getCharAtIndex

public static char getCharAtIndex(MemorySegment segment, long index)

Читает символ из заданного сегмента и индекса элемента с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    char value = getCharAtOffset(segment, 2 * index);

Parameters:: segment - сегмент, который должен быть обработан.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 2).
Returns:: значение символа, прочитанного из segment по индексу элемента, указанному в index.

setCharAtIndex

public static void setCharAtIndex(MemorySegment segment, long index, char value)

Записывает символ в заданный сегмент и индекс элемента с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setCharAtOffset(segment, 2 * index, value);

Parameters:: segment - сегмент, который должен быть обработан.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 2).; value - значение символа, которое должно быть записано.

getShortAtIndex

public static short getShortAtIndex(MemorySegment segment, long index)

Читает короткий целочисленный тип данных из заданного сегмента и индекса элемента с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    short value = getShortAtOffset(segment, 2 * index);

Parameters:: segment - сегмент, который должен быть обработан.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 2).
Returns:: значение короткого целочисленного типа данных, прочитанное из segment по индексу элемента, указанному в index.

setShortAtIndex

public static void setShortAtIndex(MemorySegment segment, long index, short value)

Записывает короткий целочисленный тип данных в заданный сегмент и индекс элемента с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setShortAtOffset(segment, 2 * index, value);

Parameters:: segment - сегмент, который должен быть обработан.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 2).; value - значение короткого целочисленного типа данных, которое должно быть записано.

getIntAtIndex

public static int getIntAtIndex(MemorySegment segment, long index)

Читает целое число из заданного сегмента и индекса элемента с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    int value = getIntAtOffset(segment, 4 * index);

Parameters:: segment - сегмент, который должен быть обработан.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 4).
Returns:: значение целого числа, прочитанное из segment по индексу элемента, указанному в index.

setIntAtIndex

public static void setIntAtIndex(MemorySegment segment, long index, int value)

Записывает целое число в заданный сегмент и индекс элемента с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setIntAtOffset(segment, 4 * index, value);

Parameters:: segment - сегмент, который должен быть обработан.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 4).; value - значение целого числа, которое должно быть записано.

getFloatAtIndex

public static float getFloatAtIndex(MemorySegment segment, long index)

Читает число с плавающей запятой из заданного сегмента и индекса элемента с порядком байтов, установленным в ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    float value = getFloatAtOffset(segment, 4 * index);

Parameters:: segment - сегмент, который должен быть обработан.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 4).
Returns:: значение числа с плавающей запятой, прочитанное из segment по индексу элемента, указанному в index.

setFloatAtIndex

public static void setFloatAtIndex(MemorySegment segment, long index, float value)

Записывает значение float в заданный сегмент и индекс элемента, с порядком байтов, установленным на ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setFloatAtOffset(segment, 4 * index, value);

Parameters:: segment - сегмент, который необходимо дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 4).; value - значение float, которое нужно записать.

getLongAtIndex

public static long getLongAtIndex(MemorySegment segment, long index)

Читает значение long из заданного сегмента и индекса элемента, с порядком байтов, установленным на ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    return getLongAtOffset(segment, 8 * index);

Parameters:: segment - сегмент, который нужно дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 8).
Returns:: значение long, прочитанное из segment по индексу элемента, указанному в index.

setLongAtIndex

public static void setLongAtIndex(MemorySegment segment, long index, long value)

Записывает значение long в заданный сегмент и индекс элемента, с порядком байтов, установленным на ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setLongAtOffset(segment, 8 * index, value);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 8).; value - значение long, которое нужно записать.

getDoubleAtIndex

public static double getDoubleAtIndex(MemorySegment segment, long index)

Читает значение double из заданного сегмента и индекса элемента, с порядком байтов, установленным на ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    return getDoubleAtOffset(segment, 8 * index);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 8).
Returns:: значение double, прочитанное из segment по индексу элемента, указанному в index.

setDoubleAtIndex

public static void setDoubleAtIndex(MemorySegment segment, long index, double value)

Записывает значение double в заданный сегмент и индекс элемента, с порядком байтов, установленным на ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setDoubleAtOffset(segment, 8 * index, value);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 8).; value - значение double, которое нужно записать.

getAddressAtIndex

public static MemoryAddress getAddressAtIndex(MemorySegment segment, long index)

Читает адрес памяти из заданного сегмента и индекса элемента, с порядком байтов, установленным на ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    return getAddressAtOffset(segment, index * MemoryLayouts.ADDRESS.byteSize());

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 8).
Returns:: адрес памяти, прочитанный из segment по индексу элемента, указанному в index.

setAddressAtIndex

public static void setAddressAtIndex(MemorySegment segment, long index, Addressable value)

Записывает адрес памяти в заданный сегмент и индекс элемента, с порядком байтов, установленным на ByteOrder.nativeOrder().

Это эквивалентно следующему коду:


    setAddressAtOffset(segment, index * MemoryLayouts.ADDRESS.byteSize(), value);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 8).; value - адрес памяти для записи (выраженный как экземпляр Addressable).

getCharAtIndex

public static char getCharAtIndex(MemorySegment segment, long index, ByteOrder order)

Читает значение char из заданного сегмента и индекса элемента с заданным порядком байтов.

Это эквивалентно следующему коду:


    char value = getCharAtOffset(segment, 2 * index, order);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 2).; order - указанный порядок байтов.
Returns:: значение char, прочитанное из segment по индексу элемента, указанному в index.

setCharAtIndex

public static void setCharAtIndex(MemorySegment segment, long index, ByteOrder order, char value)

Записывает значение char в заданный сегмент и индекс элемента с заданным порядком байтов.

Это эквивалентно следующему коду:


    setCharAtOffset(segment, 2 * index, order, value);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 2).; order - указанный порядок байтов.; value - значение char, которое нужно записать.

getShortAtIndex

public static short getShortAtIndex(MemorySegment segment, long index, ByteOrder order)

Читает значение short из заданного сегмента и индекса элемента с заданным порядком байтов.

Это эквивалентно следующему коду:


    short value = getShortAtOffset(segment, 2 * index, order);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 2).; order - указанный порядок байтов.
Returns:: значение short, прочитанное из segment по индексу элемента, указанному в index.

setShortAtIndex

public static void setShortAtIndex(MemorySegment segment, long index, ByteOrder order, short value)

Записывает значение short в заданный сегмент и индекс элемента с заданным порядком байтов.

Это эквивалентно следующему коду:


    setShortAtOffset(segment, 2 * index, order, value);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 2).; order - указанный порядок байтов.; value - значение short, которое нужно записать.

getIntAtIndex

public static int getIntAtIndex(MemorySegment segment, long index, ByteOrder order)

Читает значение int из заданного сегмента и индекса элемента с заданным порядком байтов.

Это эквивалентно следующему коду:


    int value = getIntAtOffset(segment, 4 * index, order);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 4).; order - указанный порядок байтов.
Returns:: значение int, прочитанное из segment по индексу элемента, указанному в index.

setIntAtIndex

public static void setIntAtIndex(MemorySegment segment, long index, ByteOrder order, int value)

Записывает значение int в заданный сегмент и индекс элемента с заданным порядком байтов.

Это эквивалентно следующему коду:


    setIntAtOffset(segment, 4 * index, order, value);

Parameters:: segment - сегмент, который нужно дериференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения можно выразить как segment.address().addOffset(index * 4).; order - указанный порядок байтов.; value - значение int, которое нужно записать.

getFloatAtIndex

public static float getFloatAtIndex(MemorySegment segment, long index, ByteOrder order)

Считывает значение float из заданного сегмента и индекса элемента с указанным порядком байтов.

Это эквивалентно следующему коду:


    float value = getFloatAtOffset(segment, 4 * index, order);

Параметры:: segment - сегмент, который нужно дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 4).; order - указанный порядок байтов.
Возвращает:: значение float, считанное из segment по индексу элемента, указанному в index.

setFloatAtIndex

public static void setFloatAtIndex(MemorySegment segment, long index, ByteOrder order, float value)

Записывает значение float в заданный сегмент и индекс элемента с указанным порядком байтов.

Это эквивалентно следующему коду:


    setFloatAtOffset(segment, 4 * index, order, value);

Параметры:: segment - сегмент, который нужно дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 4).; order - указанный порядок байтов.; value - значение float, которое нужно записать.

getLongAtIndex

public static long getLongAtIndex(MemorySegment segment, long index, ByteOrder order)

Считывает значение long из заданного сегмента и индекса элемента с указанным порядком байтов.

Это эквивалентно следующему коду:


    return getLongAtOffset(segment, 8 * index, order);

Параметры:: segment - сегмент, который нужно дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 8).; order - указанный порядок байтов.
Возвращает:: значение long, считанное из segment по индексу элемента, указанному в index.

setLongAtIndex

public static void setLongAtIndex(MemorySegment segment, long index, ByteOrder order, long value)

Записывает значение long в заданный сегмент и индекс элемента с указанным порядком байтов.

Это эквивалентно следующему коду:


    setLongAtOffset(segment, 8 * index, order, value);

Параметры:: segment - сегмент, который нужно дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 8).; order - указанный порядок байтов.; value - значение long, которое нужно записать.

getDoubleAtIndex

public static double getDoubleAtIndex(MemorySegment segment, long index, ByteOrder order)

Считывает значение double из заданного сегмента и индекса элемента с указанным порядком байтов.

Это эквивалентно следующему коду:


    return getDoubleAtOffset(segment, 8 * index, order);

Параметры:: segment - сегмент, который нужно дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 8).; order - указанный порядок байтов.
Возвращает:: значение double, считанное из segment по индексу элемента, указанному в index.

setDoubleAtIndex

public static void setDoubleAtIndex(MemorySegment segment, long index, ByteOrder order, double value)

Записывает значение double в заданный сегмент и индекс элемента с указанным порядком байтов.

Это эквивалентно следующему коду:


    setDoubleAtOffset(segment, 8 * index, order, value);

Параметры:: segment - сегмент, который нужно дереференцировать.; index - индекс элемента (относительно segment). Конечный адрес этой операции чтения может быть выражен как segment.address().addOffset(index * 8).; order - указанный порядок байтов.; value - значение double, которое нужно записать.

© 1993, 2021, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/17/docs/api/jdk.incubator.foreign/jdk/incubator/foreign/MemoryAccess.html