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