Example #1
0
  /**
   * Copies numFloats floats from src starting at offset to dst. Dst is assumed to be a direct
   * {@link Buffer}. The method will crash if that is not the case. The position and limit of the
   * buffer are ignored, the copy is placed at position 0 in the buffer. After the copying process
   * the position of the buffer is set to 0 and its limit is set to numFloats * 4 if it is a
   * ByteBuffer and numFloats if it is a FloatBuffer. In case the Buffer is neither a ByteBuffer nor
   * a FloatBuffer the limit is not set. This is an expert method, use at your own risk.
   *
   * @param src the source array
   * @param dst the destination buffer, has to be a direct Buffer
   * @param numFloats the number of floats to copy
   * @param offset the offset in src to start copying from
   */
  public static void copy(float[] src, Buffer dst, int numFloats, int offset) {
    copyJni(src, dst, numFloats, offset);
    dst.position(0);

    if (dst instanceof ByteBuffer) dst.limit(numFloats << 2);
    else if (dst instanceof FloatBuffer) dst.limit(numFloats);
  }
Example #2
0
 /**
  * Copies the contents of src to dst, starting from src[srcOffset], copying numElements elements.
  * The {@link Buffer} instance's {@link Buffer#position()} is used to define the offset into the
  * Buffer itself. The position will stay the same, the limit will be set to position +
  * numElements. <b>The Buffer must be a direct Buffer with native byte order. No error checking is
  * performed</b>.
  *
  * @param src the source array.
  * @param srcOffset the offset into the source array.
  * @param dst the destination Buffer, its position is used as an offset.
  * @param numElements the number of elements to copy.
  */
 public static void copy(short[] src, int srcOffset, Buffer dst, int numElements) {
   copyJni(src, srcOffset << 1, dst, positionInBytes(dst), numElements << 1);
   dst.limit(dst.position() + bytesToElements(dst, numElements << 1));
 }
Example #3
0
 /**
  * Copies the contents of src to dst, starting from the current position of src, copying
  * numElements elements (using the data type of src, no matter the datatype of dst). The dst
  * {@link Buffer#position()} is used as the writing offset. The position of both Buffers will stay
  * the same. The limit of the src Buffer will stay the same. The limit of the dst Buffer will be
  * set to dst.position() + numElements, where numElements are translated to the number of elements
  * appropriate for the dst Buffer data type. <b>The Buffers must be direct Buffers with native
  * byte order. No error checking is performed</b>.
  *
  * @param src the source Buffer.
  * @param dst the destination Buffer.
  * @param numElements the number of elements to copy.
  */
 public static void copy(Buffer src, Buffer dst, int numElements) {
   int numBytes = elementsToBytes(src, numElements);
   copyJni(src, positionInBytes(src), dst, positionInBytes(dst), numBytes);
   dst.limit(dst.position() + bytesToElements(dst, numBytes));
 }
Example #4
0
 /**
  * Copies the contents of src to dst, starting from src[srcOffset], copying numElements elements.
  * The {@link Buffer} instance's {@link Buffer#position()} is used to define the offset into the
  * Buffer itself. The position and limit will stay the same. <b>The Buffer must be a direct Buffer
  * with native byte order. No error checking is performed</b>.
  *
  * @param src the source array.
  * @param srcOffset the offset into the source array.
  * @param numElements the number of elements to copy.
  * @param dst the destination Buffer, its position is used as an offset.
  */
 public static void copy(double[] src, int srcOffset, int numElements, Buffer dst) {
   copyJni(src, srcOffset << 3, dst, positionInBytes(dst), numElements << 3);
 }