Package org.lwjgl.system

Class 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

    • 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

      • 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 MemoryUtil.memFree(java.nio.Buffer).

        Parameters:
        size - the size of the memory block to allocate, in bytes. 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. If the function failed to allocate the requested block of memory, a MemoryUtil.NULL pointer is returned.

      • memAllocShort

        public static java.nio.ShortBuffer memAllocShort(int size)
        ShortBuffer version of MemoryUtil.memAlloc(int).
        Parameters:
        size - the number of short values to allocate.

      • memAllocInt

        public static java.nio.IntBuffer memAllocInt(int size)
        IntBuffer version of MemoryUtil.memAlloc(int).
        Parameters:
        size - the number of int values to allocate.

      • memAllocFloat

        public static java.nio.FloatBuffer memAllocFloat(int size)
        FloatBuffer version of MemoryUtil.memAlloc(int).
        Parameters:
        size - the number of float values to allocate.

      • memAllocLong

        public static java.nio.LongBuffer memAllocLong(int size)
        LongBuffer version of MemoryUtil.memAlloc(int).
        Parameters:
        size - the number of long values to allocate.

      • memAllocDouble

        public static java.nio.DoubleBuffer memAllocDouble(int size)
        DoubleBuffer version of MemoryUtil.memAlloc(int).
        Parameters:
        size - the number of double values to allocate.

      • memAllocPointer

        public static PointerBuffer memAllocPointer(int size)
        PointerBuffer version of MemoryUtil.memAlloc(int).
        Parameters:
        size - the number of pointer values to allocate.

      • 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 MemoryUtil.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. If the function failed to allocate the requested block of memory, a MemoryUtil.NULL pointer is returned.

      • memCalloc

        public static java.nio.ByteBuffer memCalloc(int num)
        Alternative version of MemoryUtil.memCalloc(int, int).
        Parameters:
        num - the number of bytes to allocate.

      • memCallocShort

        public static java.nio.ShortBuffer memCallocShort(int num)
        ShortBuffer version of MemoryUtil.memCalloc(int, int).
        Parameters:
        num - the number of short values to allocate.

      • memCallocInt

        public static java.nio.IntBuffer memCallocInt(int num)
        IntBuffer version of MemoryUtil.memCalloc(int, int).
        Parameters:
        num - the number of int values to allocate.

      • memCallocFloat

        public static java.nio.FloatBuffer memCallocFloat(int num)
        FloatBuffer version of MemoryUtil.memCalloc(int, int).
        Parameters:
        num - the number of float values to allocate.

      • memCallocLong

        public static java.nio.LongBuffer memCallocLong(int num)
        LongBuffer version of MemoryUtil.memCalloc(int, int).
        Parameters:
        num - the number of long values to allocate.

      • memCallocDouble

        public static java.nio.DoubleBuffer memCallocDouble(int num)
        DoubleBuffer version of MemoryUtil.memCalloc(int, int).
        Parameters:
        num - the number of double values to allocate.

      • memRealloc

        public static java.nio.ByteBuffer memRealloc(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.

        In case that ptr is a MemoryUtil.NULL pointer, the function behaves like MemoryUtil.memAlloc(int), assigning a new block of size bytes and returning a pointer to its beginning.

        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 MemoryUtil.memAlloc(int), MemoryUtil.memCalloc(int, int) or MemoryUtil.memRealloc(java.nio.ByteBuffer, int). Alternatively, this can be a MemoryUtil.NULL pointer, in which case a new block is allocated (as if MemoryUtil.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. If the function fails to allocate the requested block of memory, a MemoryUtil.NULL pointer is returned, and the memory block pointed to by argument ptr is not deallocated (it is still valid, and with its contents unchanged).

      • 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 MemoryUtil.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.

      • memAlignedFree

        public static void memAlignedFree(java.nio.ByteBuffer ptr)
        Frees a block of memory that was allocated with MemoryUtil.memAlignedAlloc(int, int). If ptr is NULL, no operation is performed.
        Parameters:
        ptr - the aligned block of memory to free

      • 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:
        MemoryUtil.memAddress(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

      • 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

      • 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

      • 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

      • 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

      • 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

      • 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

      • 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

      • memSetupBuffer

        public static java.nio.ByteBuffer memSetupBuffer(java.nio.ByteBuffer buffer,
                                                 long address,
                                                 int capacity)
        This method is an alternative to MemoryUtil.memByteBuffer(long, int) that allows the reuse of an existing direct ByteBuffer instance. It modifies that instance so that it starts at the specified memory address and has the specified capacity. The instance passed to this method should not be an instance created using ByteBuffer.allocateDirect(int). Using such an instance will cause an exception to be thrown. Other instances are allowed and their parent reference will be cleared before this method returns.

        ByteBuffer instance modification might not be possible. In that case this method behaves exactly like MemoryUtil.memByteBuffer(long, int), so the returned instance should always replace the input one.

        Parameters:
        buffer - the ByteBuffer to modify
        address - the starting memory address
        capacity - the buffer capacity
        Returns:
        the modified ByteBuffer

      • 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.
        Parameters:
        buffer - the buffer to slice
        Returns:
        the sliced buffer
        See Also:
        ByteBuffer.slice()

      • 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.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)

public static PointerBuffer memSlice(PointerBuffer 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(long ptr,
                          int value,
                          int 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,
                           int 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)

      • 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)

      • 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

        public static long memNewGlobalRef(java.lang.Object obj)
        Creates a new global reference to the specified object. This method is a simple wrapper over the JNI NewGlobalRef function.
        Parameters:
        obj - the object
        Returns:
        the global reference memory address

      • memDeleteGlobalRef

        public static void memDeleteGlobalRef(long globalRef)
        Deletes a global reference. This method is a simple wrapper over the JNI DeleteGlobalRef function.
        Parameters:
        globalRef - the memory address of the global reference to delete

      • memNewWeakGlobalRef

        public static long memNewWeakGlobalRef(java.lang.Object obj)
        Creates a new weak global reference to the specified object. This method is a simple wrapper over the JNI NewWeakGlobalRef function.
        Parameters:
        obj - the object
        Returns:
        the weak global reference memory address

      • memDeleteWeakGlobalRef

        public static void memDeleteWeakGlobalRef(long globalRef)
        Deletes a weak global reference. This method is a simple wrapper over the JNI DeleteWeakGlobalRef function.
        Parameters:
        globalRef - the memory address of the weak global reference to delete

      • memASCII

        public static java.nio.ByteBuffer memASCII(java.lang.CharSequence text)
        Returns a ByteBuffer containing the specified text ASCII encoded and null-terminated. If text is null, null is returned.
        Parameters:
        text - the text to encode
        Returns:
        the encoded text or 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. If text is null, null is returned.
        Parameters:
        text - the text to encode
        nullTerminated - if true, the text will be terminated with a '\0'.
        Returns:
        the encoded text or 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. If text is null, null is returned.
        Parameters:
        text - the text to encode
        Returns:
        the encoded text or 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. If text is null, null is returned.
        Parameters:
        text - the text to encode
        nullTerminated - if true, the text will be terminated with a '\0'.
        Returns:
        the encoded text or 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. If text is null, null is returned.
        Parameters:
        text - the text to encode
        Returns:
        the encoded text

      • 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. If text is null, null is returned.
        Parameters:
        text - the text to encode
        nullTerminated - if true, the text will be terminated with a '\0'.
        Returns:
        the encoded text

      • 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

      • 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

      • 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 or null if the specified address is null

      • 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, or null
        Returns:
        the decoded String or null if the specified 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 or null if the specified address is null

      • 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, or null
        Returns:
        the decoded String or null if the specified 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 or null if the specified address is null

      • 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, or null
        Returns:
        the decoded String or null if the specified 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