Package org.lwjgl

Class CLongBuffer

  • All Implemented Interfaces:
    java.lang.Comparable<CLongBuffer>, Pointer

    public class CLongBuffer
    extends CustomBuffer<CLongBuffer>
    implements java.lang.Comparable<CLongBuffer>
    This class is a container for C long data. Its interface mirrors the LongBuffer API for convenience.

    The size of the C long type depends on the platform and CPU architecture. On Windows it is always 32-bit. On other platforms, it is 32-bit on 32-bit architectures and 64-bit on 64-bit architectures. Most APIs prefer portable sizes, so this class is rarely needed.

    • Method Detail

      • allocateDirect

        public static CLongBuffer allocateDirect​(int capacity)
        Allocates a new long buffer.

        The new buffer's position will be zero, its limit will be its capacity, and its mark will be undefined.

        Parameters:
        capacity - the new buffer's capacity, in longs
        Returns:
        the new long buffer
        Throws:
        java.lang.IllegalArgumentException - If the capacity is a negative integer
      • create

        public static CLongBuffer create​(long address,
                                         int capacity)
        Creates a new CLongBuffer that starts at the specified memory address and has the specified capacity.
        Parameters:
        address - the starting memory address
        capacity - the buffer capacity, in number of longs
      • create

        public static CLongBuffer create​(java.nio.ByteBuffer source)
        Creates a new CLongBuffer using the specified ByteBuffer as its long data source.
        Parameters:
        source - the source buffer
      • get

        public long get()
        Relative get method. Reads the long at this buffer's current position, and then increments the position.
        Returns:
        the long at the buffer's current position
        Throws:
        java.nio.BufferUnderflowException - If the buffer's current position is not smaller than its limit
      • get

        public static long get​(java.nio.ByteBuffer source)
        Convenience relative get from a source ByteBuffer.
        Parameters:
        source - the source ByteBuffer
      • put

        public CLongBuffer put​(long p)
        Relative put method  (optional operation).

        Writes the specified long into this buffer at the current position, and then increments the position.

        Parameters:
        p - the long to be written
        Returns:
        This buffer
        Throws:
        java.nio.BufferOverflowException - If this buffer's current position is not smaller than its limit
      • put

        public static void put​(java.nio.ByteBuffer target,
                               long p)
        Convenience relative put on a target ByteBuffer.
        Parameters:
        target - the target ByteBuffer
        p - the long value to be written
      • get

        public long get​(int index)
        Absolute get method. Reads the long at the specified index.
        Parameters:
        index - the index from which the long will be read
        Returns:
        the long at the specified index
        Throws:
        java.lang.IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
      • get

        public static long get​(java.nio.ByteBuffer source,
                               int index)
        Convenience absolute get from a source ByteBuffer.
        Parameters:
        source - the source ByteBuffer
        index - the index at which the long will be read
      • put

        public CLongBuffer put​(int index,
                               long p)
        Absolute put method  (optional operation).

        Writes the specified long into this buffer at the specified index.

        Parameters:
        index - the index at which the long will be written
        p - the long value to be written
        Returns:
        This buffer
        Throws:
        java.lang.IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
      • put

        public static void put​(java.nio.ByteBuffer target,
                               int index,
                               long p)
        Convenience absolute put on a target ByteBuffer.
        Parameters:
        target - the target ByteBuffer
        index - the index at which the long will be written
        p - the long value to be written
      • get

        public CLongBuffer get​(long[] dst)
        Relative bulk get method.

        This method transfers longs from this buffer into the specified destination array. An invocation of this method of the form src.get(a) behaves in exactly the same way as the invocation

             src.get(a, 0, a.length) 
        Returns:
        This buffer
        Throws:
        java.nio.BufferUnderflowException - If there are fewer than length longs remaining in this buffer
      • get

        public CLongBuffer get​(long[] dst,
                               int offset,
                               int length)
        Relative bulk get method.

        This method transfers longs from this buffer into the specified destination array. If there are fewer longs remaining in the buffer than are required to satisfy the request, that is, if length &gt; remaining(), then no longs are transferred and a BufferUnderflowException is thrown.

        Otherwise, this method copies length longs from this buffer into the specified array, starting at the current position of this buffer and at the specified offset in the array. The position of this buffer is then incremented by length.

        In other words, an invocation of this method of the form src.get(dst,&nbsp;off,&nbsp;len) has exactly the same effect as the loop

             for (int i = off; i < off + len; i++)
                 dst[i] = src.get(); 

        except that it first checks that there are sufficient longs in this buffer and it is potentially much more efficient.

        Parameters:
        dst - the array into which longs are to be written
        offset - the offset within the array of the first long to be written; must be non-negative and no larger than dst.length
        length - the maximum number of longs to be written to the specified array; must be non-negative and no larger than dst.length - offset
        Returns:
        This buffer
        Throws:
        java.nio.BufferUnderflowException - If there are fewer than length longs remaining in this buffer
        java.lang.IndexOutOfBoundsException - If the preconditions on the offset and length parameters do not hold
      • put

        public CLongBuffer put​(long[] src)
        Relative bulk put method  (optional operation).

        This method transfers the entire content of the specified source long array into this buffer. An invocation of this method of the form dst.put(a) behaves in exactly the same way as the invocation

             dst.put(a, 0, a.length) 
        Returns:
        This buffer
        Throws:
        java.nio.BufferOverflowException - If there is insufficient space in this buffer
      • put

        public CLongBuffer put​(long[] src,
                               int offset,
                               int length)
        Relative bulk put method  (optional operation).

        This method transfers longs into this buffer from the specified source array. If there are more longs to be copied from the array than remain in this buffer, that is, if length &gt; remaining(), then no longs are transferred and a BufferOverflowException is thrown.

        Otherwise, this method copies length longs from the specified array into this buffer, starting at the specified offset in the array and at the current position of this buffer. The position of this buffer is then incremented by length.

        In other words, an invocation of this method of the form dst.put(src,&nbsp;off,&nbsp;len) has exactly the same effect as the loop

             for (int i = off; i < off + len; i++)
                 dst.put(a[i]); 

        except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.

        Parameters:
        src - the array from which longs are to be read
        offset - the offset within the array of the first long to be read; must be non-negative and no larger than array.length
        length - the number of longs to be read from the specified array; must be non-negative and no larger than array.length - offset
        Returns:
        This buffer
        Throws:
        java.nio.BufferOverflowException - If there is insufficient space in this buffer
        java.lang.IndexOutOfBoundsException - If the preconditions on the offset and length parameters do not hold
      • hashCode

        public int hashCode()
        Returns the current hash code of this buffer.

        The hash code of a long buffer depends only upon its remaining elements; that is, upon the elements from position() up to, and including, the element at limit() - 1.

        Because buffer hash codes are content-dependent, it is inadvisable to use buffers as keys in hash maps or similar data structures unless it is known that their contents will not change.

        Overrides:
        hashCode in class Pointer.Default
        Returns:
        the current hash code of this buffer
      • equals

        public boolean equals​(java.lang.Object ob)
        Tells whether or not this buffer is equal to another object.

        Two long buffers are equal if, and only if,

        1. They have the same element type,
        2. They have the same number of remaining elements, and
        3. The two sequences of remaining elements, considered independently of their starting positions, are pointwise equal.

        A long buffer is not equal to any other type of object.

        Overrides:
        equals in class Pointer.Default
        Parameters:
        ob - the object to which this buffer is to be compared
        Returns:
        true if, and only if, this buffer is equal to the given object
      • compareTo

        public int compareTo​(CLongBuffer that)
        Compares this buffer to another.

        Two long buffers are compared by comparing their sequences of remaining elements lexicographically, without regard to the starting position of each sequence within its corresponding buffer.

        A long buffer is not comparable to any other type of object.

        Specified by:
        compareTo in interface java.lang.Comparable<CLongBuffer>
        Returns:
        A negative integer, zero, or a positive integer as this buffer is less than, equal to, or greater than the specified buffer