NativeMemory (com.yahoo.datasketches:memory 0.9.0 API)

java.lang.Object
- com.yahoo.memory.NativeMemory

All Implemented Interfaces:

Memory

Direct Known Subclasses:

AllocMemory, MemoryMappedFile
```
public class NativeMemory
extends Object
implements Memory
```
The NativeMemory class implements the Memory interface and is used to access Java primitive arrays, and ByteBuffers by presenting them as arguments to the constructors of this class.
The sub-class AllocMemory is used to allocate direct, off-heap native memory, which is then accessed by the NativeMemory methods.
These methods extend many of the sun.misc.Unsafe class methods. Unsafe is an internal, low-level class used by many Java library classes for performance reasons. To achieve high performance Unsafe DOES NOT do any bounds checking. And for the same performance reasons, the methods in this class DO NOT do any bounds checking when running in a default-configured JVM.

However, the methods in this class will perform bounds checking if the JVM is configured to enable asserts (-ea). Test enviornments such as JUnit and TestNG automatically configure the JVM to enable asserts. Thus, it is incumbent on the user of this class to make sure that their code is thoroughly tested. Violating memory bounds can cause memory segment faults, which takes down the JVM and can be very difficult to debug.

Author:

Lee Rhodes

Constructor Summary

Constructors
Modifier	Constructor and Description
	`NativeMemory(boolean[] booleanArray)` Provides access to the given boolean array using Memory interface
	`NativeMemory(byte[] byteArray)` Provides access to the given byte array using Memory interface
	`NativeMemory(ByteBuffer byteBuf)` Deprecated. Replaced by `wrap(ByteBuffer)`, which supports both writable and read-only ByteBuffers
	`NativeMemory(char[] charArray)` Provides access to the given char array using Memory interface
	`NativeMemory(double[] doubleArray)` Provides access to the given double array using Memory interface
	`NativeMemory(float[] floatArray)` Provides access to the given float array using Memory interface
	`NativeMemory(int[] intArray)` Provides access to the given int array using Memory interface
	`NativeMemory(long[] longArray)` Provides access to the given long array using Memory interface
`protected`	`NativeMemory(long nativeBaseAddress, long capacityBytes, long objectBaseOffset, Object memArray, ByteBuffer byteBuf)`
	`NativeMemory(short[] shortArray)` Provides access to the given short array using Memory interface

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`addAndGetInt(long offsetBytes, int delta)` Atomically adds the given value to the integer located at offsetBytes.
`long`	`addAndGetLong(long offsetBytes, long delta)` Atomically adds the given value to the long located at offsetBytes.
`Object`	`array()` Returns the backing on-heap primitive array if there is one, otherwise returns null
`Memory`	`asReadOnlyMemory()` Returns a read-only version of this memory
`ByteBuffer`	`byteBuffer()` Returns the backing ByteBuffer if there is one, otherwise returns null
`void`	`clear()` Clears all bytes of this Memory to zero
`void`	`clear(long offsetBytes, long lengthBytes)` Clears a portion of this Memory to zero.
`void`	`clearBits(long offsetBytes, byte bitMask)` Clears the bits defined by the bitMask
`boolean`	`compareAndSwapInt(long offsetBytes, int expect, int update)` Atomically sets the current value at the memory location to the given updated value if and only if the current value `==` the expected value.
`boolean`	`compareAndSwapLong(long offsetBytes, long expect, long update)` Atomically sets the current value at the memory location to the given updated value if and only if the current value `==` the expected value.
`void`	`copy(long srcOffsetBytes, long dstOffsetBytes, long lengthBytes)` Deprecated.
`void`	`copy(long srcOffsetBytes, Memory destination, long dstOffsetBytes, long lengthBytes)` Copies bytes from a source range of this Memory to a destination range of the given Memory using the same low-level system copy function as found in `System.arraycopy(Object, int, Object, int, int)`.
`static void`	`copy(Memory source, long srcOffsetBytes, Memory destination, long dstOffsetBytes, long lengthBytes)` Deprecated. Use `Memory.copy(long, Memory, long, long)` instead.
`void`	`fill(byte value)` Fills all bytes of this Memory region to the given byte value.
`void`	`fill(long offsetBytes, long lengthBytes, byte value)` Fills a portion of this Memory region to the given byte value.
`void`	`freeMemory()` Because the Memory classes now use the JVM Cleaner, calling freeMemory(), which also calls Cleaner, is optional.
`long`	`getAddress(long offsetBytes)` Returns the start address of this Memory relative to its parent plus the offset in bytes.
`int`	`getAndSetInt(long offsetBytes, int newValue)` Atomically exchanges the given value with the current value located at offsetBytes.
`long`	`getAndSetLong(long offsetBytes, long newValue)` Atomically exchanges the given value with the current value located at offsetBytes.
`boolean`	`getBoolean(long offsetBytes)` Gets the boolean value at the given offset
`void`	`getBooleanArray(long offsetBytes, boolean[] dstArray, int dstOffset, int length)` Gets the boolean array at the given offset
`byte`	`getByte(long offsetBytes)` Gets the byte at the given offset
`void`	`getByteArray(long offsetBytes, byte[] dstArray, int dstOffset, int length)` Gets the byte array at the given offset
`long`	`getCapacity()` Gets the capacity of this Memory in bytes
`char`	`getChar(long offsetBytes)` Gets the char at the given offset
`void`	`getCharArray(long offsetBytes, char[] dstArray, int dstOffset, int length)` Gets the char array at the given offset
`long`	`getCumulativeOffset(long offsetBytes)` Returns the cumulative offset in bytes of this Memory from the root of the Memory hierarchy including the given offsetBytes.
`double`	`getDouble(long offsetBytes)` Gets the double at the given offset
`void`	`getDoubleArray(long offsetBytes, double[] dstArray, int dstOffset, int length)` Gets the double array at the given offset
`float`	`getFloat(long offsetBytes)` Gets the float at the given offset
`void`	`getFloatArray(long offsetBytes, float[] dstArray, int dstOffset, int length)` Gets the float array at the given offset
`int`	`getInt(long offsetBytes)` Gets the int at the given offset
`void`	`getIntArray(long offsetBytes, int[] dstArray, int dstOffset, int length)` Gets the int array at the given offset
`long`	`getLong(long offsetBytes)` Gets the long at the given offset
`void`	`getLongArray(long offsetBytes, long[] dstArray, int dstOffset, int length)` Gets the long array at the given offset
`MemoryRequest`	`getMemoryRequest()` Returns a MemoryRequest or null
`Object`	`getParent()` Gets the parent Memory or backing array.
`short`	`getShort(long offsetBytes)` Gets the short at the given offset
`void`	`getShortArray(long offsetBytes, short[] dstArray, int dstOffset, int length)` Gets the short array at the given offset
`boolean`	`hasArray()` Returns true if this Memory is backed by an on-heap primitive array
`boolean`	`hasByteBuffer()` Returns true if this Memory is backed by a ByteBuffer
`boolean`	`isAllBitsClear(long offsetBytes, byte bitMask)` Returns true if all bits defined by the bitMask are clear
`boolean`	`isAllBitsSet(long offsetBytes, byte bitMask)` Returns true if all bits defined by the bitMask are set
`boolean`	`isAllocated()` Returns true if this Memory has a capacity greater than zero
`boolean`	`isAnyBitsClear(long offsetBytes, byte bitMask)` Returns true if any bits defined by the bitMask are clear
`boolean`	`isAnyBitsSet(long offsetBytes, byte bitMask)` Returns true if any bits defined by the bitMask are set
`boolean`	`isDirect()` Returns true if the backing memory is direct (off-heap) memory.
`boolean`	`isReadOnly()` Returns true if this Memory is read only
`void`	`putBoolean(long offsetBytes, boolean srcValue)` Puts the boolean value at the given offset
`void`	`putBooleanArray(long offsetBytes, boolean[] srcArray, int srcOffset, int length)` Puts the boolean array at the given offset
`void`	`putByte(long offsetBytes, byte srcValue)` Puts the byte value at the given offset
`void`	`putByteArray(long offsetBytes, byte[] srcArray, int srcOffset, int length)` Puts the byte array at the given offset
`void`	`putChar(long offsetBytes, char srcValue)` Puts the char value at the given offset
`void`	`putCharArray(long offsetBytes, char[] srcArray, int srcOffset, int length)` Puts the char array at the given offset
`void`	`putDouble(long offsetBytes, double srcValue)` Puts the double value at the given offset
`void`	`putDoubleArray(long offsetBytes, double[] srcArray, int srcOffset, int length)` Puts the double array at the given offset
`void`	`putFloat(long offsetBytes, float srcValue)` Puts the float value at the given offset
`void`	`putFloatArray(long offsetBytes, float[] srcArray, int srcOffset, int length)` Puts the float array at the given offset
`void`	`putInt(long offsetBytes, int srcValue)` Puts the int value at the given offset
`void`	`putIntArray(long offsetBytes, int[] srcArray, int srcOffset, int length)` Puts the int array at the given offset
`void`	`putLong(long offsetBytes, long srcValue)` Puts the long value at the given offset
`void`	`putLongArray(long offsetBytes, long[] srcArray, int srcOffset, int length)` Puts the long array at the given offset
`void`	`putShort(long offsetBytes, short srcValue)` Puts the short value at the given offset
`void`	`putShortArray(long offsetBytes, short[] srcArray, int srcOffset, int length)` Puts the short array at the given offset
`void`	`setBits(long offsetBytes, byte bitMask)` Sets the bits defined by the bitMask
`void`	`setMemoryRequest(MemoryRequest memReq)` Sets a MemoryRequest
`String`	`toHexString(String header, long offsetBytes, int lengthBytes)` Returns a formatted hex string of an area of this Memory.
`static Memory`	`wrap(ByteBuffer byteBuffer)` Provides access to the backing store of the given ByteBuffer using Memory interface.

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

- Constructor Detail
  - NativeMemory
```
protected NativeMemory(long nativeBaseAddress,
                       long capacityBytes,
                       long objectBaseOffset,
                       Object memArray,
                       ByteBuffer byteBuf)
```
  - NativeMemory
```
public NativeMemory(boolean[] booleanArray)
```
    Provides access to the given boolean array using Memory interface
    
    Parameters:
    
    booleanArray - an on-heap boolean array
  - NativeMemory
```
public NativeMemory(byte[] byteArray)
```
    Provides access to the given byte array using Memory interface
    
    Parameters:
    
    byteArray - an on-heap byte array
  - NativeMemory
```
public NativeMemory(char[] charArray)
```
    Provides access to the given char array using Memory interface
    
    Parameters:
    
    charArray - an on-heap char array
  - NativeMemory
```
public NativeMemory(short[] shortArray)
```
    Provides access to the given short array using Memory interface
    
    Parameters:
    
    shortArray - an on-heap short array
  - NativeMemory
```
public NativeMemory(int[] intArray)
```
    Provides access to the given int array using Memory interface
    
    Parameters:
    
    intArray - an on-heap int array
  - NativeMemory
```
public NativeMemory(long[] longArray)
```
    Provides access to the given long array using Memory interface
    
    Parameters:
    
    longArray - an on-heap long array
  - NativeMemory
```
public NativeMemory(float[] floatArray)
```
    Provides access to the given float array using Memory interface
    
    Parameters:
    
    floatArray - an on-heap float array
  - NativeMemory
```
public NativeMemory(double[] doubleArray)
```
    Provides access to the given double array using Memory interface
    
    Parameters:
    
    doubleArray - an on-heap double array
  - NativeMemory
```
@Deprecated
public NativeMemory(ByteBuffer byteBuf)
```
    Deprecated. Replaced by wrap(ByteBuffer), which supports both writable and read-only ByteBuffers
    
    Provides access to the backing store of the given writable ByteBuffer using Memory interface. For read-only ByteBuffers you must use wrap(ByteBuffer).
    
    Parameters:
    
    byteBuf - the given writable ByteBuffer
- Method Detail
  - wrap
```
public static Memory wrap(ByteBuffer byteBuffer)
```
    Provides access to the backing store of the given ByteBuffer using Memory interface. If the given ByteBuffer is read-only, the returned Memory will also be a read-only instance of NativeMemory.
    
    Parameters:
    
    byteBuffer - the given ByteBuffer
    
    Returns:
    
    a Memory object
  - getBoolean
```
public boolean getBoolean(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the boolean value at the given offset
    
    Specified by:
    
    getBoolean in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the boolean at the given offset
  - getBooleanArray
```
public void getBooleanArray(long offsetBytes,
                            boolean[] dstArray,
                            int dstOffset,
                            int length)
```
    Description copied from interface: Memory
    
    Gets the boolean array at the given offset
    
    Specified by:
    
    getBooleanArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - getByte
```
public byte getByte(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the byte at the given offset
    
    Specified by:
    
    getByte in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the byte at the given offset
  - getByteArray
```
public void getByteArray(long offsetBytes,
                         byte[] dstArray,
                         int dstOffset,
                         int length)
```
    Description copied from interface: Memory
    
    Gets the byte array at the given offset
    
    Specified by:
    
    getByteArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - getChar
```
public char getChar(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the char at the given offset
    
    Specified by:
    
    getChar in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the char at the given offset
  - getCharArray
```
public void getCharArray(long offsetBytes,
                         char[] dstArray,
                         int dstOffset,
                         int length)
```
    Description copied from interface: Memory
    
    Gets the char array at the given offset
    
    Specified by:
    
    getCharArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - getDouble
```
public double getDouble(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the double at the given offset
    
    Specified by:
    
    getDouble in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the double at the given offset
  - getDoubleArray
```
public void getDoubleArray(long offsetBytes,
                           double[] dstArray,
                           int dstOffset,
                           int length)
```
    Description copied from interface: Memory
    
    Gets the double array at the given offset
    
    Specified by:
    
    getDoubleArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - getFloat
```
public float getFloat(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the float at the given offset
    
    Specified by:
    
    getFloat in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the float at the given offset
  - getFloatArray
```
public void getFloatArray(long offsetBytes,
                          float[] dstArray,
                          int dstOffset,
                          int length)
```
    Description copied from interface: Memory
    
    Gets the float array at the given offset
    
    Specified by:
    
    getFloatArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - getInt
```
public int getInt(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the int at the given offset
    
    Specified by:
    
    getInt in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the int at the given offset
  - getIntArray
```
public void getIntArray(long offsetBytes,
                        int[] dstArray,
                        int dstOffset,
                        int length)
```
    Description copied from interface: Memory
    
    Gets the int array at the given offset
    
    Specified by:
    
    getIntArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - getLong
```
public long getLong(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the long at the given offset
    
    Specified by:
    
    getLong in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the long at the given offset
  - getLongArray
```
public void getLongArray(long offsetBytes,
                         long[] dstArray,
                         int dstOffset,
                         int length)
```
    Description copied from interface: Memory
    
    Gets the long array at the given offset
    
    Specified by:
    
    getLongArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - getShort
```
public short getShort(long offsetBytes)
```
    Description copied from interface: Memory
    
    Gets the short at the given offset
    
    Specified by:
    
    getShort in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the short at the given offset
  - getShortArray
```
public void getShortArray(long offsetBytes,
                          short[] dstArray,
                          int dstOffset,
                          int length)
```
    Description copied from interface: Memory
    
    Gets the short array at the given offset
    
    Specified by:
    
    getShortArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffset - offset in array units
    
    length - number of array units to transfer
  - isAllBitsClear
```
public boolean isAllBitsClear(long offsetBytes,
                              byte bitMask)
```
    Description copied from interface: Memory
    
    Returns true if all bits defined by the bitMask are clear
    
    Specified by:
    
    isAllBitsClear in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    bitMask - bits set to one will be checked
    
    Returns:
    
    true if all bits defined by the bitMask are clear
  - isAllBitsSet
```
public boolean isAllBitsSet(long offsetBytes,
                            byte bitMask)
```
    Description copied from interface: Memory
    
    Returns true if all bits defined by the bitMask are set
    
    Specified by:
    
    isAllBitsSet in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    bitMask - bits set to one will be checked
    
    Returns:
    
    true if all bits defined by the bitMask are set
  - isAnyBitsClear
```
public boolean isAnyBitsClear(long offsetBytes,
                              byte bitMask)
```
    Description copied from interface: Memory
    
    Returns true if any bits defined by the bitMask are clear
    
    Specified by:
    
    isAnyBitsClear in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    bitMask - bits set to one will be checked
    
    Returns:
    
    true if any bits defined by the bitMask are clear
  - isAnyBitsSet
```
public boolean isAnyBitsSet(long offsetBytes,
                            byte bitMask)
```
    Description copied from interface: Memory
    
    Returns true if any bits defined by the bitMask are set
    
    Specified by:
    
    isAnyBitsSet in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    bitMask - bits set to one will be checked
    
    Returns:
    
    true if any bits defined by the bitMask are set
  - putBoolean
```
public void putBoolean(long offsetBytes,
                       boolean srcValue)
```
    Description copied from interface: Memory
    
    Puts the boolean value at the given offset
    
    Specified by:
    
    putBoolean in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putBooleanArray
```
public void putBooleanArray(long offsetBytes,
                            boolean[] srcArray,
                            int srcOffset,
                            int length)
```
    Description copied from interface: Memory
    
    Puts the boolean array at the given offset
    
    Specified by:
    
    putBooleanArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - putByte
```
public void putByte(long offsetBytes,
                    byte srcValue)
```
    Description copied from interface: Memory
    
    Puts the byte value at the given offset
    
    Specified by:
    
    putByte in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putByteArray
```
public void putByteArray(long offsetBytes,
                         byte[] srcArray,
                         int srcOffset,
                         int length)
```
    Description copied from interface: Memory
    
    Puts the byte array at the given offset
    
    Specified by:
    
    putByteArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - putChar
```
public void putChar(long offsetBytes,
                    char srcValue)
```
    Description copied from interface: Memory
    
    Puts the char value at the given offset
    
    Specified by:
    
    putChar in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putCharArray
```
public void putCharArray(long offsetBytes,
                         char[] srcArray,
                         int srcOffset,
                         int length)
```
    Description copied from interface: Memory
    
    Puts the char array at the given offset
    
    Specified by:
    
    putCharArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - putDouble
```
public void putDouble(long offsetBytes,
                      double srcValue)
```
    Description copied from interface: Memory
    
    Puts the double value at the given offset
    
    Specified by:
    
    putDouble in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putDoubleArray
```
public void putDoubleArray(long offsetBytes,
                           double[] srcArray,
                           int srcOffset,
                           int length)
```
    Description copied from interface: Memory
    
    Puts the double array at the given offset
    
    Specified by:
    
    putDoubleArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - putFloat
```
public void putFloat(long offsetBytes,
                     float srcValue)
```
    Description copied from interface: Memory
    
    Puts the float value at the given offset
    
    Specified by:
    
    putFloat in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putFloatArray
```
public void putFloatArray(long offsetBytes,
                          float[] srcArray,
                          int srcOffset,
                          int length)
```
    Description copied from interface: Memory
    
    Puts the float array at the given offset
    
    Specified by:
    
    putFloatArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - putInt
```
public void putInt(long offsetBytes,
                   int srcValue)
```
    Description copied from interface: Memory
    
    Puts the int value at the given offset
    
    Specified by:
    
    putInt in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putIntArray
```
public void putIntArray(long offsetBytes,
                        int[] srcArray,
                        int srcOffset,
                        int length)
```
    Description copied from interface: Memory
    
    Puts the int array at the given offset
    
    Specified by:
    
    putIntArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - putLong
```
public void putLong(long offsetBytes,
                    long srcValue)
```
    Description copied from interface: Memory
    
    Puts the long value at the given offset
    
    Specified by:
    
    putLong in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putLongArray
```
public void putLongArray(long offsetBytes,
                         long[] srcArray,
                         int srcOffset,
                         int length)
```
    Description copied from interface: Memory
    
    Puts the long array at the given offset
    
    Specified by:
    
    putLongArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - putShort
```
public void putShort(long offsetBytes,
                     short srcValue)
```
    Description copied from interface: Memory
    
    Puts the short value at the given offset
    
    Specified by:
    
    putShort in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcValue - the value to put
  - putShortArray
```
public void putShortArray(long offsetBytes,
                          short[] srcArray,
                          int srcOffset,
                          int length)
```
    Description copied from interface: Memory
    
    Puts the short array at the given offset
    
    Specified by:
    
    putShortArray in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    srcArray - The source array.
    
    srcOffset - offset in array units
    
    length - number of array units to transfer
  - setBits
```
public void setBits(long offsetBytes,
                    byte bitMask)
```
    Description copied from interface: Memory
    
    Sets the bits defined by the bitMask
    
    Specified by:
    
    setBits in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    bitMask - the bits set to one will be set
  - addAndGetInt
```
public int addAndGetInt(long offsetBytes,
                        int delta)
```
    Description copied from interface: Memory
    
    Atomically adds the given value to the integer located at offsetBytes.
    
    Specified by:
    
    addAndGetInt in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    delta - the amount to add
    
    Returns:
    
    the modified value
  - addAndGetLong
```
public long addAndGetLong(long offsetBytes,
                          long delta)
```
    Description copied from interface: Memory
    
    Atomically adds the given value to the long located at offsetBytes.
    
    Specified by:
    
    addAndGetLong in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    delta - the amount to add
    
    Returns:
    
    the modified value
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long offsetBytes,
                                 int expect,
                                 int update)
```
    Description copied from interface: Memory
    
    Atomically sets the current value at the memory location to the given updated value if and only if the current value == the expected value.
    
    Specified by:
    
    compareAndSwapInt in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    expect - the expected value
    
    update - the new value
    
    Returns:
    
    true if successful. False return indicates that the current value at the memory location was not equal to the expected value.
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offsetBytes,
                                  long expect,
                                  long update)
```
    Description copied from interface: Memory
    
    Atomically sets the current value at the memory location to the given updated value if and only if the current value == the expected value.
    
    Specified by:
    
    compareAndSwapLong in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    expect - the expected value
    
    update - the new value
    
    Returns:
    
    true if successful. False return indicates that the current value at the memory location was not equal to the expected value.
  - getAndSetInt
```
public int getAndSetInt(long offsetBytes,
                        int newValue)
```
    Description copied from interface: Memory
    
    Atomically exchanges the given value with the current value located at offsetBytes.
    
    Specified by:
    
    getAndSetInt in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    newValue - new value
    
    Returns:
    
    the previous value
  - getAndSetLong
```
public long getAndSetLong(long offsetBytes,
                          long newValue)
```
    Description copied from interface: Memory
    
    Atomically exchanges the given value with the current value located at offsetBytes.
    
    Specified by:
    
    getAndSetLong in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    newValue - new value
    
    Returns:
    
    the previous value
  - array
```
public Object array()
```
    Description copied from interface: Memory
    
    Returns the backing on-heap primitive array if there is one, otherwise returns null
    
    Specified by:
    
    array in interface Memory
    
    Returns:
    
    the backing on-heap primitive array if there is one, otherwise returns null
  - asReadOnlyMemory
```
public Memory asReadOnlyMemory()
```
    Description copied from interface: Memory
    
    Returns a read-only version of this memory
    
    Specified by:
    
    asReadOnlyMemory in interface Memory
    
    Returns:
    
    a read-only version of this memory
  - byteBuffer
```
public ByteBuffer byteBuffer()
```
    Description copied from interface: Memory
    
    Returns the backing ByteBuffer if there is one, otherwise returns null
    
    Specified by:
    
    byteBuffer in interface Memory
    
    Returns:
    
    the backing ByteBuffer if there is one, otherwise returns null
  - clear
```
public void clear()
```
    Description copied from interface: Memory
    
    Clears all bytes of this Memory to zero
    
    Specified by:
    
    clear in interface Memory
  - clear
```
public void clear(long offsetBytes,
                  long lengthBytes)
```
    Description copied from interface: Memory
    
    Clears a portion of this Memory to zero.
    
    Specified by:
    
    clear in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    lengthBytes - the length in bytes
  - clearBits
```
public void clearBits(long offsetBytes,
                      byte bitMask)
```
    Description copied from interface: Memory
    
    Clears the bits defined by the bitMask
    
    Specified by:
    
    clearBits in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start.
    
    bitMask - the bits set to one will be cleared
  - copy
```
@Deprecated
public void copy(long srcOffsetBytes,
                             long dstOffsetBytes,
                             long lengthBytes)
```
    Deprecated.
    
    Description copied from interface: Memory
    
    Copies bytes from a source range of this Memory to a destination range of the given Memory using the same low-level system copy function as found in System.arraycopy(Object, int, Object, int, int). These regions may not overlap. This will be checked if asserts are enabled in the JVM.
    
    Specified by:
    
    copy in interface Memory
    
    Parameters:
    
    srcOffsetBytes - the source offset
    
    dstOffsetBytes - the destintaion offset
    
    lengthBytes - the number of bytes to copy
  - copy
```
public void copy(long srcOffsetBytes,
                 Memory destination,
                 long dstOffsetBytes,
                 long lengthBytes)
```
    Description copied from interface: Memory
    
    Copies bytes from a source range of this Memory to a destination range of the given Memory using the same low-level system copy function as found in System.arraycopy(Object, int, Object, int, int).
    
    Specified by:
    
    copy in interface Memory
    
    Parameters:
    
    srcOffsetBytes - the source offset for this Memory
    
    destination - the destination Memory, which may not be Read-Only.
    
    dstOffsetBytes - the destintaion offset
    
    lengthBytes - the number of bytes to copy
  - fill
```
public void fill(byte value)
```
    Description copied from interface: Memory
    
    Fills all bytes of this Memory region to the given byte value.
    
    Specified by:
    
    fill in interface Memory
    
    Parameters:
    
    value - the given byte value
  - fill
```
public void fill(long offsetBytes,
                 long lengthBytes,
                 byte value)
```
    Description copied from interface: Memory
    
    Fills a portion of this Memory region to the given byte value.
    
    Specified by:
    
    fill in interface Memory
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    lengthBytes - the length in bytes
    
    value - the given byte value
  - getAddress
```
public long getAddress(long offsetBytes)
```
    Description copied from interface: Memory
    
    Returns the start address of this Memory relative to its parent plus the offset in bytes. Note that the parent could be native memory or some backing object.
    
    Specified by:
    
    getAddress in interface Memory
    
    Parameters:
    
    offsetBytes - the given offset in bytes from the start address of this Memory relative to its parent.
    
    Returns:
    
    the start address of this Memory relative to its parent plus the offset in bytes.
  - getCapacity
```
public long getCapacity()
```
    Description copied from interface: Memory
    
    Gets the capacity of this Memory in bytes
    
    Specified by:
    
    getCapacity in interface Memory
    
    Returns:
    
    the capacity of this Memory in bytes
  - getCumulativeOffset
```
public long getCumulativeOffset(long offsetBytes)
```
    Description copied from interface: Memory
    
    Returns the cumulative offset in bytes of this Memory from the root of the Memory hierarchy including the given offsetBytes.
    
    Specified by:
    
    getCumulativeOffset in interface Memory
    
    Parameters:
    
    offsetBytes - the given offset in bytes
    
    Returns:
    
    the cumulative offset in bytes of this Memory from the root of the Memory hierarchy including the given offsetBytes.
  - getMemoryRequest
```
public MemoryRequest getMemoryRequest()
```
    Description copied from interface: Memory
    
    Returns a MemoryRequest or null
    
    Specified by:
    
    getMemoryRequest in interface Memory
    
    Returns:
    
    a MemoryRequest or null
  - getParent
```
public Object getParent()
```
    Description copied from interface: Memory
    
    Gets the parent Memory or backing array. Used internally.
    
    Specified by:
    
    getParent in interface Memory
    
    Returns:
    
    the parent Memory.
  - hasArray
```
public boolean hasArray()
```
    Description copied from interface: Memory
    
    Returns true if this Memory is backed by an on-heap primitive array
    
    Specified by:
    
    hasArray in interface Memory
    
    Returns:
    
    true if this Memory is backed by an on-heap primitive array
  - hasByteBuffer
```
public boolean hasByteBuffer()
```
    Description copied from interface: Memory
    
    Returns true if this Memory is backed by a ByteBuffer
    
    Specified by:
    
    hasByteBuffer in interface Memory
    
    Returns:
    
    true if this Memory is backed by a ByteBuffer
  - isAllocated
```
public boolean isAllocated()
```
    Description copied from interface: Memory
    
    Returns true if this Memory has a capacity greater than zero
    
    Specified by:
    
    isAllocated in interface Memory
    
    Returns:
    
    true if this Memory has a capacity greater than zero
  - isDirect
```
public boolean isDirect()
```
    Description copied from interface: Memory
    
    Returns true if the backing memory is direct (off-heap) memory.
    
    Specified by:
    
    isDirect in interface Memory
    
    Returns:
    
    true if the backing memory is direct (off-heap) memory.
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: Memory
    
    Returns true if this Memory is read only
    
    Specified by:
    
    isReadOnly in interface Memory
    
    Returns:
    
    true if this Memory is read only
  - setMemoryRequest
```
public void setMemoryRequest(MemoryRequest memReq)
```
    Description copied from interface: Memory
    
    Sets a MemoryRequest
    
    Specified by:
    
    setMemoryRequest in interface Memory
    
    Parameters:
    
    memReq - the MemoryRequest
  - toHexString
```
public String toHexString(String header,
                          long offsetBytes,
                          int lengthBytes)
```
    Description copied from interface: Memory
    
    Returns a formatted hex string of an area of this Memory. Used primarily for testing.
    
    Specified by:
    
    toHexString in interface Memory
    
    Parameters:
    
    header - descriptive header
    
    offsetBytes - offset bytes relative to this Memory start
    
    lengthBytes - number of bytes to convert to a hex string
    
    Returns:
    
    a formatted hex string in a human readable array
  - freeMemory
```
public void freeMemory()
```
    Description copied from interface: Memory
    
    Because the Memory classes now use the JVM Cleaner, calling freeMemory(), which also calls Cleaner, is optional. In any case, calling freeMemory() is only relevant for Memory objects that have actually allocated native memory, which are those that have been allocated using AllocMemory or MemoryMappedFile.
    Preemptively calling freeMemory() may reduce the load on the JVM GarbageCollector, but the significance of this will have to be verified in the target system environment. Calling freeMemory() always disables the current instance by setting the capacity to zero.
    
    Specified by:
    
    freeMemory in interface Memory
  - copy
```
@Deprecated
public static final void copy(Memory source,
                                          long srcOffsetBytes,
                                          Memory destination,
                                          long dstOffsetBytes,
                                          long lengthBytes)
```
    Deprecated. Use Memory.copy(long, Memory, long, long) instead.
    
    Copies bytes from the source Memory to the destination Memory using the same low-level system copy function as found in System.arraycopy(Object, int, Object, int, int).
    If the source and destination are derived from the same underlying base Memory use Memory.copy(long, long, long) instead. Nonetheless, the source and destination regions should not overlap as it could cause unpredictable results.
    
    Parameters:
    
    source - the source Memory
    
    srcOffsetBytes - the source offset
    
    destination - the destination Memory
    
    dstOffsetBytes - the destination offset
    
    lengthBytes - the number of bytes to copy

Class NativeMemory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

NativeMemory

NativeMemory

NativeMemory

NativeMemory

NativeMemory

NativeMemory

NativeMemory

NativeMemory

NativeMemory

NativeMemory

Method Detail

wrap

getBoolean

getBooleanArray

getByte

getByteArray

getChar

getCharArray

getDouble

getDoubleArray

getFloat

getFloatArray

getInt

getIntArray

getLong

getLongArray

getShort

getShortArray

isAllBitsClear

isAllBitsSet

isAnyBitsClear

isAnyBitsSet

putBoolean

putBooleanArray

putByte

putByteArray

putChar

putCharArray

putDouble

putDoubleArray

putFloat

putFloatArray

putInt

putIntArray

putLong

putLongArray

putShort

putShortArray

setBits

addAndGetInt

addAndGetLong

compareAndSwapInt

compareAndSwapLong

getAndSetInt

getAndSetLong

array

asReadOnlyMemory

byteBuffer

clear

clear

clearBits

copy

copy

fill

fill

getAddress

getCapacity

getCumulativeOffset

getMemoryRequest

getParent

hasArray

hasByteBuffer

isAllocated

isDirect

isReadOnly