StandardMemoryAccessor (Hazelcast Root 3.7 API)

java.lang.Object
- com.hazelcast.internal.memory.impl.StandardMemoryAccessor

All Implemented Interfaces:

ByteAccessStrategy<Object>, ConcurrentHeapMemoryAccessor, ConcurrentMemoryAccessor, GlobalMemoryAccessor, HeapMemoryAccessor, MemoryAccessor
```
public final class StandardMemoryAccessor
extends Object
```
Standard MemoryAccessor implementations that directly uses Unsafe for accessing to memory.

Field Summary

Fields
Modifier and Type Field and Description

static StandardMemoryAccessor INSTANCE
- Fields inherited from interface com.hazelcast.internal.memory.GlobalMemoryAccessor
  MEM_COPY_THRESHOLD
- Fields inherited from interface com.hazelcast.internal.memory.HeapMemoryAccessor
  ARRAY_BOOLEAN_BASE_OFFSET, ARRAY_BOOLEAN_INDEX_SCALE, ARRAY_BYTE_BASE_OFFSET, ARRAY_BYTE_INDEX_SCALE, ARRAY_CHAR_BASE_OFFSET, ARRAY_CHAR_INDEX_SCALE, ARRAY_DOUBLE_BASE_OFFSET, ARRAY_DOUBLE_INDEX_SCALE, ARRAY_FLOAT_BASE_OFFSET, ARRAY_FLOAT_INDEX_SCALE, ARRAY_INT_BASE_OFFSET, ARRAY_INT_INDEX_SCALE, ARRAY_LONG_BASE_OFFSET, ARRAY_LONG_INDEX_SCALE, ARRAY_OBJECT_BASE_OFFSET, ARRAY_OBJECT_INDEX_SCALE, ARRAY_SHORT_BASE_OFFSET, ARRAY_SHORT_INDEX_SCALE

Fields
Modifier and Type	Field and Description
`static StandardMemoryAccessor`	`INSTANCE`

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`arrayBaseOffset(Class<?> arrayClass)` Gets the base offset of the array typed with given class.
`int`	`arrayIndexScale(Class<?> arrayClass)` Gets the index scale of the array typed with given class.
`boolean`	`compareAndSwapInt(long address, int expected, int x)` Compares and swaps the given int value to the expected value atomically based in the given object with given offset if and only if its current value equals to specified expected value.
`boolean`	`compareAndSwapInt(Object base, long offset, int expected, int x)` Compares and swaps an int value to an expected value atomically based by given object with given offset, if and only if its current value is equal to the expected value.
`boolean`	`compareAndSwapLong(long address, long expected, long x)` Compares and swaps the long value to the expected value atomically based in the given object with given offset if and only if its current value equals the expected value.
`boolean`	`compareAndSwapLong(Object base, long offset, long expected, long x)` Compares and swaps a long value to an expected value atomically based by given object with given offset if and only if its current value equals to the expected value.
`boolean`	`compareAndSwapObject(long address, Object expected, Object x)` Compares and swaps the referenced object to the expected object atomically based by given owner object at given offset if and only if its current referenced object is the expected object.
`boolean`	`compareAndSwapObject(Object base, long offset, Object expected, Object x)` Compares and swaps referenced object to expected object atomically based by given owner object at given offset if and only if its current object is the expected object.
`void`	`copyFromByteArray(byte[] source, int offset, long destAddress, int length)` Copies bytes from a Java byte array into this accessor's address space.
`void`	`copyMemory(long srcAddress, long destAddress, long lengthBytes)` Copies memory from given source address to given destination address as given size.
`void`	`copyMemory(Object srcObj, long srcOffset, Object destObj, long destOffset, long lengthBytes)` Copies memory from source to destination.
`void`	`copyToByteArray(long srcAddress, byte[] destination, int offset, int length)` Copies bytes from this accessor's address space to a Java byte array.
`boolean`	`getBoolean(long address)` Reads the boolean value from given address.
`boolean`	`getBoolean(Object base, long offset)` Returns the boolean value at the supplied offset from the supplied object's base address.
`boolean`	`getBooleanVolatile(long address)` Reads the boolean value as volatile from given object by its offset.
`boolean`	`getBooleanVolatile(Object base, long offset)` Reads the boolean value as volatile from given object by its offset.
`byte`	`getByte(long address)` Reads the byte value from given address.
`byte`	`getByte(Object base, long offset)` Return byte from external resource
`byte`	`getByteVolatile(long address)` Reads the byte value as volatile from given object by its offset.
`byte`	`getByteVolatile(Object base, long offset)` Reads the byte value as volatile from given object by its offset.
`char`	`getChar(long address)` Reads the char value from given address.
`char`	`getChar(Object base, long offset)` Returns the char value at the supplied offset from the supplied object's base address.
`char`	`getCharVolatile(long address)` Reads the char value as volatile from given object by its offset.
`char`	`getCharVolatile(Object base, long offset)` Reads the char value as volatile from given object by its offset.
`double`	`getDouble(long address)` Reads the double value from given address.
`double`	`getDouble(Object base, long offset)` Returns the double value at the supplied offset from the supplied object's base address.
`double`	`getDoubleVolatile(long address)` Reads the double value as volatile from given object by its offset.
`double`	`getDoubleVolatile(Object base, long offset)` Reads the double value as volatile from given object by its offset.
`float`	`getFloat(long address)` Reads the float value from given address.
`float`	`getFloat(Object base, long offset)` Returns the float value at the supplied offset from the supplied object's base address.
`float`	`getFloatVolatile(long address)` Reads the float value as volatile from given object by its offset.
`float`	`getFloatVolatile(Object base, long offset)` Reads the float value as volatile from given object by its offset.
`int`	`getInt(long address)` Reads the int value from given address.
`int`	`getInt(Object base, long offset)` Returns the int value at the supplied offset from the supplied object's base address.
`int`	`getIntVolatile(long address)` Reads the int value as volatile from given object by its offset.
`int`	`getIntVolatile(Object base, long offset)` Reads the int value as volatile from given object by its offset.
`long`	`getLong(long address)` Reads the long value from given address.
`long`	`getLong(Object base, long offset)` Returns the long value at the supplied offset from the supplied object's base address.
`long`	`getLongVolatile(long address)` Reads the long value as volatile from given object by its offset.
`long`	`getLongVolatile(Object base, long offset)` Reads the long value as volatile from given object by its offset.
`Object`	`getObject(Object base, long offset)` Returns the object reference at the supplied offset from the supplied object's base address.
`Object`	`getObjectVolatile(Object base, long offset)` Gets the referenced object from given owner object as volatile by its offset.
`short`	`getShort(long address)` Reads the short value from given address.
`short`	`getShort(Object base, long offset)` Returns the short value at the supplied offset from the supplied object's base address.
`short`	`getShortVolatile(long address)` Reads the short value as volatile from given object by its offset.
`short`	`getShortVolatile(Object base, long offset)` Reads the short value as volatile from given object by its offset.
`static boolean`	`isAvailable()` Returns whether memory accessors of type `UnsafeBasedMemoryAccessor` are available or not.
`boolean`	`isBigEndian()` Tells whether this memory accessor is big- or little-endian.
`long`	`objectFieldOffset(Field field)` Gets the offset of given field.
`void`	`putBoolean(long address, boolean x)` Writes the given boolean value to given address.
`void`	`putBoolean(Object base, long offset, boolean x)` Puts the supplied boolean value at the supplied offset from the supplied object's base address.
`void`	`putBooleanVolatile(long address, boolean x)` Writes the boolean value as volatile to given object by its offset.
`void`	`putBooleanVolatile(Object base, long offset, boolean x)` Writes the boolean value as volatile to given object by its offset.
`void`	`putByte(long address, byte x)` Writes the given byte value to given address.
`void`	`putByte(Object base, long offset, byte x)` Writes byte to corresponding resource
`void`	`putByteVolatile(long address, byte x)` Writes the byte value as volatile to given object by its offset.
`void`	`putByteVolatile(Object base, long offset, byte x)` Writes the byte value as volatile to given object by its offset.
`void`	`putChar(long address, char x)` Writes the given char value to given address.
`void`	`putChar(Object base, long offset, char x)` Puts the supplied char value at the supplied offset from the supplied object's base address.
`void`	`putCharVolatile(long address, char x)` Writes the char value as volatile to given object by its offset.
`void`	`putCharVolatile(Object base, long offset, char x)` Writes the char value as volatile to given object by its offset.
`void`	`putDouble(long address, double x)` Writes the given double value to given address.
`void`	`putDouble(Object base, long offset, double x)` Puts the supplied double value at the supplied offset from the supplied object's base address.
`void`	`putDoubleVolatile(long address, double x)` Writes the double value as volatile to given object by its offset.
`void`	`putDoubleVolatile(Object base, long offset, double x)` Writes the double value as volatile to given object by its offset.
`void`	`putFloat(long address, float x)` Writes the given float value to given address.
`void`	`putFloat(Object base, long offset, float x)` Puts the supplied float value at the supplied offset from the supplied object's base address.
`void`	`putFloatVolatile(long address, float x)` Writes the float value as volatile to given object by its offset.
`void`	`putFloatVolatile(Object base, long offset, float x)` Writes the float value as volatile to given object by its offset.
`void`	`putInt(long address, int x)` Writes the given int value to given address.
`void`	`putInt(Object base, long offset, int x)` Puts the supplied int value at the supplied offset from the supplied object's base address.
`void`	`putIntVolatile(long address, int x)` Writes the int value as volatile to given object by its offset.
`void`	`putIntVolatile(Object base, long offset, int x)` Writes the int value as volatile to given object by its offset.
`void`	`putLong(long address, long x)` Writes the given long value to given address.
`void`	`putLong(Object base, long offset, long x)` Puts the supplied long value at the supplied offset from the supplied object's base address.
`void`	`putLongVolatile(long address, long x)` Writes the long value as volatile to given object by its offset.
`void`	`putLongVolatile(Object base, long offset, long x)` Writes the long value as volatile to given object by its offset.
`void`	`putObject(Object base, long offset, Object x)` Puts the supplied object reference at the supplied offset from the supplied object's base address.
`void`	`putObjectVolatile(Object base, long offset, Object x)` Puts the referenced object to given owner object as volatile by its offset.
`void`	`putOrderedInt(long address, int x)` Puts the given int value as ordered to the CPU write buffer based in the given object at the given offset.
`void`	`putOrderedInt(Object base, long offset, int x)` Puts the given int value as ordered to the CPU write buffer based by the given object at the given offset.
`void`	`putOrderedLong(long address, long x)` Puts the given long value as ordered to the CPU write buffer based in the given object at the given offset.
`void`	`putOrderedLong(Object base, long offset, long x)` Puts the given long value as ordered to the CPU write buffer based by the given object at the given offset.
`void`	`putOrderedObject(long address, Object x)` Puts the given referenced object as ordered to the CPU write buffer based by the given owner object at the given offset.
`void`	`putOrderedObject(Object base, long offset, Object x)` Puts the given referenced object as ordered to the CPU write buffer based by the given owner object at the given offset.
`void`	`putShort(long address, short x)` Writes the given short value to given address.
`void`	`putShort(Object base, long offset, short x)` Puts the supplied short value at the supplied offset from the supplied object's base address.
`void`	`putShortVolatile(long address, short x)` Writes the short value as volatile to given object by its offset.
`void`	`putShortVolatile(Object base, long offset, short x)` Writes the short value as volatile to given object by its offset.
`void`	`setMemory(long address, long lengthBytes, byte value)` Sets memory with given value from specified address as given size.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - INSTANCE
```
public static final StandardMemoryAccessor INSTANCE
```
- Method Detail
  - isBigEndian
```
public boolean isBigEndian()
```
    Description copied from interface: MemoryAccessor
    
    Tells whether this memory accessor is big- or little-endian. This applies to all the multibyte-width methods of integral type (get/putChar, get/putShort, get/putInt, get/putLong declared in this interface and others declared in subinterfaces).
    
    Specified by:
    
    isBigEndian in interface MemoryAccessor
    
    Returns:
    true if the accessor is big-endian; false otherwise
  - getBoolean
```
public boolean getBoolean(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the boolean value from given address.
    
    Parameters:
    address - the address where the boolean value will be read from
    
    Returns:
    the value that is read
  - putBoolean
```
public void putBoolean(long address,
              boolean x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given boolean value to given address.
    
    Parameters:
    address - the address where the boolean value will be written to
    x - the boolean value to be written
  - getByte
```
public byte getByte(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the byte value from given address.
    
    Parameters:
    address - the address where the byte value will be read from
    
    Returns:
    the byte value that was read
  - putByte
```
public void putByte(long address,
           byte x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given byte value to given address.
    
    Parameters:
    address - the address where the byte value will be written to
    x - the byte value to be written
  - getChar
```
public char getChar(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the char value from given address.
    
    Parameters:
    address - the address where the char value will be read from
    
    Returns:
    the char value that was read
  - putChar
```
public void putChar(long address,
           char x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given char value to given address.
    
    Parameters:
    address - the address where the char value will be written to
    x - the char value to be written
  - getShort
```
public short getShort(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the short value from given address.
    
    Parameters:
    address - the address where the short value will be read from
    
    Returns:
    the short value that was read
  - putShort
```
public void putShort(long address,
            short x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given short value to given address.
    
    Parameters:
    address - the address where the short value will be written to
    x - the short value to be written
  - getInt
```
public int getInt(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the int value from given address.
    
    Parameters:
    address - the address where the int value will be read from
    
    Returns:
    the int value that was read
  - putInt
```
public void putInt(long address,
          int x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given int value to given address.
    
    Parameters:
    address - the address where the int value will be written to
    x - the int value to be written
  - getFloat
```
public float getFloat(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the float value from given address.
    
    Parameters:
    address - the address where the float value will be read from
    
    Returns:
    the float value that was read
  - putFloat
```
public void putFloat(long address,
            float x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given float value to given address.
    
    Parameters:
    address - the address where the float value will be written to
    x - the float value to be written
  - getLong
```
public long getLong(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the long value from given address.
    
    Parameters:
    address - the address where the long value will be read from
    
    Returns:
    the long value that was read
  - putLong
```
public void putLong(long address,
           long x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given long value to given address.
    
    Parameters:
    address - the address where the long value will be written to
    x - the long value to be written
  - getDouble
```
public double getDouble(long address)
```
    Description copied from interface: MemoryAccessor
    
    Reads the double value from given address.
    
    Parameters:
    address - the address where the double value will be read from
    
    Returns:
    the double value that was read
  - putDouble
```
public void putDouble(long address,
             double x)
```
    Description copied from interface: MemoryAccessor
    
    Writes the given double value to given address.
    
    Parameters:
    address - the address where the double value will be written to
    x - the double value to be written
  - copyMemory
```
public void copyMemory(long srcAddress,
              long destAddress,
              long lengthBytes)
```
    Description copied from interface: MemoryAccessor
    
    Copies memory from given source address to given destination address as given size.
    
    Parameters:
    srcAddress - the source address to be copied from
    destAddress - the destination address to be copied to
    lengthBytes - the number of bytes to be copied
  - copyFromByteArray
```
public void copyFromByteArray(byte[] source,
                     int offset,
                     long destAddress,
                     int length)
```
    Description copied from interface: MemoryAccessor
    
    Copies bytes from a Java byte array into this accessor's address space.
    
    Parameters:
    source - the source byte array
    offset - index of the first byte to copy
    destAddress - address where the first byte will be written
    length - number of bytes to copy
  - copyToByteArray
```
public void copyToByteArray(long srcAddress,
                   byte[] destination,
                   int offset,
                   int length)
```
    Description copied from interface: MemoryAccessor
    
    Copies bytes from this accessor's address space to a Java byte array.
    
    Parameters:
    srcAddress - address of the first byte to copy
    destination - the destination byte array
    offset - array index where the first byte will be written
    length - number of bytes to copy
  - setMemory
```
public void setMemory(long address,
             long lengthBytes,
             byte value)
```
    Description copied from interface: MemoryAccessor
    
    Sets memory with given value from specified address as given size.
    
    Parameters:
    address - the start address of the memory region which will be set with the given value
    lengthBytes - the number of bytes to be set
    value - the value to be set
  - getBooleanVolatile
```
public boolean getBooleanVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the boolean value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the boolean value that was read
  - putBooleanVolatile
```
public void putBooleanVolatile(long address,
                      boolean x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the boolean value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the boolean value to be written
  - getByteVolatile
```
public byte getByteVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the byte value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the byte value that was read
  - putByteVolatile
```
public void putByteVolatile(long address,
                   byte x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the byte value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the byte value to be written
  - getCharVolatile
```
public char getCharVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the char value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the char value that was read
  - putCharVolatile
```
public void putCharVolatile(long address,
                   char x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the char value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the char value to be written
  - getShortVolatile
```
public short getShortVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the short value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the read value
  - putShortVolatile
```
public void putShortVolatile(long address,
                    short x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the short value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the short value to be written
  - getIntVolatile
```
public int getIntVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the int value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the int value that was read
  - putIntVolatile
```
public void putIntVolatile(long address,
                  int x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the int value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the int value to be written
  - getFloatVolatile
```
public float getFloatVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the float value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the float value that was read
  - putFloatVolatile
```
public void putFloatVolatile(long address,
                    float x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the float value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the float value to be written
  - getLongVolatile
```
public long getLongVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the long value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the long value that was read
  - putLongVolatile
```
public void putLongVolatile(long address,
                   long x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the long value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the long value to be written
  - getDoubleVolatile
```
public double getDoubleVolatile(long address)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Reads the double value as volatile from given object by its offset.
    
    Parameters:
    address - address to access
    
    Returns:
    the long value that was read
  - putDoubleVolatile
```
public void putDoubleVolatile(long address,
                     double x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Writes the double value as volatile to given object by its offset.
    
    Parameters:
    address - address to access
    x - the double value to be written
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long address,
                        int expected,
                        int x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Compares and swaps the given int value to the expected value atomically based in the given object with given offset if and only if its current value equals to specified expected value.
    
    Parameters:
    address - address to access
    expected - the expected current int value to be set to the new int value
    x - the int value to be written
    
    Returns:
    true if CAS is successful, false otherwise
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long address,
                         long expected,
                         long x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Compares and swaps the long value to the expected value atomically based in the given object with given offset if and only if its current value equals the expected value.
    
    Parameters:
    address - address to access
    expected - the expected current long value to be set to the new long value
    x - the long value to be written
    
    Returns:
    true if CAS is successful, false otherwise
  - compareAndSwapObject
```
public boolean compareAndSwapObject(long address,
                           Object expected,
                           Object x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Compares and swaps the referenced object to the expected object atomically based by given owner object at given offset if and only if its current referenced object is the expected object.
    
    Parameters:
    address - address to access
    expected - the expected current object to be set to the new referenced object
    x - the referenced object to be written
    
    Returns:
    true if CAS is successful, false otherwise
  - putOrderedInt
```
public void putOrderedInt(long address,
                 int x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Puts the given int value as ordered to the CPU write buffer based in the given object at the given offset.
    
    Parameters:
    address - address to access
    x - the int value to be written
  - putOrderedLong
```
public void putOrderedLong(long address,
                  long x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Puts the given long value as ordered to the CPU write buffer based in the given object at the given offset.
    
    Parameters:
    address - address to access
    x - the long value to be written
  - putOrderedObject
```
public void putOrderedObject(long address,
                    Object x)
```
    Description copied from interface: ConcurrentMemoryAccessor
    
    Puts the given referenced object as ordered to the CPU write buffer based by the given owner object at the given offset.
    
    Parameters:
    address - address to access
    x - the referenced object to be written
  - objectFieldOffset
```
public long objectFieldOffset(Field field)
```
    Description copied from interface: HeapMemoryAccessor
    
    Gets the offset of given field.
    
    Parameters:
    field - the field whose offset is requested
    
    Returns:
    the offset of given field
  - arrayBaseOffset
```
public int arrayBaseOffset(Class<?> arrayClass)
```
    Description copied from interface: HeapMemoryAccessor
    
    Gets the base offset of the array typed with given class.
    
    Parameters:
    arrayClass - the type of the array whose base offset is requested
    
    Returns:
    the base offset of the array typed with given class
  - arrayIndexScale
```
public int arrayIndexScale(Class<?> arrayClass)
```
    Description copied from interface: HeapMemoryAccessor
    
    Gets the index scale of the array typed with given class.
    
    Parameters:
    arrayClass - the type of the array whose index scale is requested
    
    Returns:
    the index scale of the array typed with given class
  - getObject
```
public Object getObject(Object base,
               long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the object reference at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putObject
```
public void putObject(Object base,
             long offset,
             Object x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied object reference at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getBoolean
```
public boolean getBoolean(Object base,
                 long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the boolean value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putBoolean
```
public void putBoolean(Object base,
              long offset,
              boolean x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied boolean value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getByte
```
public byte getByte(Object base,
           long offset)
```
    Description copied from interface: ByteAccessStrategy
    
    Return byte from external resource
    
    Parameters:
    base - - resource to access
    offset - - offset of byte
    
    Returns:
    - byte from resource
  - putByte
```
public void putByte(Object base,
           long offset,
           byte x)
```
    Description copied from interface: ByteAccessStrategy
    
    Writes byte to corresponding resource
    
    Parameters:
    base - - resource to access
    offset - - offset of byte
    x - - byte to write
  - getChar
```
public char getChar(Object base,
           long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the char value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putChar
```
public void putChar(Object base,
           long offset,
           char x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied char value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getShort
```
public short getShort(Object base,
             long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the short value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putShort
```
public void putShort(Object base,
            long offset,
            short x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied short value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getInt
```
public int getInt(Object base,
         long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the int value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putInt
```
public void putInt(Object base,
          long offset,
          int x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied int value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getFloat
```
public float getFloat(Object base,
             long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the float value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putFloat
```
public void putFloat(Object base,
            long offset,
            float x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied float value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getLong
```
public long getLong(Object base,
           long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the long value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putLong
```
public void putLong(Object base,
           long offset,
           long x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied long value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getDouble
```
public double getDouble(Object base,
               long offset)
```
    Description copied from interface: HeapMemoryAccessor
    
    Returns the double value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the object whose base address to use for the operation
    offset - offset from object's base to the accessed location
  - putDouble
```
public void putDouble(Object base,
             long offset,
             double x)
```
    Description copied from interface: HeapMemoryAccessor
    
    Puts the supplied double value at the supplied offset from the supplied object's base address.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - copyMemory
```
public void copyMemory(Object srcObj,
              long srcOffset,
              Object destObj,
              long destOffset,
              long lengthBytes)
```
    Description copied from interface: HeapMemoryAccessor
    
    Copies memory from source to destination. Source and destination addresses are specified in the form (baseObject, offset) such that the offset is added to the object's base address on Java heap.
    
    Parameters:
    srcObj - source object
    srcOffset - source offset
    destObj - destination object
    destOffset - destination offset
    lengthBytes - number of bytes to be copied
  - getObjectVolatile
```
public Object getObjectVolatile(Object base,
                       long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Gets the referenced object from given owner object as volatile by its offset.
    
    Parameters:
    base - the owner object where the referenced object will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the retrieved referenced object
  - putObjectVolatile
```
public void putObjectVolatile(Object base,
                     long offset,
                     Object x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Puts the referenced object to given owner object as volatile by its offset.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - getBooleanVolatile
```
public boolean getBooleanVolatile(Object base,
                         long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the boolean value as volatile from given object by its offset.
    
    Parameters:
    base - the object where boolean value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the boolean value that was read
  - putBooleanVolatile
```
public void putBooleanVolatile(Object base,
                      long offset,
                      boolean x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the boolean value as volatile to given object by its offset.
    
    Parameters:
    base - the object where boolean value will be written to
    offset - offset from object's base to the accessed location
    x - the boolean value to be written
  - getByteVolatile
```
public byte getByteVolatile(Object base,
                   long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the byte value as volatile from given object by its offset.
    
    Parameters:
    base - the object where the byte value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the byte value that was read
  - putByteVolatile
```
public void putByteVolatile(Object base,
                   long offset,
                   byte x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the byte value as volatile to given object by its offset.
    
    Parameters:
    base - the object where the byte value will be written to
    offset - offset from object's base to the accessed location
    x - the byte value to be written
  - getCharVolatile
```
public char getCharVolatile(Object base,
                   long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the char value as volatile from given object by its offset.
    
    Parameters:
    base - the object where char value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the char value that was read
  - putCharVolatile
```
public void putCharVolatile(Object base,
                   long offset,
                   char x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the char value as volatile to given object by its offset.
    
    Parameters:
    base - the object where char value will be written to
    offset - offset from object's base to the accessed location
    x - the char value to be written
  - getShortVolatile
```
public short getShortVolatile(Object base,
                     long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the short value as volatile from given object by its offset.
    
    Parameters:
    base - the object where short value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the short value that ws read
  - putShortVolatile
```
public void putShortVolatile(Object base,
                    long offset,
                    short x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the short value as volatile to given object by its offset.
    
    Parameters:
    base - the object where short value will be written to
    offset - offset from object's base to the accessed location
    x - the short value to be written
  - getIntVolatile
```
public int getIntVolatile(Object base,
                 long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the int value as volatile from given object by its offset.
    
    Parameters:
    base - the object where int value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the int value that was read
  - putIntVolatile
```
public void putIntVolatile(Object base,
                  long offset,
                  int x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the int value as volatile to given object by its offset.
    
    Parameters:
    base - the object where int value will be written to
    offset - offset from object's base to the accessed location
    x - the int value to be written
  - getFloatVolatile
```
public float getFloatVolatile(Object base,
                     long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the float value as volatile from given object by its offset.
    
    Parameters:
    base - the object where float value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the float value that was read
  - putFloatVolatile
```
public void putFloatVolatile(Object base,
                    long offset,
                    float x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the float value as volatile to given object by its offset.
    
    Parameters:
    base - the object where float value will be written to
    offset - offset from object's base to the accessed location
    x - the float value to be written
  - getLongVolatile
```
public long getLongVolatile(Object base,
                   long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the long value as volatile from given object by its offset.
    
    Parameters:
    base - the object where long value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the long value that was read
  - putLongVolatile
```
public void putLongVolatile(Object base,
                   long offset,
                   long x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the long value as volatile to given object by its offset.
    
    Parameters:
    base - the object where long value will be written to
    offset - offset from object's base to the accessed location
    x - the long value to be written
  - getDoubleVolatile
```
public double getDoubleVolatile(Object base,
                       long offset)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Reads the double value as volatile from given object by its offset.
    
    Parameters:
    base - the object where double value will be read from
    offset - offset from object's base to the accessed location
    
    Returns:
    the double value that was read
  - putDoubleVolatile
```
public void putDoubleVolatile(Object base,
                     long offset,
                     double x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Writes the double value as volatile to given object by its offset.
    
    Parameters:
    base - the object where double value will be written to
    offset - offset from object's base to the accessed location
    x - the double value to be written
  - putOrderedInt
```
public void putOrderedInt(Object base,
                 long offset,
                 int x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Puts the given int value as ordered to the CPU write buffer based by the given object at the given offset.
    
    Parameters:
    base - the object where the int value will be written to
    offset - offset from object's base to the accessed location
    x - the int value to be written
  - putOrderedLong
```
public void putOrderedLong(Object base,
                  long offset,
                  long x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Puts the given long value as ordered to the CPU write buffer based by the given object at the given offset.
    
    Parameters:
    base - the object where the long value will be written to
    offset - offset from object's base to the accessed location
    x - the long value to be written
  - putOrderedObject
```
public void putOrderedObject(Object base,
                    long offset,
                    Object x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Puts the given referenced object as ordered to the CPU write buffer based by the given owner object at the given offset.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    x - the referenced object to be written
  - compareAndSwapInt
```
public boolean compareAndSwapInt(Object base,
                        long offset,
                        int expected,
                        int x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Compares and swaps an int value to an expected value atomically based by given object with given offset, if and only if its current value is equal to the expected value.
    
    Parameters:
    base - the object where int value will be written to
    offset - offset from object's base to the accessed location
    expected - the expected current int value to be set new int value
    x - the int value to be written
    
    Returns:
    true if CAS is successful, false otherwise
  - compareAndSwapLong
```
public boolean compareAndSwapLong(Object base,
                         long offset,
                         long expected,
                         long x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Compares and swaps a long value to an expected value atomically based by given object with given offset if and only if its current value equals to the expected value.
    
    Parameters:
    base - the object where long value will be written to
    offset - offset from object's base to the accessed location
    expected - the expected current long value to be set new long value
    x - the long value to be written
    
    Returns:
    true if CAS is successful, false otherwise
  - compareAndSwapObject
```
public boolean compareAndSwapObject(Object base,
                           long offset,
                           Object expected,
                           Object x)
```
    Description copied from interface: ConcurrentHeapMemoryAccessor
    
    Compares and swaps referenced object to expected object atomically based by given owner object at given offset if and only if its current object is the expected object.
    
    Parameters:
    base - the owner object where the referenced object will be written to
    offset - offset from object's base to the accessed location
    expected - the expected current referenced object to be set to new referenced object
    x - the new referenced object that will be written
    
    Returns:
    true if CAS is successful, false otherwise
  - isAvailable
```
public static boolean isAvailable()
```
    Returns whether memory accessors of type UnsafeBasedMemoryAccessor are available or not.

Class StandardMemoryAccessor

Field Summary

Fields inherited from interface com.hazelcast.internal.memory.GlobalMemoryAccessor

Fields inherited from interface com.hazelcast.internal.memory.HeapMemoryAccessor

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INSTANCE

Method Detail

isBigEndian

getBoolean

putBoolean

getByte

putByte

getChar

putChar

getShort

putShort

getInt

putInt

getFloat

putFloat

getLong

putLong

getDouble

putDouble

copyMemory

copyFromByteArray

copyToByteArray

setMemory

getBooleanVolatile

putBooleanVolatile

getByteVolatile

putByteVolatile

getCharVolatile

putCharVolatile

getShortVolatile

putShortVolatile

getIntVolatile

putIntVolatile

getFloatVolatile

putFloatVolatile

getLongVolatile

putLongVolatile

getDoubleVolatile

putDoubleVolatile

compareAndSwapInt

compareAndSwapLong

compareAndSwapObject

putOrderedInt

putOrderedLong

putOrderedObject

objectFieldOffset

arrayBaseOffset

arrayIndexScale

getObject

putObject

getBoolean

putBoolean

getByte

putByte

getChar

putChar

getShort

putShort

getInt

putInt

getFloat

putFloat

getLong

putLong

getDouble

putDouble

copyMemory

getObjectVolatile

putObjectVolatile

getBooleanVolatile

putBooleanVolatile

getByteVolatile

putByteVolatile