/**
* 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);
}
/**
* 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));
}
/**
* 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));
}
/**
* 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);
}
