モジュール jdk.incubator.foreign
パッケージ jdk.incubator.foreign

クラスMemoryAccess

java.lang.Object
jdk.incubator.foreign.MemoryAccess
public final class MemoryAccess extends Object
このクラスは、様々な方法でメモリー・セグメントを間接参照するために使用できる、すぐに使用可能な静的アクセッサを定義します。

最も基本的なアクセッサである(getIntAtOffset(MemorySegment, long, ByteOrder)を参照してください)では、セグメント、オフセット(バイトで表されます。)およびバイト順序が使用されます。 間接参照が発生する最終アドレスは、指定されたベース・アドレスでMemoryAddress.addOffset(long)を呼び出した場合と同様に、ベース・アドレスを指定されたオフセットでオフセットすることによって計算されます。

オフセットが不要な場合は、クライアントがオフセット座標を省略できるように、オーバーロードが(getInt(MemorySegment, ByteOrder)を参照してください)に提供されます。

配列に似たユースケース(たとえば、指定されたメモリー・セグメントのレイアウトは、要素カウントの指定されたサイズのシーケンス・レイアウトです)での参照解除に役立つように、セグメントおよびlogical要素索引を取得する上位レベルのオーバーロードも提供(getIntAtIndex(MemorySegment, long, ByteOrder)を参照してください)されます。 索引Iからバイト・オフセットOを取得する式は、O = I * Sによって指定されます。Sは、間接参照される要素のサイズ(バイトで表されます。)です。

ネイティブ・バイト順序が優先される場合は、クライアントがバイト順序パラメータを省略できるように、オーバーロードが(getIntAtOffset(MemorySegment, long)を参照してください)に提供されます。

特に指定がないかぎり、null引数、またはこのクラスのメソッドに1つ以上のnull要素を含む配列引数を渡すと、NullPointerExceptionがスローされます。

  • メソッドの詳細

    • 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 - 書き込まれるbyte値。

    • getCharAtOffset

      public static char getCharAtOffset(MemorySegment segment, long offset)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントおよびオフセットからcharを読み取ります。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      戻り値:
      segmentから読み込まれたchar値。

    • setCharAtOffset

      public static void setCharAtOffset(MemorySegment segment, long offset, char value)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントおよびオフセットにcharを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      value - 書き込まれるchar値。

    • getShortAtOffset

      public static short getShortAtOffset(MemorySegment segment, long offset)
      指定されたセグメントおよびオフセットからshortを読み込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      戻り値:
      segmentから読み取られたshort値。

    • setShortAtOffset

      public static void setShortAtOffset(MemorySegment segment, long offset, short value)
      指定されたセグメントおよびオフセットにshortを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      value - 書き込まれるshort値。

    • getIntAtOffset

      public static int getIntAtOffset(MemorySegment segment, long offset)
      指定されたセグメントおよびオフセットからintを読み込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      戻り値:
      segmentから読み込まれたint値。

    • setIntAtOffset

      public static void setIntAtOffset(MemorySegment segment, long offset, int value)
      指定されたセグメントおよびオフセットにintを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      value - 書き込まれるint値。

    • getFloatAtOffset

      public static float getFloatAtOffset(MemorySegment segment, long offset)
      指定されたセグメントおよびオフセットからfloatを読み込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      戻り値:
      segmentから読み込まれたfloat値。

    • setFloatAtOffset

      public static void setFloatAtOffset(MemorySegment segment, long offset, float value)
      指定されたセグメントおよびオフセットにfloatを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      value - 書き込まれるfloat値。

    • getLongAtOffset

      public static long getLongAtOffset(MemorySegment segment, long offset)
      指定されたセグメントおよびオフセットからlongを読み込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      戻り値:
      segmentから読み込まれたlong値。

    • setLongAtOffset

      public static void setLongAtOffset(MemorySegment segment, long offset, long value)
      指定されたセグメントおよびオフセットにlongを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      value - 書き込まれるlong値。

    • getDoubleAtOffset

      public static double getDoubleAtOffset(MemorySegment segment, long offset)
      指定されたセグメントおよびオフセットからdoubleを読み込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      戻り値:
      segmentから読み込まれたdouble値。

    • setDoubleAtOffset

      public static void setDoubleAtOffset(MemorySegment segment, long offset, double value)
      指定されたセグメントおよびオフセットにdoubleを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      value - 書き込まれるdouble値。

    • 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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      戻り値:
      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());

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたchar値。

    • 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);

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み取られたshort値。

    • 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);

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたint値。

    • 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);

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたfloat値。

    • 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);

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたlong値。

    • 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);

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたdouble値。

    • 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);

      パラメータ:
      segment - 間接参照されるセグメント。
      offset - バイト単位のオフセット(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(offset)として表すことができます。
      order - 指定されたバイト順序。
      value - 書き込まれるdouble値。

    • getByte

      public static byte getByte(MemorySegment segment)
      指定されたセグメントからバイトを読み込みます。

      これは次のコードと等価です。 

      
    byte value = getByteAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み込まれたバイト値。

    • setByte

      public static void setByte(MemorySegment segment, byte value)
      指定されたセグメントにbyteを書き込みます。

      これは次のコードと等価です。 

      
    setByteAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - 書き込まれるbyte値。

    • getChar

      public static char getChar(MemorySegment segment)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントからcharを読み取ります。

      これは次のコードと等価です。 

      
    char value = getCharAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み込まれたchar値。

    • setChar

      public static void setChar(MemorySegment segment, char value)
      バイト順をByteOrder.nativeOrder()に設定して、指定されたセグメントにcharを書き込みます。

      これは次のコードと等価です。 

      
    setCharAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - 書き込まれるchar値。

    • getShort

      public static short getShort(MemorySegment segment)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントからshortを読み取ります。

      これは次のコードと等価です。 

      
    short value = getShortAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み取られたshort値。

    • setShort

      public static void setShort(MemorySegment segment, short value)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントにshortを書き込みます。

      これは次のコードと等価です。 

      
    setShortAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - 書き込まれるshort値。

    • getInt

      public static int getInt(MemorySegment segment)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントからintを読み取ります。

      これは次のコードと等価です。 

      
    int value = getIntAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み込まれたint値。

    • setInt

      public static void setInt(MemorySegment segment, int value)
      バイト順をByteOrder.nativeOrder()に設定して、指定されたセグメントにintを書き込みます。

      これは次のコードと等価です。 

      
    setIntAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - 書き込まれるint値。

    • getFloat

      public static float getFloat(MemorySegment segment)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントからfloatを読み取ります。

      これは次のコードと等価です。 

      
    float value = getFloatAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み込まれたfloat値。

    • setFloat

      public static void setFloat(MemorySegment segment, float value)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントにfloatを書き込みます。

      これは次のコードと等価です。 

      
    setFloatAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - 書き込まれるfloat値。

    • getLong

      public static long getLong(MemorySegment segment)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントからlongを読み取ります。

      これは次のコードと等価です。 

      
    long value = getLongAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み込まれたlong値。

    • setLong

      public static void setLong(MemorySegment segment, long value)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントにlongを書き込みます。

      これは次のコードと等価です。 

      
    setLongAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - 書き込まれるlong値。

    • getDouble

      public static double getDouble(MemorySegment segment)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントからdoubleを読み取ります。

      これは次のコードと等価です。 

      
    double value = getDoubleAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み込まれたdouble値。

    • setDouble

      public static void setDouble(MemorySegment segment, double value)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントにdoubleを書き込みます。

      これは次のコードと等価です。 

      
    setDoubleAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - 書き込まれるdouble値。

    • getAddress

      public static MemoryAddress getAddress(MemorySegment segment)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントからメモリー・アドレスを読み取ります。

      これは次のコードと等価です。 

      
    MemoryAddress value = getAddressAtOffset(segment, 0L);

      パラメータ:
      segment - 間接参照されるセグメント。
      戻り値:
      segmentから読み取られたメモリー・アドレス。

    • setAddress

      public static void setAddress(MemorySegment segment, Addressable value)
      バイト順をByteOrder.nativeOrder()に設定して、指定されたセグメントにメモリー・アドレスを書き込みます。

      これは次のコードと等価です。 

      
    setAddressAtOffset(segment, 0L, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      value - (Addressableインスタンスとして表現)に書き込むメモリー・アドレス。

    • getChar

      public static char getChar(MemorySegment segment, ByteOrder order)
      指定されたバイト順で、指定されたセグメントからcharを読み込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたchar値。

    • setChar

      public static void setChar(MemorySegment segment, ByteOrder order, char value)
      指定されたバイト順で、指定されたセグメントにcharを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      value - 書き込まれるchar値。

    • getShort

      public static short getShort(MemorySegment segment, ByteOrder order)
      指定されたバイト順で、指定されたセグメントからshortを読み込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み取られたshort値。

    • setShort

      public static void setShort(MemorySegment segment, ByteOrder order, short value)
      指定されたバイト順で、指定されたセグメントにshortを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      value - 書き込まれるshort値。

    • getInt

      public static int getInt(MemorySegment segment, ByteOrder order)
      指定されたバイト順で、指定されたセグメントからintを読み込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたint値。

    • setInt

      public static void setInt(MemorySegment segment, ByteOrder order, int value)
      指定されたバイト順で、指定されたセグメントにintを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      value - 書き込まれるint値。

    • getFloat

      public static float getFloat(MemorySegment segment, ByteOrder order)
      指定されたバイト順で、指定されたセグメントからfloatを読み込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたfloat値。

    • setFloat

      public static void setFloat(MemorySegment segment, ByteOrder order, float value)
      指定されたバイト順で、指定されたセグメントにfloatを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      value - 書き込まれるfloat値。

    • getLong

      public static long getLong(MemorySegment segment, ByteOrder order)
      指定されたバイト順で、指定されたセグメントからlongを読み込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたlong値。

    • setLong

      public static void setLong(MemorySegment segment, ByteOrder order, long value)
      指定されたバイト順で、指定されたセグメントにlongを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      value - 書き込まれるlong値。

    • getDouble

      public static double getDouble(MemorySegment segment, ByteOrder order)
      指定されたバイト順で、指定されたセグメントからdoubleを読み込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      戻り値:
      segmentから読み込まれたdouble値。

    • setDouble

      public static void setDouble(MemorySegment segment, ByteOrder order, double value)
      指定されたバイト順で、指定されたセグメントにdoubleを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      order - 指定されたバイト順序。
      value - 書き込まれるdouble値。

    • getCharAtIndex

      public static char getCharAtIndex(MemorySegment segment, long index)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントおよび要素索引からcharを読み取ります。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 2)として表すことができます。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたchar値。

    • setCharAtIndex

      public static void setCharAtIndex(MemorySegment segment, long index, char value)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントおよび要素索引にcharを書き込みます。

      これは次のコードと等価です。 

      
    setCharAtOffset(segment, 2 * index, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 2)として表すことができます。
      value - 書き込まれるchar値。

    • getShortAtIndex

      public static short getShortAtIndex(MemorySegment segment, long index)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントおよび要素索引からshortを読み取ります。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 2)として表すことができます。
      戻り値:
      indexによって指定された要素インデックスでsegmentから読み取られたshort値。

    • setShortAtIndex

      public static void setShortAtIndex(MemorySegment segment, long index, short value)
      指定されたセグメントおよび要素インデックスにshortを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

      
    setShortAtOffset(segment, 2 * index, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 2)として表すことができます。
      value - 書き込まれるshort値。

    • getIntAtIndex

      public static int getIntAtIndex(MemorySegment segment, long index)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントおよび要素索引からintを読み取ります。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 4)として表すことができます。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたint値。

    • setIntAtIndex

      public static void setIntAtIndex(MemorySegment segment, long index, int value)
      指定されたセグメントおよび要素インデックスにintを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

      
    setIntAtOffset(segment, 4 * index, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 4)として表すことができます。
      value - 書き込まれるint値。

    • getFloatAtIndex

      public static float getFloatAtIndex(MemorySegment segment, long index)
      指定されたセグメントおよび要素インデックスからfloatを読み込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

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

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 4)として表すことができます。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたfloat値。

    • setFloatAtIndex

      public static void setFloatAtIndex(MemorySegment segment, long index, float value)
      指定されたセグメントおよび要素インデックスにfloatを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

      
    setFloatAtOffset(segment, 4 * index, value);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 4)として表すことができます。
      value - 書き込まれるfloat値。

    • getLongAtIndex

      public static long getLongAtIndex(MemorySegment segment, long index)
      バイト・オーダーをByteOrder.nativeOrder()に設定して、指定されたセグメントおよび要素索引からlongを読み取ります。

      これは次のコードと等価です。 

      
    return getLongAtOffset(segment, 8 * index);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 8)として表すことができます。
      戻り値:
      indexによって指定された要素インデックスでsegmentから読み込まれたlong値。

    • setLongAtIndex

      public static void setLongAtIndex(MemorySegment segment, long index, long value)
      指定されたセグメントおよび要素インデックスにlongを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

      
    setLongAtOffset(segment, 8 * index, value);

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 8)として表すことができます。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたdouble値。

    • setDoubleAtIndex

      public static void setDoubleAtIndex(MemorySegment segment, long index, double value)
      指定されたセグメントおよび要素インデックスにdoubleを書き込みます。バイト順はByteOrder.nativeOrder()に設定されます。

      これは次のコードと等価です。 

      
    setDoubleAtOffset(segment, 8 * index, value);

      パラメータ:
      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());

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 8)として表すことができます。
      戻り値:
      indexによって指定された要素インデックスでsegmentから読み取られたメモリー・アドレス。

    • setAddressAtIndex

      public static void setAddressAtIndex(MemorySegment segment, long index, Addressable value)
      バイト順序をByteOrder.nativeOrder()に設定して、指定されたセグメントおよび要素索引にメモリー・アドレスを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 2)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたchar値。

    • setCharAtIndex

      public static void setCharAtIndex(MemorySegment segment, long index, ByteOrder order, char value)
      指定されたバイト順で、指定されたセグメントおよび要素インデックスにcharを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 2)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      indexによって指定された要素インデックスでsegmentから読み取られたshort値。

    • setShortAtIndex

      public static void setShortAtIndex(MemorySegment segment, long index, ByteOrder order, short value)
      指定されたバイト順で、指定されたセグメントおよび要素インデックスにshortを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      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);

      パラメータ:
      segment - 間接参照されるセグメント。
      index - 要素索引(segmentに関連)。 この読取り演算の最終アドレスは、segment.address().addOffset(index * 4)として表すことができます。
      order - 指定されたバイト順序。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたint値。

    • setIntAtIndex

      public static void setIntAtIndex(MemorySegment segment, long index, ByteOrder order, int value)
      指定されたバイト順で、指定されたセグメントおよび要素インデックスにintを書き込みます。

      これは次のコードと等価です。 

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

      パラメータ:
      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 - 指定されたバイト順序。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたfloat値。

    • 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 - 指定されたバイト順序。
      戻り値:
      indexによって指定された要素インデックスでsegmentから読み込まれたlong値。

    • 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 - 指定されたバイト順序。
      戻り値:
      indexで指定された要素インデックスでsegmentから読み込まれたdouble値。

    • 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値。