Memory (com.yahoo.datasketches:memory 0.12.1 API)

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

Direct Known Subclasses:

WritableMemory
```
public abstract class Memory
extends Object
```
Provides read-only primitive and primitive array methods to any of the four resources mentioned in the package level documentation.

Author:

Roman Leventov, Lee Rhodes

See Also:

com.yahoo.memory

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract Buffer`	`asBuffer()` Returns a new Buffer view of this object.
`abstract Buffer`	`asBuffer(ByteOrder byteOrder)` Returns a new Buffer view of this object, with the given byte order.
`void`	`checkValidAndBounds(long offsetBytes, long lengthBytes)` Checks that the specified range of bytes is within bounds of this object, throws `IllegalArgumentException` if it's not: i.
`abstract int`	`compareTo(long thisOffsetBytes, long thisLengthBytes, Memory that, long thatOffsetBytes, long thatLengthBytes)` Compares the bytes of this Memory to that Memory.
`abstract void`	`copyTo(long srcOffsetBytes, WritableMemory destination, long dstOffsetBytes, long lengthBytes)` Copies bytes from a source range of this Memory to a destination range of the given Memory with the same semantics when copying between overlapping ranges of bytes as method `System.arraycopy(Object, int, Object, int, int)` has.
`boolean`	`equals(Object that)` Returns true if the given object is an instance of this class and has equal data contents.
`boolean`	`equalTo(long thisOffsetBytes, Object that, long thatOffsetBytes, long lengthBytes)` Returns true if the given object is an instance of this class and has equal contents to this object in the given range of bytes.
`abstract boolean`	`getBoolean(long offsetBytes)` Gets the boolean value at the given offset
`abstract void`	`getBooleanArray(long offsetBytes, boolean[] dstArray, int dstOffsetBooleans, int lengthBooleans)` Gets the boolean array at the given offset
`abstract byte`	`getByte(long offsetBytes)` Gets the byte value at the given offset
`abstract void`	`getByteArray(long offsetBytes, byte[] dstArray, int dstOffsetBytes, int lengthBytes)` Gets the byte array at the given offset
`ByteBuffer`	`getByteBuffer()` Gets the backing ByteBuffer if it exists, otherwise returns null.
`ByteOrder`	`getByteOrder()` Gets the current ByteOrder.
`long`	`getCapacity()` Gets the capacity of this object in bytes
`abstract char`	`getChar(long offsetBytes)` Gets the char value at the given offset
`abstract void`	`getCharArray(long offsetBytes, char[] dstArray, int dstOffsetChars, int lengthChars)` Gets the char array at the given offset
`abstract int`	`getCharsFromUtf8(long offsetBytes, int utf8LengthBytes, Appendable dst)` Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of utf8LengthBytes, decodes them into characters and appends them to the given Appendable.
`abstract int`	`getCharsFromUtf8(long offsetBytes, int utf8LengthBytes, StringBuilder dst)` Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of utf8LengthBytes, decodes them into characters and appends them to the given StringBuilder.
`long`	`getCumulativeOffset()` Gets the cumulative offset in bytes of this object from the backing resource.
`long`	`getCumulativeOffset(long offsetBytes)` Gets the cumulative offset in bytes of this object from the backing resource including the given offsetBytes.
`static long`	`getCurrentDirectMemoryAllocated()` Gets the current size of active direct memory allocated.
`static long`	`getCurrentDirectMemoryAllocations()` Gets the current number of active direct memory allocations.
`static long`	`getCurrentDirectMemoryMapAllocated()` Gets the current size of active direct memory map allocated.
`static long`	`getCurrentDirectMemoryMapAllocations()` Gets the current number of active direct memory map allocations.
`abstract double`	`getDouble(long offsetBytes)` Gets the double value at the given offset
`abstract void`	`getDoubleArray(long offsetBytes, double[] dstArray, int dstOffsetDoubles, int lengthDoubles)` Gets the double array at the given offset
`abstract float`	`getFloat(long offsetBytes)` Gets the float value at the given offset
`abstract void`	`getFloatArray(long offsetBytes, float[] dstArray, int dstOffsetFloats, int lengthFloats)` Gets the float array at the given offset
`abstract int`	`getInt(long offsetBytes)` Gets the int value at the given offset
`abstract void`	`getIntArray(long offsetBytes, int[] dstArray, int dstOffsetInts, int lengthInts)` Gets the int array at the given offset
`abstract long`	`getLong(long offsetBytes)` Gets the long value at the given offset
`abstract void`	`getLongArray(long offsetBytes, long[] dstArray, int dstOffsetLongs, int lengthLongs)` Gets the long array at the given offset
`long`	`getRegionOffset()` Returns the offset of address zero of this object relative to the address zero of the backing resource but not including the size of any Java object header.
`long`	`getRegionOffset(long offsetBytes)` Returns the offset of address zero of this object relative to the address zero of the backing resource plus the given offsetBytes but not including the size of any Java object header.
`abstract short`	`getShort(long offsetBytes)` Gets the short value at the given offset
`abstract void`	`getShortArray(long offsetBytes, short[] dstArray, int dstOffsetShorts, int lengthShorts)` Gets the short array at the given offset
`boolean`	`hasArray()` Returns true if this object is backed by an on-heap primitive array
`boolean`	`hasByteBuffer()` Returns true if this Memory is backed by a ByteBuffer.
`int`	`hashCode()` Returns the hashCode of this object.
`boolean`	`isDirect()` Returns true if the backing resource is direct (off-heap) memory.
`boolean`	`isNativeOrder()` Returns true if the current byte order is native order.
`boolean`	`isReadOnly()` Returns true if this object or the backing resource is read-only.
`boolean`	`isSameResource(Object that)` Returns true if the backing resource of this is identical with the backing resource of that.
`boolean`	`isValid()` Returns true if this object is valid and has not been closed.
`static MapHandle`	`map(File file)` Maps the entire given file into native-ordered Memory for read operations (including those > 2GB).
`static MapHandle`	`map(File file, long fileOffsetBytes, long capacityBytes, ByteOrder byteOrder)` Maps the specified portion of the given file into Memory for read operations (including those > 2GB).
`abstract Memory`	`region(long offsetBytes, long capacityBytes)` A region is a read-only view of this object.
`abstract Memory`	`region(long offsetBytes, long capacityBytes, ByteOrder byteOrder)` A region is a read-only view of this object.
`String`	`toHexString(String header, long offsetBytes, int lengthBytes)` Returns a formatted hex string of a range of this object.
`abstract ByteBuffer`	`unsafeByteBufferView(long offsetBytes, int capacityBytes)` Returns the specified region of this Memory object as a new read-only `ByteBuffer` object.
`static Memory`	`wrap(boolean[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`static Memory`	`wrap(byte[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`static Memory`	`wrap(byte[] arr, ByteOrder byteOrder)` Wraps the given primitive array for read operations with the given byte order.
`static Memory`	`wrap(byte[] arr, int offsetBytes, int lengthBytes, ByteOrder byteOrder)` Wraps the given primitive array for read operations with the given byte order.
`static Memory`	`wrap(ByteBuffer byteBuf)` Accesses the given ByteBuffer for read-only operations.
`static Memory`	`wrap(ByteBuffer byteBuf, ByteOrder byteOrder)` Accesses the given ByteBuffer for read-only operations.
`static Memory`	`wrap(char[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`static Memory`	`wrap(double[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`static Memory`	`wrap(float[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`static Memory`	`wrap(int[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`static Memory`	`wrap(long[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`static Memory`	`wrap(short[] arr)` Wraps the given primitive array for read operations assuming native byte order.
`abstract void`	`writeTo(long offsetBytes, long lengthBytes, WritableByteChannel out)` Writes bytes from a source range of this Memory to the given `WritableByteChannel`.
`long`	`xxHash64(long offsetBytes, long lengthBytes, long seed)` Returns the 64-bit hash of the sequence of bytes in this object specified by offsetBytes, lengthBytes and a seed.

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

- Method Detail
  - wrap
```
public static Memory wrap(ByteBuffer byteBuf)
```
    Accesses the given ByteBuffer for read-only operations. The returned Memory object has the same byte order, as the given ByteBuffer, unless the capacity of the given ByteBuffer is zero, then byte order of the returned Memory object (as well as backing storage) is unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    byteBuf - the given ByteBuffer, must not be null
    
    Returns:
    
    a new Memory for read-only operations on the given ByteBuffer.
  - wrap
```
public static Memory wrap(ByteBuffer byteBuf,
                          ByteOrder byteOrder)
```
    Accesses the given ByteBuffer for read-only operations. The returned Memory object has the given byte order, ignoring the byte order of the given ByteBuffer. If the capacity of the given ByteBuffer is zero the byte order of the returned Memory object (as well as backing storage) is unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    byteBuf - the given ByteBuffer, must not be null
    
    byteOrder - the byte order to be used, whicn may be independent of the byte order state of the given ByteBuffer.
    
    Returns:
    
    a new Memory for read-only operations on the given ByteBuffer.
  - map
```
public static MapHandle map(File file)
                     throws IOException
```
    Maps the entire given file into native-ordered Memory for read operations (including those > 2GB). Calling this method is equivalent to calling map(file, 0, file.length(), ByteOrder.nativeOrder()).
    Note: Always qualify this method with the class name, e.g., Memory.map(...).
    
    Parameters:
    
    file - the given file to map
    
    Returns:
    
    MapHandle for managing the mapped Memory
    
    Throws:
    
    IOException - if file not found or a RuntimeException.
  - map
```
public static MapHandle map(File file,
                            long fileOffsetBytes,
                            long capacityBytes,
                            ByteOrder byteOrder)
                     throws IOException
```
    Maps the specified portion of the given file into Memory for read operations (including those > 2GB).
    Note: Always qualify this method with the class name, e.g., Memory.map(...).
    
    Parameters:
    
    file - the given file to map. It may not be null.
    
    fileOffsetBytes - the position in the given file in bytes. It may not be negative.
    
    capacityBytes - the size of the mapped Memory. It may not be negative or zero.
    
    byteOrder - the byte order to be used for the mapped Memory. It may not be null.
    
    Returns:
    
    MapHandle for managing the mapped Memory
    
    Throws:
    
    IOException - if file not found or a RuntimeException.
  - region
```
public abstract Memory region(long offsetBytes,
                              long capacityBytes)
```
    A region is a read-only view of this object.
    - Returned object's origin = this object's origin + offsetBytes
    - Returned object's capacity = capacityBytes
    If the given capacityBytes is zero, the returned object is effectively immutable and the backing storage and byte order are unspecified.
    Parameters:
    
    offsetBytes - the starting offset with respect to the origin of this Memory.
    
    capacityBytes - the capacity of the region in bytes
    
    Returns:
    
    a new Memory representing the defined region based on the given offsetBytes and capacityBytes.
  - region
```
public abstract Memory region(long offsetBytes,
                              long capacityBytes,
                              ByteOrder byteOrder)
```
    A region is a read-only view of this object.
    - Returned object's origin = this object's origin + offsetBytes
    - Returned object's capacity = capacityBytes
    - Returned object's byte order = byteOrder
    If the given capacityBytes is zero, the returned object is effectively immutable and the backing storage and byte order are unspecified.
    Parameters:
    
    offsetBytes - the starting offset with respect to the origin of this Memory.
    
    capacityBytes - the capacity of the region in bytes
    
    byteOrder - the given byte order
    
    Returns:
    
    a new Memory representing the defined region based on the given offsetBytes, capacityBytes and byteOrder.
  - asBuffer
```
public abstract Buffer asBuffer()
```
    Returns a new Buffer view of this object.
    - Returned object's origin = this object's origin
    - Returned object's start = 0
    - Returned object's position = 0
    - Returned object's end = this object's capacity
    - Returned object's capacity = this object's capacity
    - Returned object's start, position and end are mutable
    If this object's capacity is zero, the returned object is effectively immutable and the backing storage and byte order are unspecified.
    Returns:
    
    a new Buffer
  - asBuffer
```
public abstract Buffer asBuffer(ByteOrder byteOrder)
```
    Returns a new Buffer view of this object, with the given byte order.
    - Returned object's origin = this object's origin
    - Returned object's start = 0
    - Returned object's position = 0
    - Returned object's end = this object's capacity
    - Returned object's capacity = this object's capacity
    - Returned object's start, position and end are mutable
    If this object's capacity is zero, the returned object is effectively immutable and the backing storage and byte order are unspecified.
    Parameters:
    
    byteOrder - the given byte order
    
    Returns:
    
    a new Buffer with the given byteOrder.
  - unsafeByteBufferView
```
public abstract ByteBuffer unsafeByteBufferView(long offsetBytes,
                                                int capacityBytes)
```
    Returns the specified region of this Memory object as a new read-only ByteBuffer object. The ByteOrder of the returned ByteBuffer corresponds to the byte order of this Memory. The returned ByteBuffer's position is 0 and the limit is equal to the capacity.
    If this Memory object is the result of wrapping non-byte Java arrays (wrap(int[]), wrap(long[]), etc.) this methods throws an UnsupportedOperationException.
    The name of this method starts with "unsafe" because if this is a native managed Memory (e. g. obtained via map(File) or WritableMemory.allocateDirect(long))), and the returned ByteBuffer object is used after the Memory is freed, it may cause a JVM crash. This is also possible for Memory objects themselves with some methods, but Memory's use-after-free is caught as an AssertionError, if assertions are enabled.
    
    Parameters:
    
    offsetBytes - the starting offset with respect to the origin of this Memory
    
    capacityBytes - the capacity of the returned ByteBuffer
    
    Returns:
    
    a new read-only ByteBuffer to access the specified region.
    
    Throws:
    
    UnsupportedOperationException - if this method couldn't be viewed as ByteBuffer, because when it wraps a non-byte Java array.
  - wrap
```
public static Memory wrap(boolean[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(byte[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(byte[] arr,
                          ByteOrder byteOrder)
```
    Wraps the given primitive array for read operations with the given byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    byteOrder - the byte order to be used
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(byte[] arr,
                          int offsetBytes,
                          int lengthBytes,
                          ByteOrder byteOrder)
```
    Wraps the given primitive array for read operations with the given byte order. If the given lengthBytes is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    offsetBytes - the byte offset into the given array
    
    lengthBytes - the number of bytes to include from the given array
    
    byteOrder - the byte order to be used
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(char[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(short[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(int[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(long[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(float[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - wrap
```
public static Memory wrap(double[] arr)
```
    Wraps the given primitive array for read operations assuming native byte order. If the array size is zero, backing storage and byte order of the returned Memory object are unspecified.
    Note: Always qualify this method with the class name, e.g., Memory.wrap(...).
    
    Parameters:
    
    arr - the given primitive array.
    
    Returns:
    
    a new Memory for read operations
  - getBoolean
```
public abstract boolean getBoolean(long offsetBytes)
```
    Gets the boolean value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the boolean at the given offset
  - getBooleanArray
```
public abstract void getBooleanArray(long offsetBytes,
                                     boolean[] dstArray,
                                     int dstOffsetBooleans,
                                     int lengthBooleans)
```
    Gets the boolean array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetBooleans - offset in array units
    
    lengthBooleans - number of array units to transfer
  - getByte
```
public abstract byte getByte(long offsetBytes)
```
    Gets the byte value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the byte at the given offset
  - getByteArray
```
public abstract void getByteArray(long offsetBytes,
                                  byte[] dstArray,
                                  int dstOffsetBytes,
                                  int lengthBytes)
```
    Gets the byte array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetBytes - offset in array units
    
    lengthBytes - number of array units to transfer
  - getChar
```
public abstract char getChar(long offsetBytes)
```
    Gets the char value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the char at the given offset
  - getCharArray
```
public abstract void getCharArray(long offsetBytes,
                                  char[] dstArray,
                                  int dstOffsetChars,
                                  int lengthChars)
```
    Gets the char array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetChars - offset in array units
    
    lengthChars - number of array units to transfer
  - getCharsFromUtf8
```
public abstract int getCharsFromUtf8(long offsetBytes,
                                     int utf8LengthBytes,
                                     Appendable dst)
                              throws IOException,
                                     Utf8CodingException
```
    Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of utf8LengthBytes, decodes them into characters and appends them to the given Appendable. This is specifically designed to reduce the production of intermediate objects (garbage), thus significantly reducing pressure on the JVM Garbage Collector.
    
    Parameters:
    
    offsetBytes - offset bytes relative to the Memory start
    
    utf8LengthBytes - the number of encoded UTF-8 bytes to decode. It is assumed that the caller has the correct number of utf8 bytes required to decode the number of characters to be appended to dst. Characters outside the ASCII range can require 2, 3 or 4 bytes per character to decode.
    
    dst - the destination Appendable to append the decoded characters to.
    
    Returns:
    
    the number of characters decoded
    
    Throws:
    
    IOException - if dst.append() throws IOException
    
    Utf8CodingException - in case of malformed or illegal UTF-8 input
  - getCharsFromUtf8
```
public abstract int getCharsFromUtf8(long offsetBytes,
                                     int utf8LengthBytes,
                                     StringBuilder dst)
                              throws Utf8CodingException
```
    Gets UTF-8 encoded bytes from this Memory, starting at offsetBytes to a length of utf8LengthBytes, decodes them into characters and appends them to the given StringBuilder. This method does *not* reset the length of the destination StringBuilder before appending characters to it. This is specifically designed to reduce the production of intermediate objects (garbage), thus significantly reducing pressure on the JVM Garbage Collector.
    
    Parameters:
    
    offsetBytes - offset bytes relative to the Memory start
    
    utf8LengthBytes - the number of encoded UTF-8 bytes to decode. It is assumed that the caller has the correct number of utf8 bytes required to decode the number of characters to be appended to dst. Characters outside the ASCII range can require 2, 3 or 4 bytes per character to decode.
    
    dst - the destination StringBuilder to append decoded characters to.
    
    Returns:
    
    the number of characters decoded.
    
    Throws:
    
    Utf8CodingException - in case of malformed or illegal UTF-8 input
  - getDouble
```
public abstract double getDouble(long offsetBytes)
```
    Gets the double value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the double at the given offset
  - getDoubleArray
```
public abstract void getDoubleArray(long offsetBytes,
                                    double[] dstArray,
                                    int dstOffsetDoubles,
                                    int lengthDoubles)
```
    Gets the double array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetDoubles - offset in array units
    
    lengthDoubles - number of array units to transfer
  - getFloat
```
public abstract float getFloat(long offsetBytes)
```
    Gets the float value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the float at the given offset
  - getFloatArray
```
public abstract void getFloatArray(long offsetBytes,
                                   float[] dstArray,
                                   int dstOffsetFloats,
                                   int lengthFloats)
```
    Gets the float array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetFloats - offset in array units
    
    lengthFloats - number of array units to transfer
  - getInt
```
public abstract int getInt(long offsetBytes)
```
    Gets the int value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the int at the given offset
  - getIntArray
```
public abstract void getIntArray(long offsetBytes,
                                 int[] dstArray,
                                 int dstOffsetInts,
                                 int lengthInts)
```
    Gets the int array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetInts - offset in array units
    
    lengthInts - number of array units to transfer
  - getLong
```
public abstract long getLong(long offsetBytes)
```
    Gets the long value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the long at the given offset
  - getLongArray
```
public abstract void getLongArray(long offsetBytes,
                                  long[] dstArray,
                                  int dstOffsetLongs,
                                  int lengthLongs)
```
    Gets the long array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetLongs - offset in array units
    
    lengthLongs - number of array units to transfer
  - getShort
```
public abstract short getShort(long offsetBytes)
```
    Gets the short value at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    Returns:
    
    the short at the given offset
  - getShortArray
```
public abstract void getShortArray(long offsetBytes,
                                   short[] dstArray,
                                   int dstOffsetShorts,
                                   int lengthShorts)
```
    Gets the short array at the given offset
    
    Parameters:
    
    offsetBytes - offset bytes relative to this Memory start
    
    dstArray - The preallocated destination array.
    
    dstOffsetShorts - offset in array units
    
    lengthShorts - number of array units to transfer
  - compareTo
```
public abstract int compareTo(long thisOffsetBytes,
                              long thisLengthBytes,
                              Memory that,
                              long thatOffsetBytes,
                              long thatLengthBytes)
```
    Compares the bytes of this Memory to that Memory. Returns (this < that) ? (some negative value) : (this > that) ? (some positive value) : 0;. If all bytes are equal up to the shorter of the two lengths, the shorter length is considered to be less than the other.
    
    Parameters:
    
    thisOffsetBytes - the starting offset for this Memory
    
    thisLengthBytes - the length of the region to compare from this Memory
    
    that - the other Memory to compare with
    
    thatOffsetBytes - the starting offset for that Memory
    
    thatLengthBytes - the length of the region to compare from that Memory
    
    Returns:
    
    (this < that) ? (some negative value) : (this > that) ? (some positive value) : 0;
  - copyTo
```
public abstract void copyTo(long srcOffsetBytes,
                            WritableMemory destination,
                            long dstOffsetBytes,
                            long lengthBytes)
```
    Copies bytes from a source range of this Memory to a destination range of the given Memory with the same semantics when copying between overlapping ranges of bytes as method System.arraycopy(Object, int, Object, int, int) has. However, if the source and the destination ranges are exactly the same, this method throws IllegalArgumentException, because it should never be needed in real-world scenarios and therefore indicates a bug.
    
    Parameters:
    
    srcOffsetBytes - the source offset for this Memory
    
    destination - the destination Memory, which may not be Read-Only.
    
    dstOffsetBytes - the destination offset
    
    lengthBytes - the number of bytes to copy
  - writeTo
```
public abstract void writeTo(long offsetBytes,
                             long lengthBytes,
                             WritableByteChannel out)
                      throws IOException
```
    Writes bytes from a source range of this Memory to the given WritableByteChannel.
    
    Parameters:
    
    offsetBytes - the source offset for this Memory
    
    lengthBytes - the number of bytes to copy
    
    out - the destination WritableByteChannel
    
    Throws:
    
    IOException - may occur while writing to the WritableByteChannel
  - equals
```
public final boolean equals(Object that)
```
    Returns true if the given object is an instance of this class and has equal data contents.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    that - the given object
    
    Returns:
    
    true if the given Object is an instance of this class and has equal data contents.
  - equalTo
```
public final boolean equalTo(long thisOffsetBytes,
                             Object that,
                             long thatOffsetBytes,
                             long lengthBytes)
```
    Returns true if the given object is an instance of this class and has equal contents to this object in the given range of bytes. This will also check two distinct ranges within the same object for eauals.
    
    Parameters:
    
    thisOffsetBytes - the starting offset in bytes for this object.
    
    that - the given object
    
    thatOffsetBytes - the starting offset in bytes for the given object
    
    lengthBytes - the size of the range in bytes
    
    Returns:
    
    true if the given object has equal contents to this object in the given range of bytes.
  - getByteBuffer
```
public ByteBuffer getByteBuffer()
```
    Gets the backing ByteBuffer if it exists, otherwise returns null.
    
    Returns:
    
    the backing ByteBuffer if it exists, otherwise returns null.
  - getByteOrder
```
public final ByteOrder getByteOrder()
```
    Gets the current ByteOrder. This may be different from the ByteOrder of the backing resource.
    
    Returns:
    
    the current ByteOrder.
  - getCapacity
```
public final long getCapacity()
```
    Gets the capacity of this object in bytes
    
    Returns:
    
    the capacity of this object in bytes
  - getCumulativeOffset
```
public final long getCumulativeOffset()
```
    Gets the cumulative offset in bytes of this object from the backing resource. This offset may also include other offset components such as the native off-heap memory address, DirectByteBuffer split offsets, region offsets, and unsafe arrayBaseOffsets.
    
    Returns:
    
    the cumulative offset in bytes of this object from the backing resource.
  - getCumulativeOffset
```
public final long getCumulativeOffset(long offsetBytes)
```
    Gets the cumulative offset in bytes of this object from the backing resource including the given offsetBytes. This offset may also include other offset components such as the native off-heap memory address, DirectByteBuffer split offsets, region offsets, and unsafe arrayBaseOffsets.
    
    Parameters:
    
    offsetBytes - offset to be added to the cumulative offset.
    
    Returns:
    
    the cumulative offset in bytes of this object from the backing resource including the given offsetBytes.
  - getRegionOffset
```
public final long getRegionOffset()
```
    Returns the offset of address zero of this object relative to the address zero of the backing resource but not including the size of any Java object header.
    
    Returns:
    
    the offset of address zero of this object relative to the address zero of the backing resource but not including the size of any Java object header.
  - getRegionOffset
```
public final long getRegionOffset(long offsetBytes)
```
    Returns the offset of address zero of this object relative to the address zero of the backing resource plus the given offsetBytes but not including the size of any Java object header.
    
    Parameters:
    
    offsetBytes - the given offsetBytes
    
    Returns:
    
    the offset of address zero of this object relative to the address zero of the backing resource plus the given offsetBytes but not including the size of any Java object header.
  - hasArray
```
public final boolean hasArray()
```
    Returns true if this object is backed by an on-heap primitive array
    
    Returns:
    
    true if this object is backed by an on-heap primitive array
  - hashCode
```
public final int hashCode()
```
    Returns the hashCode of this object.
    The hash code of this object depends upon all of its contents. Because of this, it is inadvisable to use these objects as keys in hash maps or similar data structures unless it is known that their contents will not change.
    
    If it is desirable to use these objects in a hash map depending only on object identity, than the IdentityHashMap can be used.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the hashCode of this object.
  - xxHash64
```
public final long xxHash64(long offsetBytes,
                           long lengthBytes,
                           long seed)
```
    Returns the 64-bit hash of the sequence of bytes in this object specified by offsetBytes, lengthBytes and a seed. Note that the sequence of bytes is always processed in the same order independent of endianness.
    
    Parameters:
    
    offsetBytes - the given offset in bytes to the first byte of the byte sequence.
    
    lengthBytes - the given length in bytes of the byte sequence.
    
    seed - the given long seed.
    
    Returns:
    
    the 64-bit hash of the sequence of bytes in this object specified by offsetBytes and lengthBytes.
  - hasByteBuffer
```
public final boolean hasByteBuffer()
```
    Returns true if this Memory is backed by a ByteBuffer.
    
    Returns:
    
    true if this Memory is backed by a ByteBuffer.
  - isDirect
```
public final boolean isDirect()
```
    Returns true if the backing resource is direct (off-heap) memory. This is the case for allocated direct memory, memory mapped files,
    
    Returns:
    
    true if the backing resource is direct (off-heap) memory.
  - isNativeOrder
```
public final boolean isNativeOrder()
```
    Returns true if the current byte order is native order.
    
    Returns:
    
    true if the current byte order is native order.
  - isReadOnly
```
public final boolean isReadOnly()
```
    Returns true if this object or the backing resource is read-only.
    
    Returns:
    
    true if this object or the backing resource is read-only.
  - isSameResource
```
public final boolean isSameResource(Object that)
```
    Returns true if the backing resource of this is identical with the backing resource of that. The capacities must be the same. If this is a region, the region offset must also be the same.
    
    Parameters:
    
    that - A different non-null object
    
    Returns:
    
    true if the backing resource of this is the same as the backing resource of that.
  - isValid
```
public boolean isValid()
```
    Returns true if this object is valid and has not been closed. This is relevant only for direct (off-heap) memory and Mapped Files.
    
    Returns:
    
    true if this object is valid and has not been closed.
  - checkValidAndBounds
```
public final void checkValidAndBounds(long offsetBytes,
                                      long lengthBytes)
```
    Checks that the specified range of bytes is within bounds of this object, throws IllegalArgumentException if it's not: i. e. if offsetBytes < 0, or length < 0, or offsetBytes + length > getCapacity().
    
    Parameters:
    
    offsetBytes - the given offset in bytes of this object
    
    lengthBytes - the given length in bytes of this object
  - getCurrentDirectMemoryAllocations
```
public static final long getCurrentDirectMemoryAllocations()
```
    Gets the current number of active direct memory allocations.
    
    Returns:
    
    the current number of active direct memory allocations.
  - getCurrentDirectMemoryAllocated
```
public static final long getCurrentDirectMemoryAllocated()
```
    Gets the current size of active direct memory allocated.
    
    Returns:
    
    the current size of active direct memory allocated.
  - getCurrentDirectMemoryMapAllocations
```
public static final long getCurrentDirectMemoryMapAllocations()
```
    Gets the current number of active direct memory map allocations.
    
    Returns:
    
    the current number of active direct memory map allocations.
  - getCurrentDirectMemoryMapAllocated
```
public static final long getCurrentDirectMemoryMapAllocated()
```
    Gets the current size of active direct memory map allocated.
    
    Returns:
    
    the current size of active direct memory map allocated.
  - toHexString
```
public final String toHexString(String header,
                                long offsetBytes,
                                int lengthBytes)
```
    Returns a formatted hex string of a range of this object. Used primarily for testing.
    
    Parameters:
    
    header - a descriptive header
    
    offsetBytes - offset bytes relative to this object start
    
    lengthBytes - number of bytes to convert to a hex string
    
    Returns:
    
    a formatted hex string in a human readable array

Class Memory

Method Summary

Methods inherited from class java.lang.Object

Method Detail

wrap

wrap

map

map

region

region

asBuffer

asBuffer

unsafeByteBufferView

wrap

wrap

wrap

wrap

wrap

wrap

wrap

wrap

wrap

wrap

getBoolean

getBooleanArray

getByte

getByteArray

getChar

getCharArray

getCharsFromUtf8

getCharsFromUtf8

getDouble

getDoubleArray

getFloat

getFloatArray

getInt

getIntArray

getLong

getLongArray

getShort

getShortArray

compareTo

copyTo

writeTo

equals

equalTo

getByteBuffer

getByteOrder

getCapacity

getCumulativeOffset

getCumulativeOffset

getRegionOffset

getRegionOffset

hasArray

hashCode

xxHash64

hasByteBuffer

isDirect

isNativeOrder

isReadOnly

isSameResource

isValid

checkValidAndBounds

getCurrentDirectMemoryAllocations

getCurrentDirectMemoryAllocated

getCurrentDirectMemoryMapAllocations

getCurrentDirectMemoryMapAllocated

toHexString