one.microstream.memory.XMemory

public final class XMemory
extends Object

Util class for low-level VM memory operations and information that makes the call site independent of a certain JVM implementation (e.g. java.misc.Unsafe).

Method Summary

Modifier and Type	Method	Description
`static long`	`allocate(long bytes)`
`static ByteBuffer`	`allocateDirectNative(int capacity)`	Alias for `ByteBuffer.allocateDirect(capacity).order(ByteOrder.nativeOrder())`.
`static ByteBuffer`	`allocateDirectNative(long capacity)`
`static ByteBuffer`	`allocateDirectNativeDefault()`
`static byte[]`	`asByteArray(long value)`
`static byte[]`	`asByteArray(long[] longArray)`
`static int`	`bitSize_boolean()`
`static int`	`bitSize_byte()`
`static int`	`bitSize_char()`
`static int`	`bitSize_double()`
`static int`	`bitSize_float()`
`static int`	`bitSize_int()`
`static int`	`bitSize_long()`
`static int`	`bitSize_short()`
`static int`	`byteSize_boolean()`
`static int`	`byteSize_byte()`
`static int`	`byteSize_char()`
`static int`	`byteSize_double()`
`static int`	`byteSize_float()`
`static int`	`byteSize_int()`
`static int`	`byteSize_long()`
`static int`	`byteSize_short()`
`static long`	`byteSizeArray_boolean(long elementCount)`
`static long`	`byteSizeArray_byte(long elementCount)`
`static long`	`byteSizeArray_char(long elementCount)`
`static long`	`byteSizeArray_double(long elementCount)`
`static long`	`byteSizeArray_float(long elementCount)`
`static long`	`byteSizeArray_int(long elementCount)`
`static long`	`byteSizeArray_long(long elementCount)`
`static long`	`byteSizeArray_short(long elementCount)`
`static long`	`byteSizeArrayObject(long elementCount)`
`static int`	`byteSizeFieldValue(Class<?> type)`
`static int`	`byteSizeFieldValue(Field field)`
`static int`	`byteSizeInstance(Class<?> c)`
`static int`	`byteSizeObjectHeader(Class<?> c)`
`static int`	`byteSizePrimitive(Class<?> type)`
`static int`	`byteSizeReference()`
`static ByteBuffer`	`capLimit(ByteBuffer buffer, long limit)`
`static ByteBuffer`	`clearForLimit(ByteBuffer buffer, long limit)`
`static void`	`copyArrayToAddress(boolean[] array, long targetAddress)`
`static void`	`copyArrayToAddress(byte[] array, long targetAddress)`
`static void`	`copyArrayToAddress(char[] array, long targetAddress)`
`static void`	`copyArrayToAddress(double[] array, long targetAddress)`
`static void`	`copyArrayToAddress(float[] array, long targetAddress)`
`static void`	`copyArrayToAddress(int[] array, long targetAddress)`
`static void`	`copyArrayToAddress(long[] array, long targetAddress)`
`static void`	`copyArrayToAddress(short[] array, long targetAddress)`
`static void`	`copyRange(long sourceAddress, long targetAddress, long length)`
`static void`	`copyRangeToArray(long sourceAddress, boolean[] target)`
`static void`	`copyRangeToArray(long sourceAddress, byte[] target)`
`static void`	`copyRangeToArray(long sourceAddress, char[] target)`
`static void`	`copyRangeToArray(long sourceAddress, double[] target)`
`static void`	`copyRangeToArray(long sourceAddress, float[] target)`
`static void`	`copyRangeToArray(long sourceAddress, int[] target)`
`static void`	`copyRangeToArray(long sourceAddress, long[] target)`
`static void`	`copyRangeToArray(long sourceAddress, short[] target)`
`static boolean`	`deallocateDirectByteBuffer(ByteBuffer directBuffer)`
`static int`	`defaultBufferSize()`	Arbitrary value that coincidentally matches most hardware's standard page sizes without being hard-tied to an actual pageSize system value.
`static void`	`ensureClassInitialized(Class<?> c)`
`static void`	`ensureClassInitialized(Class<?> c, Iterable<Field> usedFields)`
`static void`	`fillMemory(long address, long length, byte value)`
`static void`	`free(long address)`
`static boolean`	`get_boolean(long address)`
`static boolean`	`get_boolean(Object instance, long offset)`
`static byte`	`get_byte(long address)`
`static byte`	`get_byte(Object instance, long offset)`
`static char`	`get_char(long address)`
`static char`	`get_char(Object instance, long offset)`
`static double`	`get_double(long address)`
`static double`	`get_double(Object instance, long offset)`
`static float`	`get_float(long address)`
`static float`	`get_float(Object instance, long offset)`
`static int`	`get_int(long address)`
`static int`	`get_int(Object instance, long offset)`
`static long`	`get_long(long address)`
`static long`	`get_long(Object instance, long offset)`
`static short`	`get_short(long address)`
`static short`	`get_short(Object instance, long offset)`
`static long`	`getDirectByteBufferAddress(ByteBuffer directBuffer)`
`static Object`	`getObject(Object instance, long offset)`
`static long`	`getPositionLimit(ByteBuffer buffer)`
`static ByteBuffer`	`guaranteeDirectByteBuffer(ByteBuffer directBuffer)`
`static void`	`guaranteeUsability()`
`static <T> T`	`instantiateBlank(Class<T> c)`
`static boolean`	`isBigEndianNativeOrder()`
`static boolean`	`isDirectByteBuffer(ByteBuffer byteBuffer)`
`static boolean`	`isLittleEndianNativeOrder()`
`static MemoryAccessor`	`memoryAccessor()`
`static MemoryAccessor`	`memoryAccessorReversing()`
`static MemorySizeProperties`	`memorySizeProperties()`
`static ByteOrder`	`nativeByteOrder()`
`static long`	`objectFieldOffset(Class<?> c, Field field)`
`static long`	`objectFieldOffset(Field field)`
`static long[]`	`objectFieldOffsets(Class<?> c, Field[] fields)`
`static long[]`	`objectFieldOffsets(Field[] fields)`
`static int`	`pageSize()`
`static ByteOrder`	`parseByteOrder(String name)`	Parses a `String` instance to a `ByteOrder` instance according to `ByteOrder#toString()` or throws an `IllegalArgumentException` if the passed string does not match exactly one of the `ByteOrder` constant instances' string representation.
`static long`	`reallocate(long address, long bytes)`
`static void`	`set_boolean(long address, boolean value)`
`static void`	`set_boolean(Object instance, long offset, boolean value)`
`static void`	`set_booleanInBytes(byte[] bytes, int index, boolean value)`
`static void`	`set_byte(long address, byte value)`
`static void`	`set_byte(Object instance, long offset, byte value)`
`static void`	`set_byteInBytes(byte[] bytes, int index, byte value)`
`static void`	`set_char(long address, char value)`
`static void`	`set_char(Object instance, long offset, char value)`
`static void`	`set_charInBytes(byte[] bytes, int index, char value)`
`static void`	`set_double(long address, double value)`
`static void`	`set_double(Object instance, long offset, double value)`
`static void`	`set_doubleInBytes(byte[] bytes, int index, double value)`
`static void`	`set_float(long address, float value)`
`static void`	`set_float(Object instance, long offset, float value)`
`static void`	`set_floatInBytes(byte[] bytes, int index, float value)`
`static void`	`set_int(long address, int value)`
`static void`	`set_int(Object instance, long offset, int value)`
`static void`	`set_intInBytes(byte[] bytes, int index, int value)`
`static void`	`set_long(long address, long value)`
`static void`	`set_long(Object instance, long offset, long value)`
`static void`	`set_longInBytes(byte[] bytes, int index, long value)`
`static void`	`set_short(long address, short value)`
`static void`	`set_short(Object instance, long offset, short value)`
`static void`	`set_shortInBytes(byte[] bytes, int index, short value)`
`static void`	`setMemoryAccessor(MemoryAccessor memoryAccessor)`
`static <H extends MemoryAccessor & MemorySizeProperties> void`	`setMemoryHandling(H memoryHandler)`
`static void`	`setMemoryHandling(MemoryAccessor memoryAccessor, MemorySizeProperties memorySizeProperties)`
`static void`	`setObject(Object instance, long offset, Object value)`
`static ByteBuffer`	`setPositionLimit(ByteBuffer buffer, int position, int limit)`
`static ByteBuffer`	`setPositionLimit(ByteBuffer buffer, long positionLimit)`
`static ByteBuffer`	`slice(ByteBuffer source, long position, long limit)`
`static byte[]`	`toArray(ByteBuffer source)`
`static byte[]`	`toArray(ByteBuffer[] sources)`
`static byte[]`	`toArray(ByteBuffer source, int position, int length)`
`static ByteBuffer`	`toDirectByteBuffer(byte[] bytes)`

Methods inherited from class java.lang.Object

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

Method Details
- setMemoryHandling
  
  public static final <H extends MemoryAccessor & MemorySizeProperties> void setMemoryHandling(H memoryHandler)
- setMemoryAccessor
  
  public static final void setMemoryAccessor(MemoryAccessor memoryAccessor)
- setMemoryHandling
  
  public static final void setMemoryHandling(MemoryAccessor memoryAccessor, MemorySizeProperties memorySizeProperties)
- memoryAccessor
  
  public static final MemoryAccessor memoryAccessor()
- memoryAccessorReversing
  
  public static final MemoryAccessor memoryAccessorReversing()
- memorySizeProperties
  
  public static final MemorySizeProperties memorySizeProperties()
- guaranteeUsability
  
  public static final void guaranteeUsability()
- getDirectByteBufferAddress
  
  public static final long getDirectByteBufferAddress(ByteBuffer directBuffer)
- deallocateDirectByteBuffer
  
  public static final boolean deallocateDirectByteBuffer(ByteBuffer directBuffer)
- isDirectByteBuffer
  
  public static final boolean isDirectByteBuffer(ByteBuffer byteBuffer)
- guaranteeDirectByteBuffer
  
  public static final ByteBuffer guaranteeDirectByteBuffer(ByteBuffer directBuffer)
- allocate
  
  public static final long allocate(long bytes)
- reallocate
  
  public static final long reallocate(long address, long bytes)
- free
  
  public static final void free(long address)
- fillMemory
  
  public static final void fillMemory(long address, long length, byte value)
- defaultBufferSize
  
  public static final int defaultBufferSize()
  
  Arbitrary value that coincidentally matches most hardware's standard page sizes without being hard-tied to an actual pageSize system value. So this value is an educated guess and almost always a "good" value when paged-sized-ish buffer sizes are needed, while still not being at the mercy of an OS's JVM implementation.
  
  Returns:
  
  a "good" value for a paged-sized-ish default buffer size.
- pageSize
  
  public static final int pageSize()
- byteSizeInstance
  
  public static final int byteSizeInstance(Class<?> c)
- byteSizeObjectHeader
  
  public static final int byteSizeObjectHeader(Class<?> c)
- byteSizeFieldValue
  
  public static final int byteSizeFieldValue(Field field)
- byteSizeFieldValue
  
  public static final int byteSizeFieldValue(Class<?> type)
- byteSizeArray_byte
  
  public static final long byteSizeArray_byte(long elementCount)
- byteSizeArray_boolean
  
  public static final long byteSizeArray_boolean(long elementCount)
- byteSizeArray_short
  
  public static final long byteSizeArray_short(long elementCount)
- byteSizeArray_char
  
  public static final long byteSizeArray_char(long elementCount)
- byteSizeArray_int
  
  public static final long byteSizeArray_int(long elementCount)
- byteSizeArray_float
  
  public static final long byteSizeArray_float(long elementCount)
- byteSizeArray_long
  
  public static final long byteSizeArray_long(long elementCount)
- byteSizeArray_double
  
  public static final long byteSizeArray_double(long elementCount)
- byteSizeArrayObject
  
  public static final long byteSizeArrayObject(long elementCount)
- byteSizePrimitive
  
  public static final int byteSizePrimitive(Class<?> type)
- bitSize_byte
  
  public static final int bitSize_byte()
- byteSize_byte
  
  public static final int byteSize_byte()
- byteSize_boolean
  
  public static final int byteSize_boolean()
- byteSize_short
  
  public static final int byteSize_short()
- byteSize_char
  
  public static final int byteSize_char()
- byteSize_int
  
  public static final int byteSize_int()
- byteSize_float
  
  public static final int byteSize_float()
- byteSize_long
  
  public static final int byteSize_long()
- byteSize_double
  
  public static final int byteSize_double()
- byteSizeReference
  
  public static final int byteSizeReference()
- bitSize_boolean
  
  public static final int bitSize_boolean()
- bitSize_short
  
  public static final int bitSize_short()
- bitSize_char
  
  public static final int bitSize_char()
- bitSize_int
  
  public static final int bitSize_int()
- bitSize_float
  
  public static final int bitSize_float()
- bitSize_long
  
  public static final int bitSize_long()
- bitSize_double
  
  public static final int bitSize_double()
- objectFieldOffset
  
  public static final long objectFieldOffset(Field field)
- objectFieldOffsets
  
  public static final long[] objectFieldOffsets(Field[] fields)
- objectFieldOffset
  
  public static final long objectFieldOffset(Class<?> c, Field field)
- objectFieldOffsets
  
  public static final long[] objectFieldOffsets(Class<?> c, Field[] fields)
- get_byte
  
  public static final byte get_byte(long address)
- get_boolean
  
  public static final boolean get_boolean(long address)
- get_short
  
  public static final short get_short(long address)
- get_char
  
  public static final char get_char(long address)
- get_int
  
  public static final int get_int(long address)
- get_float
  
  public static final float get_float(long address)
- get_long
  
  public static final long get_long(long address)
- get_double
  
  public static final double get_double(long address)
- get_byte
  
  public static final byte get_byte(Object instance, long offset)
- get_boolean
  
  public static final boolean get_boolean(Object instance, long offset)
- get_short
  
  public static final short get_short(Object instance, long offset)
- get_char
  
  public static final char get_char(Object instance, long offset)
- get_int
  
  public static final int get_int(Object instance, long offset)
- get_float
  
  public static final float get_float(Object instance, long offset)
- get_long
  
  public static final long get_long(Object instance, long offset)
- get_double
  
  public static final double get_double(Object instance, long offset)
- getObject
  
  public static final Object getObject(Object instance, long offset)
- set_byte
  
  public static final void set_byte(long address, byte value)
- set_boolean
  
  public static final void set_boolean(long address, boolean value)
- set_short
  
  public static final void set_short(long address, short value)
- set_char
  
  public static final void set_char(long address, char value)
- set_int
  
  public static final void set_int(long address, int value)
- set_float
  
  public static final void set_float(long address, float value)
- set_long
  
  public static final void set_long(long address, long value)
- set_double
  
  public static final void set_double(long address, double value)
- set_byte
  
  public static final void set_byte(Object instance, long offset, byte value)
- set_boolean
  
  public static final void set_boolean(Object instance, long offset, boolean value)
- set_short
  
  public static final void set_short(Object instance, long offset, short value)
- set_char
  
  public static final void set_char(Object instance, long offset, char value)
- set_int
  
  public static final void set_int(Object instance, long offset, int value)
- set_float
  
  public static final void set_float(Object instance, long offset, float value)
- set_long
  
  public static final void set_long(Object instance, long offset, long value)
- set_double
  
  public static final void set_double(Object instance, long offset, double value)
- setObject
  
  public static final void setObject(Object instance, long offset, Object value)
- set_byteInBytes
  
  public static final void set_byteInBytes(byte[] bytes, int index, byte value)
- set_booleanInBytes
  
  public static final void set_booleanInBytes(byte[] bytes, int index, boolean value)
- set_shortInBytes
  
  public static final void set_shortInBytes(byte[] bytes, int index, short value)
- set_charInBytes
  
  public static final void set_charInBytes(byte[] bytes, int index, char value)
- set_intInBytes
  
  public static final void set_intInBytes(byte[] bytes, int index, int value)
- set_floatInBytes
  
  public static final void set_floatInBytes(byte[] bytes, int index, float value)
- set_longInBytes
  
  public static final void set_longInBytes(byte[] bytes, int index, long value)
- set_doubleInBytes
  
  public static final void set_doubleInBytes(byte[] bytes, int index, double value)
- copyRange
  
  public static final void copyRange(long sourceAddress, long targetAddress, long length)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, byte[] target)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, boolean[] target)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, short[] target)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, char[] target)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, int[] target)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, float[] target)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, long[] target)
- copyRangeToArray
  
  public static final void copyRangeToArray(long sourceAddress, double[] target)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(byte[] array, long targetAddress)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(boolean[] array, long targetAddress)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(short[] array, long targetAddress)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(char[] array, long targetAddress)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(int[] array, long targetAddress)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(float[] array, long targetAddress)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(long[] array, long targetAddress)
- copyArrayToAddress
  
  public static final void copyArrayToAddress(double[] array, long targetAddress)
- asByteArray
  
  public static final byte[] asByteArray(long[] longArray)
- asByteArray
  
  public static final byte[] asByteArray(long value)
- ensureClassInitialized
  
  public static final void ensureClassInitialized(Class<?> c)
- ensureClassInitialized
  
  public static final void ensureClassInitialized(Class<?> c, Iterable<Field> usedFields)
- instantiateBlank
  
  public static final <T> T instantiateBlank(Class<T> c) throws InstantiationRuntimeException
  
  Throws:
  
  InstantiationRuntimeException
- nativeByteOrder
  
  public static final ByteOrder nativeByteOrder()
- isBigEndianNativeOrder
  
  public static final boolean isBigEndianNativeOrder()
- isLittleEndianNativeOrder
  
  public static final boolean isLittleEndianNativeOrder()
- parseByteOrder
  
  public static final ByteOrder parseByteOrder(String name)
  
  Parses a String instance to a ByteOrder instance according to ByteOrder#toString() or throws an IllegalArgumentException if the passed string does not match exactly one of the ByteOrder constant instances' string representation.
  
  Parameters:
  
  name - the string representing the ByteOrder instance to be parsed.
  
  Returns:
  
  the recognized ByteOrder
  
  Throws:
  
  IllegalArgumentException - if the string can't be recognized as a ByteOrder constant instance.
  
  See Also:
  
  ByteOrder.toString()
- allocateDirectNative
  
  public static final ByteBuffer allocateDirectNative(int capacity) throws IllegalArgumentException
  
  Alias for ByteBuffer.allocateDirect(capacity).order(ByteOrder.nativeOrder()). See ByteBuffer.allocateDirect(int) for details.
  
  Parameters:
  
  capacity - The new buffer's capacity, in bytes
  
  Returns:
  
  a newly created direct byte buffer with the specified capacity and the platform's native byte order.
  
  Throws:
  
  IllegalArgumentException - If the capacity is a negative integer.
  
  See Also:
  
  ByteBuffer.allocateDirect(int), ByteBuffer.order(ByteOrder)
- allocateDirectNative
  
  public static final ByteBuffer allocateDirectNative(long capacity) throws IllegalArgumentException
  
  Throws:
  
  IllegalArgumentException
- allocateDirectNativeDefault
  
  public static final ByteBuffer allocateDirectNativeDefault()
- toArray
  
  public static final byte[] toArray(ByteBuffer source)
- toArray
  
  public static final byte[] toArray(ByteBuffer source, int position, int length)
- toArray
  
  public static final byte[] toArray(ByteBuffer[] sources)
- toDirectByteBuffer
  
  public static final ByteBuffer toDirectByteBuffer(byte[] bytes)
- getPositionLimit
  
  public static final long getPositionLimit(ByteBuffer buffer)
- setPositionLimit
  
  public static final ByteBuffer setPositionLimit(ByteBuffer buffer, long positionLimit)
- setPositionLimit
  
  public static final ByteBuffer setPositionLimit(ByteBuffer buffer, int position, int limit)
- capLimit
  
  public static final ByteBuffer capLimit(ByteBuffer buffer, long limit)
- clearForLimit
  
  public static final ByteBuffer clearForLimit(ByteBuffer buffer, long limit)
- slice
  
  public static final ByteBuffer slice(ByteBuffer source, long position, long limit)

Class XMemory

Method Summary

Methods inherited from class java.lang.Object

Method Details