java.lang.Object
- org.lwjgl.system.MemoryUtil

```
public final class MemoryUtil
extends java.lang.Object
```
This class provides functionality for managing native memory.
All methods in this class will make use of Unsafe if it's available, for performance. If Unsafe is not available, the fallback implementations make use of reflection and, in the worst-case, JNI.

Method names in this class are prefixed with mem to avoid ambiguities when used with static imports.

Text encoding/decoding
Three codecs are available, each with a different postfix:
- UTF16 - Direct mapping of 2 bytes to Java char and vice versa
- UTF8 - custom UTF-8 codec without intermediate allocations
- ASCII - Not the original 7bit ASCII, but any character set with a single byte encoding (ISO 8859-1, Windows-1252, etc.)
Methods in bindings that accept/return CharSequence/String also support ByteBuffer, so custom codecs can be used if necessary.
See Also:

Configuration.MEMORY_ALLOCATOR, Configuration.DEBUG_MEMORY_ALLOCATOR

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static interface`	`MemoryUtil.MemoryAllocationReport`	The memory allocation report callback.
`static interface`	`MemoryUtil.MemoryAllocator`	The interface implemented by the memory allocator used by the explicit memory management API (`memAlloc(int)`, `memFree(java.nio.Buffer)`, etc).

Field Summary

Fields
Modifier and Type	Field	Description
`static int`	`CACHE_LINE_SIZE`	The cache-line size, in bytes.
`static long`	`NULL`	Alias for the null pointer address.
`static int`	`PAGE_SIZE`	The memory page size, in bytes.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static MemoryUtil.MemoryAllocator`	`getAllocator()`	Returns the `MemoryUtil.MemoryAllocator` instance used internally by the explicit memory management API (`memAlloc(int)`, `memFree(java.nio.Buffer)`, etc).
`static MemoryUtil.MemoryAllocator`	`getAllocator(boolean tracked)`	Returns the `MemoryUtil.MemoryAllocator` instance used internally by the explicit memory management API (`memAlloc(int)`, `memFree(java.nio.Buffer)`, etc).
`static long`	`memAddress(java.nio.Buffer buffer)`	Polymorphic version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(java.nio.ByteBuffer buffer)`	Returns the memory address at the current position of the specified buffer.
`static long`	`memAddress(java.nio.ByteBuffer buffer, int position)`	Returns the memory address at the specified position of the specified buffer.
`static long`	`memAddress(java.nio.CharBuffer buffer)`	CharBuffer version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(java.nio.CharBuffer buffer, int position)`	CharBuffer version of `memAddress(ByteBuffer, int)`.
`static long`	`memAddress(java.nio.DoubleBuffer buffer)`	DoubleBuffer version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(java.nio.DoubleBuffer buffer, int position)`	DoubleBuffer version of `memAddress(ByteBuffer, int)`.
`static long`	`memAddress(java.nio.FloatBuffer buffer)`	FloatBuffer version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(java.nio.FloatBuffer buffer, int position)`	FloatBuffer version of `memAddress(ByteBuffer, int)`.
`static long`	`memAddress(java.nio.IntBuffer buffer)`	IntBuffer version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(java.nio.IntBuffer buffer, int position)`	IntBuffer version of `memAddress(ByteBuffer, int)`.
`static long`	`memAddress(java.nio.LongBuffer buffer)`	LongBuffer version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(java.nio.LongBuffer buffer, int position)`	LongBuffer version of `memAddress(ByteBuffer, int)`.
`static long`	`memAddress(java.nio.ShortBuffer buffer)`	ShortBuffer version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(java.nio.ShortBuffer buffer, int position)`	ShortBuffer version of `memAddress(ByteBuffer, int)`.
`static long`	`memAddress(CustomBuffer<?> buffer)`	CustomBuffer version of `memAddress(ByteBuffer)`.
`static long`	`memAddress(CustomBuffer<?> buffer, int position)`	CustomBuffer version of `memAddress(ByteBuffer, int)`.
`static long`	`memAddress0(java.nio.Buffer buffer)`	Returns the memory address of the specified buffer.
`static long`	`memAddressSafe(java.nio.ByteBuffer buffer)`	Null-safe version of `memAddress(ByteBuffer)`.
`static long`	`memAddressSafe(java.nio.CharBuffer buffer)`	CharBuffer version of `memAddressSafe(ByteBuffer)`.
`static long`	`memAddressSafe(java.nio.DoubleBuffer buffer)`	DoubleBuffer version of `memAddressSafe(ByteBuffer)`.
`static long`	`memAddressSafe(java.nio.FloatBuffer buffer)`	FloatBuffer version of `memAddressSafe(ByteBuffer)`.
`static long`	`memAddressSafe(java.nio.IntBuffer buffer)`	IntBuffer version of `memAddressSafe(ByteBuffer)`.
`static long`	`memAddressSafe(java.nio.LongBuffer buffer)`	LongBuffer version of `memAddressSafe(ByteBuffer)`.
`static long`	`memAddressSafe(java.nio.ShortBuffer buffer)`	ShortBuffer version of `memAddressSafe(ByteBuffer)`.
`static long`	`memAddressSafe(Pointer pointer)`	Pointer version of `memAddressSafe(ByteBuffer)`.
`static java.nio.ByteBuffer`	`memAlignedAlloc(int alignment, int size)`	The standard C aligned_alloc function.
`static void`	`memAlignedFree(java.nio.ByteBuffer ptr)`	Frees a block of memory that was allocated with `memAlignedAlloc(int, int)`.
`static java.nio.ByteBuffer`	`memAlloc(int size)`	The standard C malloc function.
`static java.nio.DoubleBuffer`	`memAllocDouble(int size)`	DoubleBuffer version of `memAlloc(int)`.
`static java.nio.FloatBuffer`	`memAllocFloat(int size)`	FloatBuffer version of `memAlloc(int)`.
`static java.nio.IntBuffer`	`memAllocInt(int size)`	IntBuffer version of `memAlloc(int)`.
`static java.nio.LongBuffer`	`memAllocLong(int size)`	LongBuffer version of `memAlloc(int)`.
`static PointerBuffer`	`memAllocPointer(int size)`	PointerBuffer version of `memAlloc(int)`.
`static java.nio.ShortBuffer`	`memAllocShort(int size)`	ShortBuffer version of `memAlloc(int)`.
`static java.lang.String`	`memASCII(long address)`	Converts the null-terminated ASCII encoded string at the specified memory address to a `String`.
`static java.lang.String`	`memASCII(long address, int length)`	Converts the ASCII encoded string at the specified memory address to a `String`.
`static java.nio.ByteBuffer`	`memASCII(java.lang.CharSequence text)`	Returns a ByteBuffer containing the specified text ASCII encoded and null-terminated.
`static java.nio.ByteBuffer`	`memASCII(java.lang.CharSequence text, boolean nullTerminated)`	Returns a ByteBuffer containing the specified text ASCII encoded and optionally null-terminated.
`static int`	`memASCII(java.lang.CharSequence text, boolean nullTerminated, java.nio.ByteBuffer target)`	Encodes and optionally null-terminates the specified text using ASCII encoding.
`static int`	`memASCII(java.lang.CharSequence text, boolean nullTerminated, java.nio.ByteBuffer target, int offset)`	Encodes and optionally null-terminates the specified text using ASCII encoding.
`static java.lang.String`	`memASCII(java.nio.ByteBuffer buffer)`	Decodes the bytes with index `[position(), position()+remaining()`) in `buffer`, as an ASCII string.
`static java.lang.String`	`memASCII(java.nio.ByteBuffer buffer, int length)`	Decodes the bytes with index `[position(), position()+length`) in `buffer`, as an ASCII string.
`static java.lang.String`	`memASCII(java.nio.ByteBuffer buffer, int length, int offset)`	Decodes the bytes with index `[offset, offset+length`) in `buffer`, as an ASCII string.
`static java.lang.String`	`memASCIISafe(long address)`	Like `memASCII`, but returns `null` if `address` is `NULL`.
`static java.lang.String`	`memASCIISafe(long address, int length)`	Like `memASCII`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memASCIISafe(java.lang.CharSequence text)`	Like `memASCII`, but returns `null` if `text` is `null`.
`static java.nio.ByteBuffer`	`memASCIISafe(java.lang.CharSequence text, boolean nullTerminated)`	Like `memASCII`, but returns `null` if `text` is `null`.
`static java.lang.String`	`memASCIISafe(java.nio.ByteBuffer buffer)`	Like `memASCII`, but returns `null` if `buffer` is `null`.
`static java.nio.ByteBuffer`	`memByteBuffer(long address, int capacity)`	Creates a new direct ByteBuffer that starts at the specified memory address and has the specified capacity.
`static java.nio.ByteBuffer`	`memByteBufferNT1(long address)`	Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address.
`static java.nio.ByteBuffer`	`memByteBufferNT1(long address, int maxLength)`	Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address, up to a maximum of `maxLength` bytes.
`static java.nio.ByteBuffer`	`memByteBufferNT1Safe(long address)`	Like `memByteBufferNT1`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memByteBufferNT1Safe(long address, int maxLength)`	Like `memByteBufferNT1`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memByteBufferNT2(long address)`	Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address.
`static java.nio.ByteBuffer`	`memByteBufferNT2(long address, int maxLength)`	Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address, up to a maximum of `maxLength` bytes.
`static java.nio.ByteBuffer`	`memByteBufferNT2Safe(long address)`	Like `memByteBufferNT2`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memByteBufferNT2Safe(long address, int maxLength)`	Like `memByteBufferNT2`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memByteBufferSafe(long address, int capacity)`	Like `memByteBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memCalloc(int num)`	Alternative version of `memCalloc(int, int)`.
`static java.nio.ByteBuffer`	`memCalloc(int num, int size)`	The standard C calloc function.
`static java.nio.DoubleBuffer`	`memCallocDouble(int num)`	DoubleBuffer version of `memCalloc(int, int)`.
`static java.nio.FloatBuffer`	`memCallocFloat(int num)`	FloatBuffer version of `memCalloc(int, int)`.
`static java.nio.IntBuffer`	`memCallocInt(int num)`	IntBuffer version of `memCalloc(int, int)`.
`static java.nio.LongBuffer`	`memCallocLong(int num)`	LongBuffer version of `memCalloc(int, int)`.
`static PointerBuffer`	`memCallocPointer(int num)`	PointerBuffer version of `memCalloc(int, int)`.
`static java.nio.ShortBuffer`	`memCallocShort(int num)`	ShortBuffer version of `memCalloc(int, int)`.
`static java.nio.CharBuffer`	`memCharBuffer(long address, int capacity)`	Creates a new direct CharBuffer that starts at the specified memory address and has the specified capacity.
`static java.nio.CharBuffer`	`memCharBufferSafe(long address, int capacity)`	Like `memCharBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static void`	`memCopy(long src, long dst, long bytes)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memCopy(java.nio.ByteBuffer src, java.nio.ByteBuffer dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memCopy(java.nio.CharBuffer src, java.nio.CharBuffer dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memCopy(java.nio.DoubleBuffer src, java.nio.DoubleBuffer dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memCopy(java.nio.FloatBuffer src, java.nio.FloatBuffer dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memCopy(java.nio.IntBuffer src, java.nio.IntBuffer dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memCopy(java.nio.LongBuffer src, java.nio.LongBuffer dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memCopy(java.nio.ShortBuffer src, java.nio.ShortBuffer dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static <T extends CustomBuffer<T>> void`	`memCopy(T src, T dst)`	Sets all bytes in a specified block of memory to a copy of another block.
`static void`	`memDeleteGlobalRef(long globalRef)`	Deprecated.
`static void`	`memDeleteWeakGlobalRef(long globalRef)`	Deprecated.
`static java.nio.DoubleBuffer`	`memDoubleBuffer(long address, int capacity)`	Creates a new direct DoubleBuffer that starts at the specified memory address and has the specified capacity.
`static java.nio.DoubleBuffer`	`memDoubleBufferSafe(long address, int capacity)`	Like `memDoubleBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memDuplicate(java.nio.ByteBuffer buffer)`	Duplicates the specified buffer.
`static java.nio.CharBuffer`	`memDuplicate(java.nio.CharBuffer buffer)`	Duplicates the specified buffer.
`static java.nio.DoubleBuffer`	`memDuplicate(java.nio.DoubleBuffer buffer)`	Duplicates the specified buffer.
`static java.nio.FloatBuffer`	`memDuplicate(java.nio.FloatBuffer buffer)`	Duplicates the specified buffer.
`static java.nio.IntBuffer`	`memDuplicate(java.nio.IntBuffer buffer)`	Duplicates the specified buffer.
`static java.nio.LongBuffer`	`memDuplicate(java.nio.LongBuffer buffer)`	Duplicates the specified buffer.
`static java.nio.ShortBuffer`	`memDuplicate(java.nio.ShortBuffer buffer)`	Duplicates the specified buffer.
`static java.nio.FloatBuffer`	`memFloatBuffer(long address, int capacity)`	Creates a new direct FloatBuffer that starts at the specified memory address and has the specified capacity.
`static java.nio.FloatBuffer`	`memFloatBufferSafe(long address, int capacity)`	Like `memFloatBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static void`	`memFree(java.nio.Buffer ptr)`	The standard C free function.
`static void`	`memFree(PointerBuffer ptr)`	PointerBuffer version of `memFree(java.nio.Buffer)`.
`static long`	`memGetAddress(long ptr)`
`static boolean`	`memGetBoolean(long ptr)`
`static byte`	`memGetByte(long ptr)`
`static long`	`memGetCLong(long ptr)`
`static double`	`memGetDouble(long ptr)`
`static float`	`memGetFloat(long ptr)`
`static int`	`memGetInt(long ptr)`
`static long`	`memGetLong(long ptr)`
`static short`	`memGetShort(long ptr)`
`static <T> T`	`memGlobalRefToObject(long globalRef)`	Returns the object that the specified global reference points to.
`static java.nio.IntBuffer`	`memIntBuffer(long address, int capacity)`	Creates a new direct IntBuffer that starts at the specified memory address and has the specified capacity.
`static java.nio.IntBuffer`	`memIntBufferSafe(long address, int capacity)`	Like `memIntBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static int`	`memLengthASCII(java.lang.CharSequence value, boolean nullTerminated)`	Returns the number of bytes required to encode the specified text in the ASCII encoding.
`static int`	`memLengthNT1(java.nio.ByteBuffer buffer)`	Calculates the length, in bytes, of the null-terminated string that starts at the current position of the specified buffer.
`static int`	`memLengthNT2(java.nio.ByteBuffer buffer)`	Calculates the length, in bytes, of the null-terminated string that starts at the current position of the specified buffer.
`static int`	`memLengthUTF16(java.lang.CharSequence value, boolean nullTerminated)`	Returns the number of bytes required to encode the specified text in the UTF-16 encoding.
`static int`	`memLengthUTF8(java.lang.CharSequence value, boolean nullTerminated)`	Returns the number of bytes required to encode the specified text in the UTF-8 encoding.
`static java.nio.LongBuffer`	`memLongBuffer(long address, int capacity)`	Creates a new direct LongBuffer that starts at the specified memory address and has the specified capacity.
`static java.nio.LongBuffer`	`memLongBufferSafe(long address, int capacity)`	Like `memLongBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static long`	`memNewGlobalRef(java.lang.Object obj)`	Deprecated.
`static long`	`memNewWeakGlobalRef(java.lang.Object obj)`	Deprecated.
`static PointerBuffer`	`memPointerBuffer(long address, int capacity)`	Creates a new PointerBuffer that starts at the specified memory address and has the specified capacity.
`static PointerBuffer`	`memPointerBufferSafe(long address, int capacity)`	Like `memPointerBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static void`	`memPutAddress(long ptr, long value)`
`static void`	`memPutByte(long ptr, byte value)`
`static void`	`memPutCLong(long ptr, long value)`
`static void`	`memPutDouble(long ptr, double value)`
`static void`	`memPutFloat(long ptr, float value)`
`static void`	`memPutInt(long ptr, int value)`
`static void`	`memPutLong(long ptr, long value)`
`static void`	`memPutShort(long ptr, short value)`
`static java.nio.ByteBuffer`	`memRealloc(java.nio.ByteBuffer ptr, int size)`	The standard C realloc function.
`static java.nio.DoubleBuffer`	`memRealloc(java.nio.DoubleBuffer ptr, int size)`	DoubleBuffer version of `memRealloc(java.nio.ByteBuffer, int)`.
`static java.nio.FloatBuffer`	`memRealloc(java.nio.FloatBuffer ptr, int size)`	FloatBuffer version of `memRealloc(java.nio.ByteBuffer, int)`.
`static java.nio.IntBuffer`	`memRealloc(java.nio.IntBuffer ptr, int size)`	IntBuffer version of `memRealloc(java.nio.ByteBuffer, int)`.
`static java.nio.LongBuffer`	`memRealloc(java.nio.LongBuffer ptr, int size)`	LongBuffer version of `memRealloc(java.nio.ByteBuffer, int)`.
`static java.nio.ShortBuffer`	`memRealloc(java.nio.ShortBuffer ptr, int size)`	ShortBuffer version of `memRealloc(java.nio.ByteBuffer, int)`.
`static PointerBuffer`	`memRealloc(PointerBuffer ptr, int size)`	PointerBuffer version of `memRealloc(java.nio.ByteBuffer, int)`.
`static void`	`memReport(MemoryUtil.MemoryAllocationReport report)`	Reports all live allocations.
`static void`	`memReport(MemoryUtil.MemoryAllocationReport report, MemoryUtil.MemoryAllocationReport.Aggregate groupByStackTrace, boolean groupByThread)`	Reports aggregates for the live allocations.
`static void`	`memSet(long ptr, int value, long bytes)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static void`	`memSet(java.nio.ByteBuffer ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static void`	`memSet(java.nio.CharBuffer ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static void`	`memSet(java.nio.DoubleBuffer ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static void`	`memSet(java.nio.FloatBuffer ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static void`	`memSet(java.nio.IntBuffer ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static void`	`memSet(java.nio.LongBuffer ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static void`	`memSet(java.nio.ShortBuffer ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static <T extends CustomBuffer<T>> void`	`memSet(T ptr, int value)`	Sets all bytes in a specified block of memory to a fixed value (usually zero).
`static java.nio.ShortBuffer`	`memShortBuffer(long address, int capacity)`	Creates a new direct ShortBuffer that starts at the specified memory address and has the specified capacity.
`static java.nio.ShortBuffer`	`memShortBufferSafe(long address, int capacity)`	Like `memShortBuffer(long, int)`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memSlice(java.nio.ByteBuffer buffer)`	Slices the specified buffer.
`static java.nio.ByteBuffer`	`memSlice(java.nio.ByteBuffer buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static java.nio.CharBuffer`	`memSlice(java.nio.CharBuffer buffer)`	Slices the specified buffer.
`static java.nio.CharBuffer`	`memSlice(java.nio.CharBuffer buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static java.nio.DoubleBuffer`	`memSlice(java.nio.DoubleBuffer buffer)`	Slices the specified buffer.
`static java.nio.DoubleBuffer`	`memSlice(java.nio.DoubleBuffer buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static java.nio.FloatBuffer`	`memSlice(java.nio.FloatBuffer buffer)`	Slices the specified buffer.
`static java.nio.FloatBuffer`	`memSlice(java.nio.FloatBuffer buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static java.nio.IntBuffer`	`memSlice(java.nio.IntBuffer buffer)`	Slices the specified buffer.
`static java.nio.IntBuffer`	`memSlice(java.nio.IntBuffer buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static java.nio.LongBuffer`	`memSlice(java.nio.LongBuffer buffer)`	Slices the specified buffer.
`static java.nio.LongBuffer`	`memSlice(java.nio.LongBuffer buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static java.nio.ShortBuffer`	`memSlice(java.nio.ShortBuffer buffer)`	Slices the specified buffer.
`static java.nio.ShortBuffer`	`memSlice(java.nio.ShortBuffer buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static <T extends CustomBuffer<T>> T`	`memSlice(T buffer, int offset, int capacity)`	Returns a slice of the specified buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`static java.lang.String`	`memUTF16(long address)`	Converts the null-terminated UTF-16 encoded string at the specified memory address to a `String`.
`static java.lang.String`	`memUTF16(long address, int length)`	Converts the UTF-16 encoded string at the specified memory address to a `String`.
`static java.nio.ByteBuffer`	`memUTF16(java.lang.CharSequence text)`	Returns a ByteBuffer containing the specified text UTF-16 encoded and null-terminated.
`static java.nio.ByteBuffer`	`memUTF16(java.lang.CharSequence text, boolean nullTerminated)`	Returns a ByteBuffer containing the specified text UTF-16 encoded and optionally null-terminated.
`static int`	`memUTF16(java.lang.CharSequence text, boolean nullTerminated, java.nio.ByteBuffer target)`	Encodes and optionally null-terminates the specified text using UTF-16 encoding.
`static int`	`memUTF16(java.lang.CharSequence text, boolean nullTerminated, java.nio.ByteBuffer target, int offset)`	Encodes and optionally null-terminates the specified text using UTF-16 encoding.
`static java.lang.String`	`memUTF16(java.nio.ByteBuffer buffer)`	Decodes the bytes with index `[position(), position()+remaining()`) in `buffer`, as a UTF-16 string.
`static java.lang.String`	`memUTF16(java.nio.ByteBuffer buffer, int length)`	Decodes the bytes with index `[position(), position()+(length*2)`) in `buffer`, as a UTF-16 string.
`static java.lang.String`	`memUTF16(java.nio.ByteBuffer buffer, int length, int offset)`	Decodes the bytes with index `[offset, offset+(length*2)`) in `buffer`, as a UTF-16 string.
`static java.lang.String`	`memUTF16Safe(long address)`	Like `memUTF16`, but returns `null` if `address` is `NULL`.
`static java.lang.String`	`memUTF16Safe(long address, int length)`	Like `memUTF16`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memUTF16Safe(java.lang.CharSequence text)`	Like `memASCII`, but returns `null` if `text` is `null`.
`static java.nio.ByteBuffer`	`memUTF16Safe(java.lang.CharSequence text, boolean nullTerminated)`	Like `memASCII`, but returns `null` if `text` is `null`.
`static java.lang.String`	`memUTF16Safe(java.nio.ByteBuffer buffer)`	Like `memUTF16`, but returns `null` if `buffer` is `null`.
`static java.lang.String`	`memUTF8(long address)`	Converts the null-terminated UTF-8 encoded string at the specified memory address to a `String`.
`static java.lang.String`	`memUTF8(long address, int length)`	Converts the UTF-8 encoded string at the specified memory address to a `String`.
`static java.nio.ByteBuffer`	`memUTF8(java.lang.CharSequence text)`	Returns a ByteBuffer containing the specified text UTF-8 encoded and null-terminated.
`static java.nio.ByteBuffer`	`memUTF8(java.lang.CharSequence text, boolean nullTerminated)`	Returns a ByteBuffer containing the specified text UTF-8 encoded and optionally null-terminated.
`static int`	`memUTF8(java.lang.CharSequence text, boolean nullTerminated, java.nio.ByteBuffer target)`	Encodes and optionally null-terminates the specified text using UTF-8 encoding.
`static int`	`memUTF8(java.lang.CharSequence text, boolean nullTerminated, java.nio.ByteBuffer target, int offset)`	Encodes and optionally null-terminates the specified text using UTF-8 encoding.
`static java.lang.String`	`memUTF8(java.nio.ByteBuffer buffer)`	Decodes the bytes with index `[position(), position()+remaining()`) in `buffer`, as a UTF-8 string.
`static java.lang.String`	`memUTF8(java.nio.ByteBuffer buffer, int length)`	Decodes the bytes with index `[position(), position()+length`) in `buffer`, as a UTF-8 string.
`static java.lang.String`	`memUTF8(java.nio.ByteBuffer buffer, int length, int offset)`	Decodes the bytes with index `[offset, offset+length`) in `buffer`, as a UTF-8 string.
`static java.lang.String`	`memUTF8Safe(long address)`	Like `memUTF8`, but returns `null` if `address` is `NULL`.
`static java.lang.String`	`memUTF8Safe(long address, int length)`	Like `memUTF8`, but returns `null` if `address` is `NULL`.
`static java.nio.ByteBuffer`	`memUTF8Safe(java.lang.CharSequence text)`	Like `memASCII`, but returns `null` if `text` is `null`.
`static java.nio.ByteBuffer`	`memUTF8Safe(java.lang.CharSequence text, boolean nullTerminated)`	Like `memASCII`, but returns `null` if `text` is `null`.
`static java.lang.String`	`memUTF8Safe(java.nio.ByteBuffer buffer)`	Like `memUTF8`, but returns `null` if `buffer` is `null`.
`static long`	`nmemAlignedAlloc(long alignment, long size)`	Unsafe version of `memAlignedAlloc(int, int)`.
`static long`	`nmemAlignedAllocChecked(long alignment, long size)`	Unsafe version of `memAlignedAlloc(int, int)` that checks the returned pointer.
`static void`	`nmemAlignedFree(long ptr)`	Unsafe version of `memAlignedFree(java.nio.ByteBuffer)`.
`static long`	`nmemAlloc(long size)`	Unsafe version of `memAlloc(int)`.
`static long`	`nmemAllocChecked(long size)`	Unsafe version of `memAlloc(int)` that checks the returned pointer.
`static long`	`nmemCalloc(long num, long size)`	Unsafe version of `memCalloc(int, int)`.
`static long`	`nmemCallocChecked(long num, long size)`	Unsafe version of `memCalloc(int, int)` that checks the returned pointer.
`static void`	`nmemFree(long ptr)`	Unsafe version of `memFree(java.nio.Buffer)`.
`static long`	`nmemRealloc(long ptr, long size)`	Unsafe version of `memRealloc(java.nio.ByteBuffer, int)`.
`static long`	`nmemReallocChecked(long ptr, long size)`	Unsafe version of `memRealloc(java.nio.ByteBuffer, int)` that checks the returned pointer.

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

- Field Detail
  - NULL
    
    Alias for the null pointer address.
  - PAGE_SIZE
    
    The memory page size, in bytes. This value is always a power-of-two.
  - CACHE_LINE_SIZE
    
    The cache-line size, in bytes. This value is always a power-of-two.
- Method Detail
  - getAllocator
```
public static MemoryUtil.MemoryAllocator getAllocator()
```
    Returns the MemoryUtil.MemoryAllocator instance used internally by the explicit memory management API (memAlloc(int), memFree(java.nio.Buffer), etc).
    Allocations made through the returned instance will not be tracked for memory leaks, even if Configuration.DEBUG_MEMORY_ALLOCATOR is enabled. This can be useful for static final allocations that live throughout the application's lifetime and will never be freed until the process is terminated. Normally such allocations would be reported as memory leaks by the debug allocator.
    
    The expectation is that this method will rarely be used, so it does not have the mem prefix to avoid pollution of auto-complete lists.
    
    Returns:
    
    the MemoryUtil.MemoryAllocator instance
  - getAllocator
```
public static MemoryUtil.MemoryAllocator getAllocator(boolean tracked)
```
    Returns the MemoryUtil.MemoryAllocator instance used internally by the explicit memory management API (memAlloc(int), memFree(java.nio.Buffer), etc).
    
    Parameters:
    
    tracked - whether allocations will be tracked for memory leaks, if Configuration.DEBUG_MEMORY_ALLOCATOR is enabled.
    
    Returns:
    
    the MemoryUtil.MemoryAllocator instance
  - nmemAlloc
```
public static long nmemAlloc(long size)
```
    Unsafe version of memAlloc(int). May return NULL if size is zero or the allocation failed.
  - nmemAllocChecked
```
public static long nmemAllocChecked(long size)
```
    Unsafe version of memAlloc(int) that checks the returned pointer.
    
    Returns:
    
    a pointer to the memory block allocated by the function on success. This pointer will never be NULL, even if size is zero.
    
    Throws:
    
    java.lang.OutOfMemoryError - if the function failed to allocate the requested block of memory
  - memAlloc
```
public static java.nio.ByteBuffer memAlloc(int size)
```
    The standard C malloc function.
    Allocates a block of size bytes of memory, returning a pointer to the beginning of the block. The content of the newly allocated block of memory is not initialized, remaining with indeterminate values.
    
    Memory allocated with this method must be freed with memFree(java.nio.Buffer).
    
    Parameters:
    
    size - the size of the memory block to allocate, in bytes. If size is zero, the returned pointer shall not be dereferenced.
    
    Returns:
    
    on success, a pointer to the memory block allocated by the function
    
    Throws:
    
    java.lang.OutOfMemoryError - if the function failed to allocate the requested block of memory
  - memAllocShort
```
public static java.nio.ShortBuffer memAllocShort(int size)
```
    ShortBuffer version of memAlloc(int).
    
    Parameters:
    
    size - the number of short values to allocate.
  - memAllocInt
```
public static java.nio.IntBuffer memAllocInt(int size)
```
    IntBuffer version of memAlloc(int).
    
    Parameters:
    
    size - the number of int values to allocate.
  - memAllocFloat
```
public static java.nio.FloatBuffer memAllocFloat(int size)
```
    FloatBuffer version of memAlloc(int).
    
    Parameters:
    
    size - the number of float values to allocate.
  - memAllocLong
```
public static java.nio.LongBuffer memAllocLong(int size)
```
    LongBuffer version of memAlloc(int).
    
    Parameters:
    
    size - the number of long values to allocate.
  - memAllocDouble
```
public static java.nio.DoubleBuffer memAllocDouble(int size)
```
    DoubleBuffer version of memAlloc(int).
    
    Parameters:
    
    size - the number of double values to allocate.
  - memAllocPointer
```
public static PointerBuffer memAllocPointer(int size)
```
    PointerBuffer version of memAlloc(int).
    
    Parameters:
    
    size - the number of pointer values to allocate.
  - nmemFree
```
public static void nmemFree(long ptr)
```
    Unsafe version of memFree(java.nio.Buffer).
  - memFree
```
public static void memFree(@Nullable
                           java.nio.Buffer ptr)
```
    The standard C free function.
    A block of memory previously allocated by a call to memAlloc(int), memCalloc(int, int) or memRealloc(java.nio.ByteBuffer, int) is deallocated, making it available again for further allocations.
    
    Parameters:
    
    ptr - pointer to a memory block previously allocated with memAlloc(int), memCalloc(int, int) or memRealloc(java.nio.ByteBuffer, int). If ptr does not point to a block of memory allocated with the above functions, it causes undefined behavior. If ptr is a NULL pointer, the function does nothing.
  - memFree
```
public static void memFree(@Nullable
                           PointerBuffer ptr)
```
    PointerBuffer version of memFree(java.nio.Buffer).
  - nmemCalloc
```
public static long nmemCalloc(long num,
                              long size)
```
    Unsafe version of memCalloc(int, int). May return NULL if num or size are zero or the allocation failed.
  - nmemCallocChecked
```
public static long nmemCallocChecked(long num,
                                     long size)
```
    Unsafe version of memCalloc(int, int) that checks the returned pointer.
    
    Returns:
    
    a pointer to the memory block allocated by the function on success. This pointer will never be NULL, even if num or size are zero.
    
    Throws:
    
    java.lang.OutOfMemoryError - if the function failed to allocate the requested block of memory
  - memCalloc
```
public static java.nio.ByteBuffer memCalloc(int num,
                                            int size)
```
    The standard C calloc function.
    Allocates a block of memory for an array of num elements, each of them size bytes long, and initializes all its bits to zero. The effective result is the allocation of a zero-initialized memory block of (num*size) bytes.
    
    Memory allocated with this method must be freed with memFree(java.nio.Buffer).
    
    Parameters:
    
    num - the number of elements to allocate.
    
    size - the size of each element. If size is zero, the return value depends on the particular library implementation (it may or may not be a null pointer), but the returned pointer shall not be dereferenced.
    
    Returns:
    
    on success, a pointer to the memory block allocated by the function
    
    Throws:
    
    java.lang.OutOfMemoryError - if the function failed to allocate the requested block of memory
  - memCalloc
```
public static java.nio.ByteBuffer memCalloc(int num)
```
    Alternative version of memCalloc(int, int).
    
    Parameters:
    
    num - the number of bytes to allocate.
  - memCallocShort
```
public static java.nio.ShortBuffer memCallocShort(int num)
```
    ShortBuffer version of memCalloc(int, int).
    
    Parameters:
    
    num - the number of short values to allocate.
  - memCallocInt
```
public static java.nio.IntBuffer memCallocInt(int num)
```
    IntBuffer version of memCalloc(int, int).
    
    Parameters:
    
    num - the number of int values to allocate.
  - memCallocFloat
```
public static java.nio.FloatBuffer memCallocFloat(int num)
```
    FloatBuffer version of memCalloc(int, int).
    
    Parameters:
    
    num - the number of float values to allocate.
  - memCallocLong
```
public static java.nio.LongBuffer memCallocLong(int num)
```
    LongBuffer version of memCalloc(int, int).
    
    Parameters:
    
    num - the number of long values to allocate.
  - memCallocDouble
```
public static java.nio.DoubleBuffer memCallocDouble(int num)
```
    DoubleBuffer version of memCalloc(int, int).
    
    Parameters:
    
    num - the number of double values to allocate.
  - memCallocPointer
```
public static PointerBuffer memCallocPointer(int num)
```
    PointerBuffer version of memCalloc(int, int).
    
    Parameters:
    
    num - the number of pointer values to allocate.
  - nmemRealloc
```
public static long nmemRealloc(long ptr,
                               long size)
```
    Unsafe version of memRealloc(java.nio.ByteBuffer, int). May return NULL if size is zero or the allocation failed.
  - nmemReallocChecked
```
public static long nmemReallocChecked(long ptr,
                                      long size)
```
    Unsafe version of memRealloc(java.nio.ByteBuffer, int) that checks the returned pointer.
    
    Returns:
    
    a pointer to the memory block reallocated by the function on success. This pointer will never be NULL, even if size is zero.
    
    Throws:
    
    java.lang.OutOfMemoryError - if the function failed to allocate the requested block of memory
  - memRealloc
```
public static java.nio.ByteBuffer memRealloc(@Nullable
                                             java.nio.ByteBuffer ptr,
                                             int size)
```
    The standard C realloc function.
    Changes the size of the memory block pointed to by ptr. The function may move the memory block to a new location (whose address is returned by the function). The content of the memory block is preserved up to the lesser of the new and old sizes, even if the block is moved to a new location. If the new size is larger, the value of the newly allocated portion is indeterminate.
    
    The memory address used is always the address at the start of ptr, so the current position of ptr does not need to be set to 0 for this function to work. The current position is preserved, even if the memory block is moved to a new location, unless size is less than the current position in which case position will be equal to capacity. The limit is set to the capacity, and the mark is discarded.
    
    Parameters:
    
    ptr - a pointer to a memory block previously allocated with memAlloc(int), memCalloc(int, int) or memRealloc(java.nio.ByteBuffer, int). Alternatively, this can be a NULL pointer, in which case a new block is allocated (as if memAlloc(int) was called).
    
    size - the new size for the memory block, in bytes.
    
    Returns:
    
    a pointer to the reallocated memory block, which may be either the same as ptr or a new location
    
    Throws:
    
    java.lang.OutOfMemoryError - if the function failed to allocate the requested block of memory. The memory block pointed to by argument ptr is not deallocated (it is still valid, and with its contents unchanged).
  - memRealloc
```
public static java.nio.ShortBuffer memRealloc(@Nullable
                                              java.nio.ShortBuffer ptr,
                                              int size)
```
    ShortBuffer version of memRealloc(java.nio.ByteBuffer, int).
    
    Parameters:
    
    size - the number of short values to allocate.
  - memRealloc
```
public static java.nio.IntBuffer memRealloc(@Nullable
                                            java.nio.IntBuffer ptr,
                                            int size)
```
    IntBuffer version of memRealloc(java.nio.ByteBuffer, int).
    
    Parameters:
    
    size - the number of int values to allocate.
  - memRealloc
```
public static java.nio.LongBuffer memRealloc(@Nullable
                                             java.nio.LongBuffer ptr,
                                             int size)
```
    LongBuffer version of memRealloc(java.nio.ByteBuffer, int).
    
    Parameters:
    
    size - the number of long values to allocate.
  - memRealloc
```
public static java.nio.FloatBuffer memRealloc(@Nullable
                                              java.nio.FloatBuffer ptr,
                                              int size)
```
    FloatBuffer version of memRealloc(java.nio.ByteBuffer, int).
    
    Parameters:
    
    size - the number of float values to allocate.
  - memRealloc
```
public static java.nio.DoubleBuffer memRealloc(@Nullable
                                               java.nio.DoubleBuffer ptr,
                                               int size)
```
    DoubleBuffer version of memRealloc(java.nio.ByteBuffer, int).
    
    Parameters:
    
    size - the number of double values to allocate.
  - memRealloc
```
public static PointerBuffer memRealloc(@Nullable
                                       PointerBuffer ptr,
                                       int size)
```
    PointerBuffer version of memRealloc(java.nio.ByteBuffer, int).
    
    Parameters:
    
    size - the number of pointer values to allocate.
  - nmemAlignedAlloc
```
public static long nmemAlignedAlloc(long alignment,
                                    long size)
```
    Unsafe version of memAlignedAlloc(int, int). May return NULL if size is zero or the allocation failed.
  - nmemAlignedAllocChecked
```
public static long nmemAlignedAllocChecked(long alignment,
                                           long size)
```
    Unsafe version of memAlignedAlloc(int, int) that checks the returned pointer.
    
    Returns:
    
    a pointer to the memory block allocated by the function on success. This pointer will never be NULL, even if size is zero.
    
    Throws:
    
    java.lang.OutOfMemoryError - if the function failed to allocate the requested block of memory
  - memAlignedAlloc
```
public static java.nio.ByteBuffer memAlignedAlloc(int alignment,
                                                  int size)
```
    The standard C aligned_alloc function.
    Allocate size bytes of uninitialized storage whose alignment is specified by alignment. The size parameter must be an integral multiple of alignment. Memory allocated with memAlignedAlloc() must be freed with memAlignedFree(java.nio.ByteBuffer).
    
    Parameters:
    
    alignment - the alignment. Must be a power of two value and a multiple of sizeof(void *).
    
    size - the number of bytes to allocate. Must be a multiple of alignment.
  - nmemAlignedFree
```
public static void nmemAlignedFree(long ptr)
```
    Unsafe version of memAlignedFree(java.nio.ByteBuffer).
  - memAlignedFree
```
public static void memAlignedFree(@Nullable
                                  java.nio.ByteBuffer ptr)
```
    Frees a block of memory that was allocated with memAlignedAlloc(int, int). If ptr is NULL, no operation is performed.
    
    Parameters:
    
    ptr - the aligned block of memory to free
  - memReport
```
public static void memReport(MemoryUtil.MemoryAllocationReport report)
```
    Reports all live allocations.
    This method can only be used if the Configuration.DEBUG_MEMORY_ALLOCATOR option has been set to true.
    
    Parameters:
    
    report - the report callback
  - memReport
```
public static void memReport(MemoryUtil.MemoryAllocationReport report,
                             MemoryUtil.MemoryAllocationReport.Aggregate groupByStackTrace,
                             boolean groupByThread)
```
    Reports aggregates for the live allocations.
    This method can only be used if the Configuration.DEBUG_MEMORY_ALLOCATOR option has been set to true.
    
    Parameters:
    
    report - the report callback
    
    groupByStackTrace - how to aggregate the reported allocations
    
    groupByThread - if the reported allocations should be grouped by thread
  - memAddress0
```
public static long memAddress0(java.nio.Buffer buffer)
```
    Returns the memory address of the specified buffer. [INTERNAL USE ONLY]
    
    Parameters:
    
    buffer - the buffer
    
    Returns:
    
    the memory address
  - memAddress
```
public static long memAddress(java.nio.ByteBuffer buffer)
```
    Returns the memory address at the current position of the specified buffer. This is effectively a pointer value that can be used in native function calls.
    
    Parameters:
    
    buffer - the buffer
    
    Returns:
    
    the memory address
  - memAddress
```
public static long memAddress(java.nio.ByteBuffer buffer,
                              int position)
```
    Returns the memory address at the specified position of the specified buffer.
    
    Parameters:
    
    buffer - the buffer
    
    position - the buffer position
    
    Returns:
    
    the memory address
    
    See Also:
    
    memAddress(ByteBuffer)
  - memAddress
```
public static long memAddress(java.nio.ShortBuffer buffer)
```
    ShortBuffer version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(java.nio.ShortBuffer buffer,
                              int position)
```
    ShortBuffer version of memAddress(ByteBuffer, int).
  - memAddress
```
public static long memAddress(java.nio.CharBuffer buffer)
```
    CharBuffer version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(java.nio.CharBuffer buffer,
                              int position)
```
    CharBuffer version of memAddress(ByteBuffer, int).
  - memAddress
```
public static long memAddress(java.nio.IntBuffer buffer)
```
    IntBuffer version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(java.nio.IntBuffer buffer,
                              int position)
```
    IntBuffer version of memAddress(ByteBuffer, int).
  - memAddress
```
public static long memAddress(java.nio.FloatBuffer buffer)
```
    FloatBuffer version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(java.nio.FloatBuffer buffer,
                              int position)
```
    FloatBuffer version of memAddress(ByteBuffer, int).
  - memAddress
```
public static long memAddress(java.nio.LongBuffer buffer)
```
    LongBuffer version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(java.nio.LongBuffer buffer,
                              int position)
```
    LongBuffer version of memAddress(ByteBuffer, int).
  - memAddress
```
public static long memAddress(java.nio.DoubleBuffer buffer)
```
    DoubleBuffer version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(java.nio.DoubleBuffer buffer,
                              int position)
```
    DoubleBuffer version of memAddress(ByteBuffer, int).
  - memAddress
```
public static long memAddress(java.nio.Buffer buffer)
```
    Polymorphic version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(CustomBuffer<?> buffer)
```
    CustomBuffer version of memAddress(ByteBuffer).
  - memAddress
```
public static long memAddress(CustomBuffer<?> buffer,
                              int position)
```
    CustomBuffer version of memAddress(ByteBuffer, int).
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  java.nio.ByteBuffer buffer)
```
    Null-safe version of memAddress(ByteBuffer). Returns NULL if the specified buffer is null.
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  java.nio.ShortBuffer buffer)
```
    ShortBuffer version of memAddressSafe(ByteBuffer).
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  java.nio.CharBuffer buffer)
```
    CharBuffer version of memAddressSafe(ByteBuffer).
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  java.nio.IntBuffer buffer)
```
    IntBuffer version of memAddressSafe(ByteBuffer).
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  java.nio.FloatBuffer buffer)
```
    FloatBuffer version of memAddressSafe(ByteBuffer).
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  java.nio.LongBuffer buffer)
```
    LongBuffer version of memAddressSafe(ByteBuffer).
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  java.nio.DoubleBuffer buffer)
```
    DoubleBuffer version of memAddressSafe(ByteBuffer).
  - memAddressSafe
```
public static long memAddressSafe(@Nullable
                                  Pointer pointer)
```
    Pointer version of memAddressSafe(ByteBuffer).
  - memByteBuffer
```
public static java.nio.ByteBuffer memByteBuffer(long address,
                                                int capacity)
```
    Creates a new direct ByteBuffer that starts at the specified memory address and has the specified capacity. The returned ByteBuffer instance will be set to the native ByteOrder.
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new ByteBuffer
  - memByteBufferSafe
```
@Nullable
public static java.nio.ByteBuffer memByteBufferSafe(long address,
                                                    int capacity)
```
    Like memByteBuffer(long, int), but returns null if address is NULL.
  - memShortBuffer
```
public static java.nio.ShortBuffer memShortBuffer(long address,
                                                  int capacity)
```
    Creates a new direct ShortBuffer that starts at the specified memory address and has the specified capacity.
    The address specified must be aligned to 2 bytes. If not, use memByteBuffer(address, capacity * 2).asShortBuffer().
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new ShortBuffer
  - memShortBufferSafe
```
@Nullable
public static java.nio.ShortBuffer memShortBufferSafe(long address,
                                                      int capacity)
```
    Like memShortBuffer(long, int), but returns null if address is NULL.
  - memCharBuffer
```
public static java.nio.CharBuffer memCharBuffer(long address,
                                                int capacity)
```
    Creates a new direct CharBuffer that starts at the specified memory address and has the specified capacity.
    The address specified must be aligned to 2 bytes. If not, use memByteBuffer(address, capacity * 2).asCharBuffer().
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new CharBuffer
  - memCharBufferSafe
```
@Nullable
public static java.nio.CharBuffer memCharBufferSafe(long address,
                                                    int capacity)
```
    Like memCharBuffer(long, int), but returns null if address is NULL.
  - memIntBuffer
```
public static java.nio.IntBuffer memIntBuffer(long address,
                                              int capacity)
```
    Creates a new direct IntBuffer that starts at the specified memory address and has the specified capacity.
    The address specified must be aligned to 4 bytes. If not, use memByteBuffer(address, capacity * 4).asIntBuffer().
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new IntBuffer
  - memIntBufferSafe
```
@Nullable
public static java.nio.IntBuffer memIntBufferSafe(long address,
                                                  int capacity)
```
    Like memIntBuffer(long, int), but returns null if address is NULL.
  - memLongBuffer
```
public static java.nio.LongBuffer memLongBuffer(long address,
                                                int capacity)
```
    Creates a new direct LongBuffer that starts at the specified memory address and has the specified capacity.
    The address specified must be aligned to 8 bytes. If not, use memByteBuffer(address, capacity * 8).asLongBuffer().
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new LongBuffer
  - memLongBufferSafe
```
@Nullable
public static java.nio.LongBuffer memLongBufferSafe(long address,
                                                    int capacity)
```
    Like memLongBuffer(long, int), but returns null if address is NULL.
  - memFloatBuffer
```
public static java.nio.FloatBuffer memFloatBuffer(long address,
                                                  int capacity)
```
    Creates a new direct FloatBuffer that starts at the specified memory address and has the specified capacity.
    The address specified must be aligned to 4 bytes. If not, use memByteBuffer(address, capacity * 4).asFloatBuffer().
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new FloatBuffer
  - memFloatBufferSafe
```
@Nullable
public static java.nio.FloatBuffer memFloatBufferSafe(long address,
                                                      int capacity)
```
    Like memFloatBuffer(long, int), but returns null if address is NULL.
  - memDoubleBuffer
```
public static java.nio.DoubleBuffer memDoubleBuffer(long address,
                                                    int capacity)
```
    Creates a new direct DoubleBuffer that starts at the specified memory address and has the specified capacity.
    The address specified must be aligned to 8 bytes. If not, use memByteBuffer(address, capacity * 8).asDoubleBuffer().
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new DoubleBuffer
  - memDoubleBufferSafe
```
@Nullable
public static java.nio.DoubleBuffer memDoubleBufferSafe(long address,
                                                        int capacity)
```
    Like memDoubleBuffer(long, int), but returns null if address is NULL.
  - memPointerBuffer
```
public static PointerBuffer memPointerBuffer(long address,
                                             int capacity)
```
    Creates a new PointerBuffer that starts at the specified memory address and has the specified capacity.
    The address specified must be aligned to the pointer size. If not, use PointerBuffer.create(memByteBuffer(address, capacity * POINTER_SIZE)).
    
    Parameters:
    
    address - the starting memory address
    
    capacity - the buffer capacity
    
    Returns:
    
    the new PointerBuffer
  - memPointerBufferSafe
```
@Nullable
public static PointerBuffer memPointerBufferSafe(long address,
                                                 int capacity)
```
    Like memPointerBuffer(long, int), but returns null if address is NULL.
  - memDuplicate
```
public static java.nio.ByteBuffer memDuplicate(java.nio.ByteBuffer buffer)
```
    Duplicates the specified buffer. The returned buffer will have the same ByteOrder as the source buffer.
    This method should be preferred over ByteBuffer.duplicate() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to duplicate
    
    Returns:
    
    the duplicated buffer
  - memDuplicate
```
public static java.nio.ShortBuffer memDuplicate(java.nio.ShortBuffer buffer)
```
    Duplicates the specified buffer.
    This method should be preferred over ShortBuffer.duplicate() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to duplicate
    
    Returns:
    
    the duplicated buffer
  - memDuplicate
```
public static java.nio.CharBuffer memDuplicate(java.nio.CharBuffer buffer)
```
    Duplicates the specified buffer.
    This method should be preferred over CharBuffer.duplicate() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to duplicate
    
    Returns:
    
    the duplicated buffer
  - memDuplicate
```
public static java.nio.IntBuffer memDuplicate(java.nio.IntBuffer buffer)
```
    Duplicates the specified buffer.
    This method should be preferred over IntBuffer.duplicate() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to duplicate
    
    Returns:
    
    the duplicated buffer
  - memDuplicate
```
public static java.nio.LongBuffer memDuplicate(java.nio.LongBuffer buffer)
```
    Duplicates the specified buffer.
    This method should be preferred over LongBuffer.duplicate() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to duplicate
    
    Returns:
    
    the duplicated buffer
  - memDuplicate
```
public static java.nio.FloatBuffer memDuplicate(java.nio.FloatBuffer buffer)
```
    Duplicates the specified buffer.
    This method should be preferred over FloatBuffer.duplicate() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to duplicate
    
    Returns:
    
    the duplicated buffer
  - memDuplicate
```
public static java.nio.DoubleBuffer memDuplicate(java.nio.DoubleBuffer buffer)
```
    Duplicates the specified buffer.
    This method should be preferred over DoubleBuffer.duplicate() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to duplicate
    
    Returns:
    
    the duplicated buffer
  - memSlice
```
public static java.nio.ByteBuffer memSlice(java.nio.ByteBuffer buffer)
```
    Slices the specified buffer. The returned buffer will have the same ByteOrder as the source buffer.
    This method should be preferred over ByteBuffer.slice() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to slice
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.ShortBuffer memSlice(java.nio.ShortBuffer buffer)
```
    Slices the specified buffer.
    This method should be preferred over ShortBuffer.slice() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to slice
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.CharBuffer memSlice(java.nio.CharBuffer buffer)
```
    Slices the specified buffer.
    This method should be preferred over CharBuffer.slice() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to slice
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.IntBuffer memSlice(java.nio.IntBuffer buffer)
```
    Slices the specified buffer.
    This method should be preferred over IntBuffer.slice() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to slice
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.LongBuffer memSlice(java.nio.LongBuffer buffer)
```
    Slices the specified buffer.
    This method should be preferred over LongBuffer.slice() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to slice
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.FloatBuffer memSlice(java.nio.FloatBuffer buffer)
```
    Slices the specified buffer.
    This method should be preferred over FloatBuffer.slice() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to slice
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.DoubleBuffer memSlice(java.nio.DoubleBuffer buffer)
```
    Slices the specified buffer.
    This method should be preferred over DoubleBuffer.slice() because it has a much shorter call chain. Long call chains may fail to inline due to JVM limits, disabling important optimizations (e.g. scalar replacement via Escape Analysis).
    
    Parameters:
    
    buffer - the buffer to slice
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.ByteBuffer memSlice(java.nio.ByteBuffer buffer,
                                           int offset,
                                           int capacity)
```
    Returns a slice of the specified buffer between (buffer.position() + offset) and (buffer.position() + offset + capacity). The returned buffer will have the same ByteOrder as the original buffer.
    The position and limit of the original buffer are preserved after a call to this method.
    
    Parameters:
    
    buffer - the buffer to slice
    
    offset - the slice offset, it must be ≤ buffer.remaining()
    
    capacity - the slice length, it must be ≤ buffer.capacity() - (buffer.position() + offset)
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static java.nio.ShortBuffer memSlice(java.nio.ShortBuffer buffer,
                                            int offset,
                                            int capacity)

public static java.nio.CharBuffer memSlice(java.nio.CharBuffer buffer,
                                           int offset,
                                           int capacity)

public static java.nio.IntBuffer memSlice(java.nio.IntBuffer buffer,
                                          int offset,
                                          int capacity)

public static java.nio.LongBuffer memSlice(java.nio.LongBuffer buffer,
                                           int offset,
                                           int capacity)

public static java.nio.FloatBuffer memSlice(java.nio.FloatBuffer buffer,
                                            int offset,
                                            int capacity)

public static java.nio.DoubleBuffer memSlice(java.nio.DoubleBuffer buffer,
                                             int offset,
                                             int capacity)
```
    Returns a slice of the specified buffer between (buffer.position() + offset) and (buffer.position() + offset + capacity).
    The position and limit of the original buffer are preserved after a call to this method.
    
    Parameters:
    
    buffer - the buffer to slice
    
    offset - the slice offset, it must be ≤ buffer.remaining()
    
    capacity - the slice length, it must be ≤ buffer.capacity() - (buffer.position() + offset)
    
    Returns:
    
    the sliced buffer
  - memSlice
```
public static <T extends CustomBuffer<T>> T memSlice(T buffer,
                                                     int offset,
                                                     int capacity)
```
    Returns a slice of the specified buffer between (buffer.position() + offset) and (buffer.position() + offset + capacity).
    The position and limit of the original buffer are preserved after a call to this method.
    
    Parameters:
    
    buffer - the buffer to slice
    
    offset - the slice offset, it must be ≤ buffer.remaining()
    
    capacity - the slice length, it must be ≤ buffer.capacity() - (buffer.position() + offset)
    
    Returns:
    
    the sliced buffer
  - memSet
```
public static void memSet(java.nio.ByteBuffer ptr,
                          int value)

public static void memSet(java.nio.ShortBuffer ptr,
                          int value)

public static void memSet(java.nio.CharBuffer ptr,
                          int value)

public static void memSet(java.nio.IntBuffer ptr,
                          int value)

public static void memSet(java.nio.LongBuffer ptr,
                          int value)

public static void memSet(java.nio.FloatBuffer ptr,
                          int value)

public static void memSet(java.nio.DoubleBuffer ptr,
                          int value)
```
    Sets all bytes in a specified block of memory to a fixed value (usually zero).
    
    Parameters:
    
    ptr - the starting memory address
    
    value - the value to set (memSet will convert it to unsigned byte)
  - memSet
```
public static <T extends CustomBuffer<T>> void memSet(T ptr,
                                                      int value)
```
    Sets all bytes in a specified block of memory to a fixed value (usually zero).
    
    Type Parameters:
    
    T - the buffer type
    
    Parameters:
    
    ptr - the starting memory address
    
    value - the value to set (memSet will convert it to unsigned byte)
  - memSet
```
public static <T extends Struct> void memSet(T ptr,
                                             int value)
```
    Sets all bytes in a specified block of memory to a fixed value (usually zero).
    
    Type Parameters:
    
    T - the struct type
    
    Parameters:
    
    ptr - the starting memory address
    
    value - the value to set (memSet will convert it to unsigned byte)
  - memCopy
```
public static void memCopy(java.nio.ByteBuffer src,
                           java.nio.ByteBuffer dst)

public static void memCopy(java.nio.ShortBuffer src,
                           java.nio.ShortBuffer dst)

public static void memCopy(java.nio.CharBuffer src,
                           java.nio.CharBuffer dst)

public static void memCopy(java.nio.IntBuffer src,
                           java.nio.IntBuffer dst)

public static void memCopy(java.nio.LongBuffer src,
                           java.nio.LongBuffer dst)

public static void memCopy(java.nio.FloatBuffer src,
                           java.nio.FloatBuffer dst)

public static void memCopy(java.nio.DoubleBuffer src,
                           java.nio.DoubleBuffer dst)
```
    Sets all bytes in a specified block of memory to a copy of another block.
    
    Parameters:
    
    src - the source memory address
    
    dst - the destination memory address
  - memCopy
```
public static <T extends CustomBuffer<T>> void memCopy(T src,
                                                       T dst)
```
    Sets all bytes in a specified block of memory to a copy of another block.
    
    Type Parameters:
    
    T - the buffer type
    
    Parameters:
    
    src - the source memory address
    
    dst - the destination memory address
  - memCopy
```
public static <T extends Struct> void memCopy(T src,
                                              T dst)
```
    Sets all bytes of a struct to a copy of another struct.
    
    Type Parameters:
    
    T - the struct type
    
    Parameters:
    
    src - the source struct
    
    dst - the destination struct
  - memSet
```
public static void memSet(long ptr,
                          int value,
                          long bytes)
```
    Sets all bytes in a specified block of memory to a fixed value (usually zero).
    
    Parameters:
    
    ptr - the starting memory address
    
    value - the value to set (memSet will convert it to unsigned byte)
    
    bytes - the number of bytes to set
  - memCopy
```
public static void memCopy(long src,
                           long dst,
                           long bytes)
```
    Sets all bytes in a specified block of memory to a copy of another block.
    
    Parameters:
    
    src - the source memory address
    
    dst - the destination memory address
    
    bytes - the number of bytes to copy
  - memGetBoolean
```
public static boolean memGetBoolean(long ptr)
```
  - memGetByte
```
public static byte memGetByte(long ptr)
```
  - memGetShort
```
public static short memGetShort(long ptr)
```
  - memGetInt
```
public static int memGetInt(long ptr)
```
  - memGetLong
```
public static long memGetLong(long ptr)
```
  - memGetFloat
```
public static float memGetFloat(long ptr)
```
  - memGetDouble
```
public static double memGetDouble(long ptr)
```
  - memGetCLong
```
public static long memGetCLong(long ptr)
```
  - memGetAddress
```
public static long memGetAddress(long ptr)
```
  - memPutByte
```
public static void memPutByte(long ptr,
                              byte value)
```
  - memPutShort
```
public static void memPutShort(long ptr,
                               short value)
```
  - memPutInt
```
public static void memPutInt(long ptr,
                             int value)
```
  - memPutLong
```
public static void memPutLong(long ptr,
                              long value)
```
  - memPutFloat
```
public static void memPutFloat(long ptr,
                               float value)
```
  - memPutDouble
```
public static void memPutDouble(long ptr,
                                double value)
```
  - memPutCLong
```
public static void memPutCLong(long ptr,
                               long value)
```
  - memPutAddress
```
public static void memPutAddress(long ptr,
                                 long value)
```
  - memGlobalRefToObject
```
public static <T> T memGlobalRefToObject(long globalRef)
```
    Returns the object that the specified global reference points to.
    
    Type Parameters:
    
    T - the object type
    
    Parameters:
    
    globalRef - the global reference
    
    Returns:
    
    the object pointed to by globalRef
  - memNewGlobalRef
```
@Deprecated
public static long memNewGlobalRef(java.lang.Object obj)
```
    Deprecated.
    
    Deprecated, use JNINativeInterface.NewGlobalRef(java.lang.Object) instead.
  - memDeleteGlobalRef
```
@Deprecated
public static void memDeleteGlobalRef(long globalRef)
```
    Deprecated.
    
    Deprecated, use JNINativeInterface.DeleteGlobalRef(long) instead.
  - memNewWeakGlobalRef
```
@Deprecated
public static long memNewWeakGlobalRef(java.lang.Object obj)
```
    Deprecated.
    
    Deprecated, use JNINativeInterface.NewWeakGlobalRef(java.lang.Object) instead.
  - memDeleteWeakGlobalRef
```
@Deprecated
public static void memDeleteWeakGlobalRef(long globalRef)
```
    Deprecated.
    
    Deprecated, use JNINativeInterface.DeleteWeakGlobalRef(long) instead.
  - memASCII
```
public static java.nio.ByteBuffer memASCII(java.lang.CharSequence text)
```
    Returns a ByteBuffer containing the specified text ASCII encoded and null-terminated.
    
    Parameters:
    
    text - the text to encode
    
    Returns:
    
    the encoded text. The returned buffer must be deallocated manually with memFree(java.nio.Buffer).
  - memASCIISafe
```
@Nullable
public static java.nio.ByteBuffer memASCIISafe(@Nullable
                                               java.lang.CharSequence text)
```
    Like memASCII, but returns null if text is null.
  - memASCII
```
public static java.nio.ByteBuffer memASCII(java.lang.CharSequence text,
                                           boolean nullTerminated)
```
    Returns a ByteBuffer containing the specified text ASCII encoded and optionally null-terminated.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    Returns:
    
    the encoded text. The returned buffer must be deallocated manually with memFree(java.nio.Buffer).
  - memASCIISafe
```
@Nullable
public static java.nio.ByteBuffer memASCIISafe(@Nullable
                                               java.lang.CharSequence text,
                                               boolean nullTerminated)
```
    Like memASCII, but returns null if text is null.
  - memASCII
```
public static int memASCII(java.lang.CharSequence text,
                           boolean nullTerminated,
                           java.nio.ByteBuffer target)
```
    Encodes and optionally null-terminates the specified text using ASCII encoding. The encoded text is stored in the specified ByteBuffer, at the current buffer position. The current buffer position is not modified by this operation. The target buffer is assumed to have enough remaining space to store the encoded text.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    Returns:
    
    the number of bytes of the encoded string
  - memASCII
```
public static int memASCII(java.lang.CharSequence text,
                           boolean nullTerminated,
                           java.nio.ByteBuffer target,
                           int offset)
```
    Encodes and optionally null-terminates the specified text using ASCII encoding. The encoded text is stored in the specified ByteBuffer at the specified position offset. The current buffer position is not modified by this operation. The target buffer is assumed to have enough remaining space to store the encoded text.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    offset - the buffer position to which the string will be encoded
    
    Returns:
    
    the number of bytes of the encoded string
  - memLengthASCII
```
public static int memLengthASCII(java.lang.CharSequence value,
                                 boolean nullTerminated)
```
    Returns the number of bytes required to encode the specified text in the ASCII encoding.
    
    Parameters:
    
    value - the text to encode
    
    nullTerminated - if true, add the number of bytes required for null-termination
    
    Returns:
    
    the number of bytes
  - memUTF8
```
public static java.nio.ByteBuffer memUTF8(java.lang.CharSequence text)
```
    Returns a ByteBuffer containing the specified text UTF-8 encoded and null-terminated.
    
    Parameters:
    
    text - the text to encode
    
    Returns:
    
    the encoded text. The returned buffer must be deallocated manually with memFree(java.nio.Buffer).
  - memUTF8Safe
```
@Nullable
public static java.nio.ByteBuffer memUTF8Safe(@Nullable
                                              java.lang.CharSequence text)
```
    Like memASCII, but returns null if text is null.
  - memUTF8
```
public static java.nio.ByteBuffer memUTF8(java.lang.CharSequence text,
                                          boolean nullTerminated)
```
    Returns a ByteBuffer containing the specified text UTF-8 encoded and optionally null-terminated.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    Returns:
    
    the encoded text. The returned buffer must be deallocated manually with memFree(java.nio.Buffer).
  - memUTF8Safe
```
@Nullable
public static java.nio.ByteBuffer memUTF8Safe(@Nullable
                                              java.lang.CharSequence text,
                                              boolean nullTerminated)
```
    Like memASCII, but returns null if text is null.
  - memUTF8
```
public static int memUTF8(java.lang.CharSequence text,
                          boolean nullTerminated,
                          java.nio.ByteBuffer target)
```
    Encodes and optionally null-terminates the specified text using UTF-8 encoding. The encoded text is stored in the specified ByteBuffer, at the current buffer position. The current buffer position is not modified by this operation. The target buffer is assumed to have enough remaining space to store the encoded text. The specified text is assumed to be a valid UTF-16 string.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    target - the buffer in which to store the encoded text
    
    Returns:
    
    the number of bytes of the encoded string
  - memUTF8
```
public static int memUTF8(java.lang.CharSequence text,
                          boolean nullTerminated,
                          java.nio.ByteBuffer target,
                          int offset)
```
    Encodes and optionally null-terminates the specified text using UTF-8 encoding. The encoded text is stored in the specified ByteBuffer, at the specified position offset. The current buffer position is not modified by this operation. The target buffer is assumed to have enough remaining space to store the encoded text. The specified text is assumed to be a valid UTF-16 string.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    target - the buffer in which to store the encoded text
    
    offset - the buffer position to which the string will be encoded
    
    Returns:
    
    the number of bytes of the encoded string
  - memLengthUTF8
```
public static int memLengthUTF8(java.lang.CharSequence value,
                                boolean nullTerminated)
```
    Returns the number of bytes required to encode the specified text in the UTF-8 encoding.
    
    Parameters:
    
    value - the text to encode
    
    nullTerminated - if true, add the number of bytes required for null-termination
    
    Returns:
    
    the number of bytes
  - memUTF16
```
public static java.nio.ByteBuffer memUTF16(java.lang.CharSequence text)
```
    Returns a ByteBuffer containing the specified text UTF-16 encoded and null-terminated.
    
    Parameters:
    
    text - the text to encode
    
    Returns:
    
    the encoded text. The returned buffer must be deallocated manually with memFree(java.nio.Buffer).
  - memUTF16Safe
```
@Nullable
public static java.nio.ByteBuffer memUTF16Safe(@Nullable
                                               java.lang.CharSequence text)
```
    Like memASCII, but returns null if text is null.
  - memUTF16
```
public static java.nio.ByteBuffer memUTF16(java.lang.CharSequence text,
                                           boolean nullTerminated)
```
    Returns a ByteBuffer containing the specified text UTF-16 encoded and optionally null-terminated.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    Returns:
    
    the encoded text. The returned buffer must be deallocated manually with memFree(java.nio.Buffer).
  - memUTF16Safe
```
@Nullable
public static java.nio.ByteBuffer memUTF16Safe(@Nullable
                                               java.lang.CharSequence text,
                                               boolean nullTerminated)
```
    Like memASCII, but returns null if text is null.
  - memUTF16
```
public static int memUTF16(java.lang.CharSequence text,
                           boolean nullTerminated,
                           java.nio.ByteBuffer target)
```
    Encodes and optionally null-terminates the specified text using UTF-16 encoding. The encoded text is stored in the specified ByteBuffer, at the current buffer position. The current buffer position is not modified by this operation. The target buffer is assumed to have enough remaining space to store the encoded text.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    target - the buffer in which to store the encoded text
    
    Returns:
    
    the number of bytes of the encoded string
  - memUTF16
```
public static int memUTF16(java.lang.CharSequence text,
                           boolean nullTerminated,
                           java.nio.ByteBuffer target,
                           int offset)
```
    Encodes and optionally null-terminates the specified text using UTF-16 encoding. The encoded text is stored in the specified ByteBuffer at the specified position offset. The current buffer position is not modified by this operation. The target buffer is assumed to have enough remaining space to store the encoded text.
    
    Parameters:
    
    text - the text to encode
    
    nullTerminated - if true, the text will be terminated with a '\0'.
    
    target - the buffer in which to store the encoded text
    
    offset - the buffer position to which the string will be encoded
    
    Returns:
    
    the number of bytes of the encoded string
  - memLengthUTF16
```
public static int memLengthUTF16(java.lang.CharSequence value,
                                 boolean nullTerminated)
```
    Returns the number of bytes required to encode the specified text in the UTF-16 encoding.
    
    Parameters:
    
    value - the text to encode
    
    nullTerminated - if true, add the number of bytes required for null-termination
    
    Returns:
    
    the number of bytes
  - memLengthNT1
```
public static int memLengthNT1(java.nio.ByteBuffer buffer)
```
    Calculates the length, in bytes, of the null-terminated string that starts at the current position of the specified buffer. A single \0 character will terminate the string. The returned length will NOT include the \0 byte.
    This method is useful for reading ASCII and UTF8 encoded text.
    
    Parameters:
    
    buffer - the buffer containing the null-terminated string
    
    Returns:
    
    the string length, in bytes
  - memLengthNT2
```
public static int memLengthNT2(java.nio.ByteBuffer buffer)
```
    Calculates the length, in bytes, of the null-terminated string that starts at the current position of the specified buffer. Two \0 characters will terminate the string. The returned buffer will NOT include the \0 bytes.
    This method is useful for reading UTF16 encoded text.
    
    Parameters:
    
    buffer - the buffer containing the null-terminated string
    
    Returns:
    
    the string length, in bytes
  - memByteBufferNT1
```
public static java.nio.ByteBuffer memByteBufferNT1(long address)
```
    Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address. A single \0 character will terminate the string. The returned buffer will NOT include the \0 byte.
    This method is useful for reading ASCII and UTF8 encoded text.
    
    Parameters:
    
    address - the starting memory address
    
    Returns:
    
    the new ByteBuffer
  - memByteBufferNT1
```
public static java.nio.ByteBuffer memByteBufferNT1(long address,
                                                   int maxLength)
```
    Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address, up to a maximum of maxLength bytes. A single \0 character will terminate the string. The returned buffer will NOT include the \0 byte.
    This method is useful for reading ASCII and UTF8 encoded text.
    
    Parameters:
    
    address - the starting memory address
    
    maxLength - the maximum string length, in bytes
    
    Returns:
    
    the new ByteBuffer
  - memByteBufferNT1Safe
```
@Nullable
public static java.nio.ByteBuffer memByteBufferNT1Safe(long address)
```
    Like memByteBufferNT1, but returns null if address is NULL.
  - memByteBufferNT1Safe
```
@Nullable
public static java.nio.ByteBuffer memByteBufferNT1Safe(long address,
                                                       int maxLength)
```
    Like memByteBufferNT1, but returns null if address is NULL.
  - memByteBufferNT2
```
public static java.nio.ByteBuffer memByteBufferNT2(long address)
```
    Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address. Two \0 characters will terminate the string. The returned buffer will NOT include the \0 bytes.
    This method is useful for reading UTF16 encoded text.
    
    Parameters:
    
    address - the starting memory address
    
    Returns:
    
    the new ByteBuffer
  - memByteBufferNT2
```
public static java.nio.ByteBuffer memByteBufferNT2(long address,
                                                   int maxLength)
```
    Creates a new direct ByteBuffer that starts at the specified memory address and has capacity equal to the null-terminated string starting at that address, up to a maximum of maxLength bytes. Two \0 characters will terminate the string. The returned buffer will NOT include the \0 bytes.
    This method is useful for reading UTF16 encoded text.
    
    Parameters:
    
    address - the starting memory address
    
    Returns:
    
    the new ByteBuffer
  - memByteBufferNT2Safe
```
@Nullable
public static java.nio.ByteBuffer memByteBufferNT2Safe(long address)
```
    Like memByteBufferNT2, but returns null if address is NULL.
  - memByteBufferNT2Safe
```
@Nullable
public static java.nio.ByteBuffer memByteBufferNT2Safe(long address,
                                                       int maxLength)
```
    Like memByteBufferNT2, but returns null if address is NULL.
  - memASCII
```
public static java.lang.String memASCII(long address)
```
    Converts the null-terminated ASCII encoded string at the specified memory address to a String.
    
    Parameters:
    
    address - the string memory address
    
    Returns:
    
    the decoded String
  - memASCII
```
public static java.lang.String memASCII(long address,
                                        int length)
```
    Converts the ASCII encoded string at the specified memory address to a String.
    
    Parameters:
    
    address - the string memory address
    
    length - the number of bytes to decode
    
    Returns:
    
    the decoded String
  - memASCII
```
public static java.lang.String memASCII(java.nio.ByteBuffer buffer)
```
    Decodes the bytes with index [position(), position()+remaining()) in buffer, as an ASCII string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    Returns:
    
    the decoded String
  - memASCIISafe
```
@Nullable
public static java.lang.String memASCIISafe(long address)
```
    Like memASCII, but returns null if address is NULL.
  - memASCIISafe
```
@Nullable
public static java.lang.String memASCIISafe(long address,
                                            int length)
```
    Like memASCII, but returns null if address is NULL.
  - memASCIISafe
```
@Nullable
public static java.lang.String memASCIISafe(@Nullable
                                            java.nio.ByteBuffer buffer)
```
    Like memASCII, but returns null if buffer is null.
  - memASCII
```
public static java.lang.String memASCII(java.nio.ByteBuffer buffer,
                                        int length)
```
    Decodes the bytes with index [position(), position()+length) in buffer, as an ASCII string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    length - the number of bytes to decode
    
    Returns:
    
    the decoded String
  - memASCII
```
public static java.lang.String memASCII(java.nio.ByteBuffer buffer,
                                        int length,
                                        int offset)
```
    Decodes the bytes with index [offset, offset+length) in buffer, as an ASCII string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    length - the number of bytes to decode
    
    offset - the offset at which to start decoding.
    
    Returns:
    
    the decoded String
  - memUTF8
```
public static java.lang.String memUTF8(long address)
```
    Converts the null-terminated UTF-8 encoded string at the specified memory address to a String.
    
    Parameters:
    
    address - the string memory address
    
    Returns:
    
    the decoded String
  - memUTF8
```
public static java.lang.String memUTF8(long address,
                                       int length)
```
    Converts the UTF-8 encoded string at the specified memory address to a String.
    
    Parameters:
    
    address - the string memory address
    
    length - the number of bytes to decode
    
    Returns:
    
    the decoded String
  - memUTF8
```
public static java.lang.String memUTF8(java.nio.ByteBuffer buffer)
```
    Decodes the bytes with index [position(), position()+remaining()) in buffer, as a UTF-8 string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    Returns:
    
    the decoded String
  - memUTF8Safe
```
@Nullable
public static java.lang.String memUTF8Safe(long address)
```
    Like memUTF8, but returns null if address is NULL.
  - memUTF8Safe
```
@Nullable
public static java.lang.String memUTF8Safe(long address,
                                           int length)
```
    Like memUTF8, but returns null if address is NULL.
  - memUTF8Safe
```
@Nullable
public static java.lang.String memUTF8Safe(@Nullable
                                           java.nio.ByteBuffer buffer)
```
    Like memUTF8, but returns null if buffer is null.
  - memUTF8
```
public static java.lang.String memUTF8(java.nio.ByteBuffer buffer,
                                       int length)
```
    Decodes the bytes with index [position(), position()+length) in buffer, as a UTF-8 string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    length - the number of bytes to decode
    
    Returns:
    
    the decoded String
  - memUTF8
```
public static java.lang.String memUTF8(java.nio.ByteBuffer buffer,
                                       int length,
                                       int offset)
```
    Decodes the bytes with index [offset, offset+length) in buffer, as a UTF-8 string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    length - the number of bytes to decode
    
    offset - the offset at which to start decoding.
    
    Returns:
    
    the decoded String
  - memUTF16
```
public static java.lang.String memUTF16(long address)
```
    Converts the null-terminated UTF-16 encoded string at the specified memory address to a String.
    
    Parameters:
    
    address - the string memory address
    
    Returns:
    
    the decoded String
  - memUTF16
```
public static java.lang.String memUTF16(long address,
                                        int length)
```
    Converts the UTF-16 encoded string at the specified memory address to a String.
    
    Parameters:
    
    address - the string memory address
    
    length - the number of characters to decode
    
    Returns:
    
    the decoded String
  - memUTF16
```
public static java.lang.String memUTF16(java.nio.ByteBuffer buffer)
```
    Decodes the bytes with index [position(), position()+remaining()) in buffer, as a UTF-16 string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    Returns:
    
    the decoded String
  - memUTF16Safe
```
@Nullable
public static java.lang.String memUTF16Safe(long address)
```
    Like memUTF16, but returns null if address is NULL.
  - memUTF16Safe
```
@Nullable
public static java.lang.String memUTF16Safe(long address,
                                            int length)
```
    Like memUTF16, but returns null if address is NULL.
  - memUTF16Safe
```
@Nullable
public static java.lang.String memUTF16Safe(@Nullable
                                            java.nio.ByteBuffer buffer)
```
    Like memUTF16, but returns null if buffer is null.
  - memUTF16
```
public static java.lang.String memUTF16(java.nio.ByteBuffer buffer,
                                        int length)
```
    Decodes the bytes with index [position(), position()+(length*2)) in buffer, as a UTF-16 string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    length - the number of characters to decode
    
    Returns:
    
    the decoded String
  - memUTF16
```
public static java.lang.String memUTF16(java.nio.ByteBuffer buffer,
                                        int length,
                                        int offset)
```
    Decodes the bytes with index [offset, offset+(length*2)) in buffer, as a UTF-16 string.
    The current position and limit of the specified buffer are not affected by this operation.
    
    Parameters:
    
    buffer - the ByteBuffer to decode
    
    length - the number of characters to decode
    
    offset - the offset at which to start decoding, in bytes.
    
    Returns:
    
    the decoded String

Class MemoryUtil

Text encoding/decoding

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NULL

PAGE_SIZE

CACHE_LINE_SIZE

Method Detail

getAllocator

getAllocator

nmemAlloc

nmemAllocChecked

memAlloc

memAllocShort

memAllocInt

memAllocFloat

memAllocLong

memAllocDouble

memAllocPointer

nmemFree

memFree

memFree

nmemCalloc

nmemCallocChecked

memCalloc

memCalloc

memCallocShort

memCallocInt

memCallocFloat

memCallocLong

memCallocDouble

memCallocPointer

nmemRealloc

nmemReallocChecked

memRealloc

memRealloc

memRealloc

memRealloc

memRealloc

memRealloc

memRealloc

nmemAlignedAlloc

nmemAlignedAllocChecked

memAlignedAlloc

nmemAlignedFree

memAlignedFree

memReport

memReport

memAddress0

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddress

memAddressSafe

memAddressSafe

memAddressSafe

memAddressSafe

memAddressSafe

memAddressSafe

memAddressSafe

memAddressSafe

memByteBuffer

memByteBufferSafe

memShortBuffer