Package org.lwjgl

Class CLongBuffer

All Implemented Interfaces:
Comparable<CLongBuffer>, Pointer

public class CLongBuffer extends CustomBuffer<CLongBuffer> implements 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 Details

    • 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:
      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(ByteBuffer source)
      Creates a new CLongBuffer using the specified ByteBuffer as its long data source.
      Parameters:
      source - the source buffer
    • sizeof

      public int sizeof()
      Description copied from class: CustomBuffer
      Returns the sizeof a single element in the buffer.
      Specified by:
      sizeof in class CustomBuffer<CLongBuffer>
    • 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:
      BufferUnderflowException - If the buffer's current position is not smaller than its limit
    • get

      public static long get(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:
      BufferOverflowException - If this buffer's current position is not smaller than its limit
    • put

      public static void put(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:
      IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
    • get

      public static long get(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:
      IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
    • put

      public static void put(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:
      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:
      BufferUnderflowException - If there are fewer than length longs remaining in this buffer
      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:
      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:
      BufferOverflowException - If there is insufficient space in this buffer
      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(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 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