From 21217bbf0868cd7d2019de87de54ae23a77590b4 Mon Sep 17 00:00:00 2001
From: Chris Povirk This class defines {#if[byte]?six:four} categories of operations upon
+ * This class defines six categories of operations upon
* byte buffers:
*
*
@@ -42,16 +60,16 @@
* {@link #put(byte) put} methods that read and write
* single bytes;
Relative {@link #get(byte[]) bulk get} + *
Absolute and relative {@link #get(byte[]) bulk get} * methods that transfer contiguous sequences of bytes from this buffer - * into an array; {#if[!byte]?and}
Relative {@link #put(byte[]) bulk put} + *
Absolute and relative {@link #put(byte[]) bulk put} * methods that transfer contiguous sequences of bytes from a - * byte array{#if[char]?, a string,} or some other byte - * buffer into this buffer;{#if[!byte]? and}
Absolute and relative {@link #getChar() get} * and {@link #putChar(char) put} methods that read and @@ -62,7 +80,7 @@ * which allow a byte buffer to be viewed as a buffer containing values of * some other primitive type; and
A method for {@link #compact compacting} * a byte buffer.
Byte buffers can be created either by {@link #allocate * allocation}, which allocates space for the buffer's * -#if[byte] + * * content, or by {@link #wrap(byte[]) wrapping} an - * existing byte array {#if[char]?or string} into a buffer. - * -#else[byte] + * existing byte array into a buffer. * - * content, by {@link #wrap(byte[]) wrapping} an existing - * byte array {#if[char]?or string} into a buffer, or by creating a - * view of an existing byte buffer. - * -#end[byte] + + + + + + + * -#if[byte] + * * *
A direct byte buffer may also be created by {@link * java.nio.channels.FileChannel#map mapping} a region of a file @@ -138,11 +156,16 @@ * get and put methods for each type. For 32-bit floating-point * values, for example, this class defines: * - *
- * float {@link #getFloat()}
- * float {@link #getFloat(int) getFloat(int index)}
- * void {@link #putFloat(float) putFloat(float f)}
- * void {@link #putFloat(int,float) putFloat(int index, float f)}
+ * {@snippet lang=java :
+ * // @link substring="getFloat()" target="#getFloat" :
+ * float getFloat()
+ * // @link substring="getFloat(int index)" target="#getFloat(int)" :
+ * float getFloat(int index)
+ * // @link substring="putFloat(float f)" target="#putFloat(float)" :
+ * ByteBuffer putFloat(float f)
+ * // @link substring="putFloat(int index, float f)" target="#putFloat(int,float)" :
+ * ByteBuffer putFloat(int index, float f)
+ * }
*
* Corresponding methods are defined for the types {@code char, * short, int, long}, and {@code double}. The index @@ -182,79 +205,110 @@ *
The byte order of a view buffer is fixed to be that of its byte buffer * at the time that the view is created.
* -#end[byte] + * -#if[!byte] - * - *Like a byte buffer, a byte buffer is either direct or non-direct. A - * byte buffer created via the {@code wrap} methods of this class will - * be non-direct. A byte buffer created as a view of a byte buffer will - * be direct if, and only if, the byte buffer itself is direct. Whether or not - * a byte buffer is direct may be determined by invoking the {@link - * #isDirect isDirect} method.
- * -#end[!byte] + + + + + + + + + + + * -#if[char] - * - *This class implements the {@link CharSequence} interface so that - * character buffers may be used wherever character sequences are accepted, for - * example in the regular-expression package {@link java.util.regex}. - *
- * -#end[char] + + + + + + + + + + * -#if[byte] + *Methods in this class that do not otherwise have a value to return are * specified to return the buffer upon which they are invoked. This allows * method invocations to be chained. * -#if[byte] - * - * The sequence of statements - * - *
- * - * can, for example, be replaced by the single statement - * - *- * bb.putInt(0xCAFEBABE); - * bb.putShort(3); - * bb.putShort(45);
- * -#end[byte] -#if[char] + * * The sequence of statements * - *- * bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
- * cb.put("text/");
- * cb.put(subtype);
- * cb.put("; charset=");
- * cb.put(enc);
+ * {@snippet lang=java :
+ * bb.putInt(0xCAFEBABE);
+ * bb.putShort(3);
+ * bb.putShort(45);
+ * }
*
* can, for example, be replaced by the single statement
*
- *
- * cb.put("text/").put(subtype).put("; charset=").put(enc);
+ * {@snippet lang=java :
+ * bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
+ * }
*
-#end[char]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ * The new buffer's position will be zero, its limit will be its * capacity, its mark will be undefined, each of its elements will be * initialized to zero, and its byte order will be -#if[byte] + * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. -#else[byte] - * the {@link ByteOrder#nativeOrder native order} of the underlying - * hardware. -#end[byte] + + + + * It will have a {@link #array backing array}, and its * {@link #arrayOffset array offset} will be zero. * @@ -335,7 +399,7 @@ public static ByteBuffer allocateDirect(int capacity) { public static ByteBuffer allocate(int capacity) { if (capacity < 0) throw createCapacityException(capacity); - return new HeapByteBuffer(capacity, capacity); + return new HeapByteBuffer(capacity, capacity, null); } /** @@ -347,12 +411,12 @@ public static ByteBuffer allocate(int capacity) { * {@code array.length}, its position will be {@code offset}, its limit * will be {@code offset + length}, its mark will be undefined, and its * byte order will be -#if[byte] + * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. -#else[byte] - * the {@link ByteOrder#nativeOrder native order} of the underlying - * hardware. -#end[byte] + + + + * Its {@link #array backing array} will be the given array, and * its {@link #arrayOffset array offset} will be zero.
* @@ -380,7 +444,7 @@ public static ByteBuffer wrap(byte[] array, int offset, int length) { try { - return new HeapByteBuffer(array, offset, length); + return new HeapByteBuffer(array, offset, length, null); } catch (IllegalArgumentException x) { throw new IndexOutOfBoundsException(); } @@ -394,12 +458,12 @@ public static ByteBuffer wrap(byte[] array, * and vice versa. The new buffer's capacity and limit will be * {@code array.length}, its position will be zero, its mark will be * undefined, and its byte order will be -#if[byte] + * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. -#else[byte] - * the {@link ByteOrder#nativeOrder native order} of the underlying - * hardware. -#end[byte] + + + + * Its {@link #array backing array} will be the given array, and its * {@link #arrayOffset array offset} will be zero. * @@ -413,6 +477,108 @@ public static ByteBuffer wrap(byte[] array) { } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** * Creates a new byte buffer whose content is a shared subsequence of * this buffer's content. @@ -425,23 +591,63 @@ public static ByteBuffer wrap(byte[] array) { *The new buffer's position will be zero, its capacity and its limit * will be the number of bytes remaining in this buffer, its mark will be * undefined, and its byte order will be -#if[byte] + * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. -#else[byte] - * identical to that of this buffer. -#end[byte] + + + * The new buffer will be direct if, and only if, this buffer is direct, and * it will be read-only if, and only if, this buffer is read-only.
* * @return The new byte buffer -#if[byte] + * * @see #alignedSlice(int) -#end[byte] + */ @Override public abstract ByteBuffer slice(); + /** + * Creates a new byte buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at position {@code index} + * in this buffer, and will contain {@code length} elements. Changes to + * this buffer's content will be visible in the new buffer, and vice versa; + * the two buffers' position, limit, and mark values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be {@code length}, its mark will be undefined, and its byte order + * will be + + * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. + + + + * The new buffer will be direct if, and only if, this buffer is direct, + * and it will be read-only if, and only if, this buffer is read-only.
+ * + * @param index + * The position in this buffer at which the content of the new + * buffer will start; must be non-negative and no larger than + * {@link #limit() limit()} + * + * @param length + * The number of elements the new buffer will contain; must be + * non-negative and no larger than {@code limit() - index} + * + * @return The new buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative or greater than {@code limit()}, + * {@code length} is negative, or {@code length > limit() - index} + * + * @since 13 + */ + @Override + public abstract ByteBuffer slice(int index, int length); + /** * Creates a new byte buffer that shares this buffer's content. * @@ -451,12 +657,12 @@ public static ByteBuffer wrap(byte[] array) { * independent. * *The new buffer's capacity, limit, position, -#if[byte] + * and mark values will be identical to those of this buffer, and its byte * order will be {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. -#else[byte] - * mark values, and byte order will be identical to those of this buffer. -#end[byte] + + + * The new buffer will be direct if, and only if, this buffer is direct, and * it will be read-only if, and only if, this buffer is read-only.
* @@ -476,12 +682,12 @@ public static ByteBuffer wrap(byte[] array) { * values will be independent. * *The new buffer's capacity, limit, position, -#if[byte] + * and mark values will be identical to those of this buffer, and its byte * order will be {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. -#else[byte] - * mark values, and byte order will be identical to those of this buffer. -#end[byte] + + + * *
If this buffer is itself read-only then this method behaves in * exactly the same way as the {@link #duplicate duplicate} method.
@@ -510,7 +716,7 @@ public static ByteBuffer wrap(byte[] array) { *Writes the given byte into this buffer at the current * position, and then increments the position.
* - * @param $x$ + * @param b * The byte to be written * * @return This buffer @@ -521,7 +727,7 @@ public static ByteBuffer wrap(byte[] array) { * @throws ReadOnlyBufferException * If this buffer is read-only */ - public abstract ByteBuffer put(byte $x$); + public abstract ByteBuffer put(byte b); /** * Absolute get method. Reads the byte at the given @@ -539,16 +745,28 @@ public static ByteBuffer wrap(byte[] array) { public abstract byte get(int index); - /** - * Absolute put method (optional operation). - * - *Writes the given byte into this buffer at the given - * index.
- * + + + + + + + + + + + + + /** + * Absolute put method (optional operation). + * + *Writes the given byte into this buffer at the given + * index.
+ * * @param index * The index at which the byte will be written * - * @param $x$ + * @param b * The byte value to be written * * @return This buffer @@ -560,7 +778,7 @@ public static ByteBuffer wrap(byte[] array) { * @throws ReadOnlyBufferException * If this buffer is read-only */ - public abstract ByteBuffer put(int index, byte $x$); + public abstract ByteBuffer put(int index, byte b); // -- Bulk get operations -- @@ -584,10 +802,10 @@ public static ByteBuffer wrap(byte[] array) { *src.get(dst, off, len) has exactly the same effect as
* the loop
*
- * {@code
+ * {@snippet lang=java :
* for (int i = off; i < off + len; i++)
* dst[i] = src.get();
- * }
+ * }
*
* except that it first checks that there are sufficient bytes in
* this buffer and it is potentially much more efficient.
@@ -616,12 +834,14 @@ public static ByteBuffer wrap(byte[] array) {
* parameters do not hold
*/
public ByteBuffer get(byte[] dst, int offset, int length) {
- checkBounds(offset, length, dst.length);
- if (length > remaining())
+ Objects.checkFromIndexSize(offset, length, dst.length);
+ int pos = position();
+ if (length > limit() - pos)
throw new BufferUnderflowException();
- int end = offset + length;
- for (int i = offset; i < end; i++)
- dst[i] = get();
+
+ getArray(pos, dst, offset, length);
+
+ position(pos + length);
return this;
}
@@ -632,8 +852,9 @@ public ByteBuffer get(byte[] dst, int offset, int length) {
* destination array. An invocation of this method of the form
* {@code src.get(a)} behaves in exactly the same way as the invocation
*
- * - * src.get(a, 0, a.length)+ * {@snippet lang=java : + * src.get(a, 0, a.length) + * } * * @param dst * The destination array @@ -648,6 +869,127 @@ public ByteBuffer get(byte[] dst) { return get(dst, 0, dst.length); } + /** + * Absolute bulk get method. + * + *
This method transfers {@code length} bytes from this + * buffer into the given array, starting at the given index in this + * buffer and at the given offset in the array. The position of this + * buffer is unchanged. + * + *
An invocation of this method of the form
+ * src.get(index, dst, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst[i] = src.get(j);
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first byte will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @param offset
+ * The offset within the array of the first byte to be
+ * written; must be non-negative and less than
+ * {@code dst.length}
+ *
+ * @param length
+ * The number of bytes to be written to the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @since 13
+ */
+ public ByteBuffer get(int index, byte[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, dst.length);
+
+ getArray(index, dst, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk get method.
+ *
+ *
This method transfers bytes from this buffer into the given
+ * destination array. The position of this buffer is unchanged. An
+ * invocation of this method of the form
+ * src.get(index, dst) behaves in exactly the same
+ * way as the invocation:
+ *
+ * {@snippet lang=java :
+ * src.get(index, dst, 0, dst.length)
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first byte will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < dst.length}
+ *
+ * @since 13
+ */
+ public ByteBuffer get(int index, byte[] dst) {
+ return get(index, dst, 0, dst.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ ByteBuffer getArray(int index, byte[] dst, int offset, int length) {
+
+
+
+ if (((long)length << 0) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 0);
+ long dstOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 0);
+ long len = (long)length << 0;
+
+ try {
+
+
+
+
+
+
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++) {
+ dst[i] = get(j);
+ }
+ }
+ return this;
+ }
// -- Bulk put operations --
@@ -669,12 +1011,16 @@ public ByteBuffer get(byte[] dst) {
*
In other words, an invocation of this method of the form * {@code dst.put(src)} has exactly the same effect as the loop * - *
+ * {@snippet lang=java :
* while (src.hasRemaining())
- * dst.put(src.get());
+ * dst.put(src.get());
+ * }
*
* except that it first checks that there is sufficient space in this
- * buffer and it is potentially much more efficient.
+ * buffer and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
*
* @param src
* The source buffer from which bytes are to be read;
@@ -697,12 +1043,136 @@ public ByteBuffer put(ByteBuffer src) {
throw createSameBufferException();
if (isReadOnly())
throw new ReadOnlyBufferException();
- int n = src.remaining();
- if (n > remaining())
+
+ int srcPos = src.position();
+ int srcLim = src.limit();
+ int srcRem = (srcPos <= srcLim ? srcLim - srcPos : 0);
+ int pos = position();
+ int lim = limit();
+ int rem = (pos <= lim ? lim - pos : 0);
+
+ if (srcRem > rem)
throw new BufferOverflowException();
- for (int i = 0; i < n; i++)
- put(src.get());
+
+ putBuffer(pos, src, srcPos, srcRem);
+
+ position(pos + srcRem);
+ src.position(srcPos + srcRem);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk put method (optional operation).
+ *
+ * This method transfers {@code length} bytes into this buffer from + * the given source buffer, starting at the given {@code offset} in the + * source buffer and the given {@code index} in this buffer. The positions + * of both buffers are unchanged. + * + *
In other words, an invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src.get(i));
+ * }
+ *
+ * except that it first checks the consistency of the supplied parameters
+ * and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
+ *
+ * @param index
+ * The index in this buffer at which the first byte will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The buffer from which bytes are to be read
+ *
+ * @param offset
+ * The index within the source buffer of the first byte to be
+ * read; must be non-negative and less than {@code src.limit()}
+ *
+ * @param length
+ * The number of bytes to be read from the given buffer;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.limit() - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 16
+ */
+ public ByteBuffer put(int index, ByteBuffer src, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.limit());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+
+ putBuffer(index, src, offset, length);
+
return this;
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ void putBuffer(int pos, ByteBuffer src, int srcPos, int n) {
+
+ Object srcBase = src.base();
+
+
+
+ assert srcBase != null || src.isDirect();
+
+
+ Object base = base();
+ assert base != null || isDirect();
+
+ long srcAddr = src.address + ((long)srcPos << 0);
+ long addr = address + ((long)pos << 0);
+ long len = (long)n << 0;
+
+ try {
+
+
+
+
+
+
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len);
+ } finally {
+ Reference.reachabilityFence(src);
+ Reference.reachabilityFence(this);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
}
/**
@@ -724,10 +1194,10 @@ public ByteBuffer put(ByteBuffer src) {
* dst.put(src, off, len) has exactly the same effect as
* the loop
*
- *
{@code
+ * {@snippet lang=java :
* for (int i = off; i < off + len; i++)
- * dst.put(a[i]);
- * }
+ * dst.put(src[i]);
+ * }
*
* except that it first checks that there is sufficient space in this
* buffer and it is potentially much more efficient.
@@ -737,12 +1207,12 @@ public ByteBuffer put(ByteBuffer src) {
*
* @param offset
* The offset within the array of the first byte to be read;
- * must be non-negative and no larger than {@code array.length}
+ * must be non-negative and no larger than {@code src.length}
*
* @param length
* The number of bytes to be read from the given array;
* must be non-negative and no larger than
- * {@code array.length - offset}
+ * {@code src.length - offset}
*
* @return This buffer
*
@@ -757,12 +1227,16 @@ public ByteBuffer put(ByteBuffer src) {
* If this buffer is read-only
*/
public ByteBuffer put(byte[] src, int offset, int length) {
- checkBounds(offset, length, src.length);
- if (length > remaining())
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(offset, length, src.length);
+ int pos = position();
+ if (length > limit() - pos)
throw new BufferOverflowException();
- int end = offset + length;
- for (int i = offset; i < end; i++)
- this.put(src[i]);
+
+ putArray(pos, src, offset, length);
+
+ position(pos + length);
return this;
}
@@ -774,8 +1248,9 @@ public ByteBuffer put(byte[] src, int offset, int length) {
* form {@code dst.put(a)} behaves in exactly the same way as the
* invocation
*
- * - * dst.put(a, 0, a.length)+ * {@snippet lang=java : + * dst.put(a, 0, a.length) + * } * * @param src * The source array @@ -792,107 +1267,343 @@ public final ByteBuffer put(byte[] src) { return put(src, 0, src.length); } - - - // -- Other stuff -- - /** - * Tells whether or not this buffer is backed by an accessible byte - * array. + * Absolute bulk put method (optional operation). * - *
If this method returns {@code true} then the {@link #array() array} - * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. - *
+ *This method transfers {@code length} bytes from the given + * array, starting at the given offset in the array and at the given index + * in this buffer. The position of this buffer is unchanged. * - * @return {@code true} if, and only if, this buffer - * is backed by an array and is not read-only - */ - public final boolean hasArray() { - return (hb != null) && !isReadOnly; - } - - /** - * Returns the byte array that backs this - * buffer (optional operation). + *
An invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
*
- *
Modifications to this buffer's content will cause the returned - * array's content to be modified, and vice versa. + * {@snippet lang=java : + * for (int i = offset, j = index; i < offset + length; i++, j++) + * dst.put(j, src[i]); + * } * - *
Invoke the {@link #hasArray hasArray} method before invoking this - * method in order to ensure that this buffer has an accessible backing - * array.
+ * @param index + * The index in this buffer at which the first byte will be + * written; must be non-negative and less than {@code limit()} * - * @return The array that backs this buffer + * @param src + * The array from which bytes are to be read + * + * @param offset + * The offset within the array of the first byte to be read; + * must be non-negative and less than {@code src.length} + * + * @param length + * The number of bytes to be read from the given array; + * must be non-negative and no larger than the smaller of + * {@code limit() - index} and {@code src.length - offset} + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code index}, {@code offset}, and + * {@code length} parameters do not hold * * @throws ReadOnlyBufferException - * If this buffer is backed by an array but is read-only + * If this buffer is read-only * - * @throws UnsupportedOperationException - * If this buffer is not backed by an accessible array + * @since 13 */ - public final byte[] array() { - if (hb == null) - throw new UnsupportedOperationException(); - if (isReadOnly) + public ByteBuffer put(int index, byte[] src, int offset, int length) { + if (isReadOnly()) throw new ReadOnlyBufferException(); - return hb; + Objects.checkFromIndexSize(index, length, limit()); + Objects.checkFromIndexSize(offset, length, src.length); + + putArray(index, src, offset, length); + + return this; } /** - * Returns the offset within this buffer's backing array of the first - * element of the buffer (optional operation). + * Absolute bulk put method (optional operation). * - *If this buffer is backed by an array then buffer position p - * corresponds to array index p + {@code arrayOffset()}. + *
This method copies bytes into this buffer from the given source
+ * array. The position of this buffer is unchanged. An invocation of this
+ * method of the form dst.put(index, src)
+ * behaves in exactly the same way as the invocation:
*
- *
Invoke the {@link #hasArray hasArray} method before invoking this - * method in order to ensure that this buffer has an accessible backing - * array.
+ * {@snippet lang=java : + * dst.put(index, src, 0, src.length); + * } * - * @return The offset within this buffer's array - * of the first element of the buffer + * @param index + * The index in this buffer at which the first byte will be + * written; must be non-negative and less than {@code limit()} + * + * @param src + * The array from which bytes are to be read + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative, not smaller than {@code limit()}, + * or {@code limit() - index < src.length} * * @throws ReadOnlyBufferException - * If this buffer is backed by an array but is read-only + * If this buffer is read-only * - * @throws UnsupportedOperationException - * If this buffer is not backed by an accessible array + * @since 13 */ - public final int arrayOffset() { - if (hb == null) - throw new UnsupportedOperationException(); - if (isReadOnly) - throw new ReadOnlyBufferException(); - return offset; + public ByteBuffer put(int index, byte[] src) { + return put(index, src, 0, src.length); } - // -- Covariant return type overrides + // + // This method does not perform bounds checking which it expects + // will have been done by the caller + // + ByteBuffer putArray(int index, byte[] src, int offset, int length) { - /** - * {@inheritDoc} - */ - @Override - public - ByteBuffer position(int newPosition) { - super.position(newPosition); + if ( + + + + ((long)length << 0) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) { + long bufAddr = address + ((long)index << 0); + long srcOffset = + ARRAY_BASE_OFFSET + ((long)offset << 0); + long len = (long)length << 0; + + try { + + + + + + + + SCOPED_MEMORY_ACCESS.copyMemory( + null, session(), src, srcOffset, + base(), bufAddr, len); + } finally { + Reference.reachabilityFence(this); + } + } else { + int end = offset + length; + for (int i = offset, j = index; i < end; i++, j++) + this.put(j, src[i]); + } return this; + + + } - - /** - * {@inheritDoc} - */ - @Override - public + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // -- Other stuff -- + + /** + * Tells whether or not this buffer is backed by an accessible byte + * array. + * + *If this method returns {@code true} then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *
+ * + * @return {@code true} if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the byte array that backs this + * buffer (optional operation). + * + *Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final byte[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer (optional operation). + * + *If this buffer is backed by an array then buffer position p + * corresponds to array index p + {@code arrayOffset()}. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + // -- Covariant return type overrides + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + + + ByteBuffer position(int newPosition) { + super.position(newPosition); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + + ByteBuffer limit(int newLimit) { super.limit(newLimit); return this; } - + /** * {@inheritDoc} + * @since 9 */ @Override - public + public + + + ByteBuffer mark() { super.mark(); return this; @@ -900,9 +1611,13 @@ ByteBuffer mark() { /** * {@inheritDoc} + * @since 9 */ @Override - public + public + + + ByteBuffer reset() { super.reset(); return this; @@ -910,9 +1625,13 @@ ByteBuffer reset() { /** * {@inheritDoc} + * @since 9 */ @Override - public + public + + + ByteBuffer clear() { super.clear(); return this; @@ -920,9 +1639,13 @@ ByteBuffer clear() { /** * {@inheritDoc} + * @since 9 */ @Override - public + public + + + ByteBuffer flip() { super.flip(); return this; @@ -930,9 +1653,13 @@ ByteBuffer flip() { /** * {@inheritDoc} + * @since 9 */ @Override - public + public + + + ByteBuffer rewind() { super.rewind(); return this; @@ -956,22 +1683,22 @@ ByteBuffer rewind() { * followed immediately by an invocation of another relative put * method. * -#if[byte] + * *Invoke this method after writing data from a buffer in case the * write was incomplete. The following loop, for example, copies bytes * from one channel to another via the buffer {@code buf}: * - *
{@code
- * buf.clear(); // Prepare buffer for use
- * while (in.read(buf) >= 0 || buf.position != 0) {
- * buf.flip();
- * out.write(buf);
- * buf.compact(); // In case of partial write
- * }
- * }
+ * {@snippet lang=java :
+ * buf.clear(); // Prepare buffer for use
+ * while (in.read(buf) >= 0 || buf.position != 0) {
+ * buf.flip();
+ * out.write(buf);
+ * buf.compact(); // In case of partial write
+ * }
+ * }
*
-#end[byte]
+
*
* @return This buffer
*
@@ -988,27 +1715,38 @@ ByteBuffer rewind() {
public abstract boolean isDirect();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
/**
* Returns a string summarizing the state of this buffer.
*
* @return A summary string
*/
public String toString() {
- StringBuffer sb = new StringBuffer();
- sb.append(getClass().getName());
- sb.append("[pos=");
- sb.append(position());
- sb.append(" lim=");
- sb.append(limit());
- sb.append(" cap=");
- sb.append(capacity());
- sb.append("]");
- return sb.toString();
+ return getClass().getName()
+ + "[pos=" + position()
+ + " lim=" + limit()
+ + " cap=" + capacity()
+ + "]";
}
- // ## Should really use unchecked accessors here for speed
+
+
/**
* Returns the current hash code of this buffer.
@@ -1027,7 +1765,11 @@ public int hashCode() {
int h = 1;
int p = position();
for (int i = limit() - 1; i >= p; i--)
+
+
+
h = 31 * h + (int)get(i);
+
return h;
}
@@ -1045,13 +1787,13 @@ public int hashCode() {
*
* The two sequences of remaining elements, considered * independently of their starting positions, are pointwise equal. -#if[floatingPointType] - * This method considers two byte elements {@code a} and {@code b} - * to be equal if - * {@code (a == b) || (Byte.isNaN(a) && Byte.isNaN(b))}. - * The values {@code -0.0} and {@code +0.0} are considered to be - * equal, unlike {@link Byte#equals(Object)}. -#end[floatingPointType] + + + + + + + *
Two byte buffers are compared by comparing their sequences of * remaining elements lexicographically, without regard to the starting * position of each sequence within its corresponding buffer. -#if[floatingPointType] - * Pairs of {@code byte} elements are compared as if by invoking - * {@link Byte#compare(byte,byte)}, except that - * {@code -0.0} and {@code 0.0} are considered to be equal. - * {@code Byte.NaN} is considered by this method to be equal - * to itself and greater than all other {@code byte} values - * (including {@code Byte.POSITIVE_INFINITY}). -#else[floatingPointType] - * Pairs of {@code byte} elements are compared as if by invoking - * {@link Byte#compare(byte,byte)}. -#end[floatingPointType] - * - *
A byte buffer is not comparable to any other type of object. - * - * @return A negative integer, zero, or a positive integer as this buffer + + + + + + + + + * Pairs of {@code byte} elements are compared as if by invoking + * {@link Byte#compare(byte,byte)}. + + * + *
A byte buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer * is less than, equal to, or greater than the given buffer */ public int compareTo(ByteBuffer that) { - int i = BufferMismatch.mismatch(this, this.position(), - that, that.position(), - Math.min(this.remaining(), that.remaining())); + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int i = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); if (i >= 0) { - return compare(this.get(this.position() + i), that.get(that.position() + i)); + return compare(this.get(thisPos + i), that.get(thatPos + i)); } - return this.remaining() - that.remaining(); + return thisRem - thatRem; } private static int compare(byte x, byte y) { + + + + + + return Byte.compare(x, y); + } /** @@ -1138,199 +1898,1093 @@ private static int compare(byte x, byte y) { * @since 11 */ public int mismatch(ByteBuffer that) { - int length = Math.min(this.remaining(), that.remaining()); - int r = BufferMismatch.mismatch(this, this.position(), - that, that.position(), + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int r = BufferMismatch.mismatch(this, thisPos, + that, thatPos, length); - return (r == -1 && this.remaining() != that.remaining()) ? length : r; + return (r == -1 && thisRem != thatRem) ? length : r; } // -- Other char stuff -- - // -- Other byte stuff: Access to binary data -- - boolean bigEndian // package-private - = true; - boolean nativeByteOrder // package-private - = (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN); - /** - * Retrieves this buffer's byte order. - * - *
The byte order is used when reading or writing multibyte values, and - * when creating buffers that are views of this byte buffer. The order of - * a newly-created byte buffer is always {@link ByteOrder#BIG_ENDIAN - * BIG_ENDIAN}.
- * - * @return This buffer's byte order - */ - public final ByteOrder order() { - return bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN; - } - /** - * Modifies this buffer's byte order. - * - * @param bo - * The new byte order, - * either {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN} - * or {@link ByteOrder#LITTLE_ENDIAN LITTLE_ENDIAN} - * - * @return This buffer - */ - public final ByteBuffer order(ByteOrder bo) { - bigEndian = (bo == ByteOrder.BIG_ENDIAN); - nativeByteOrder = - (bigEndian == (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)); - return this; - } - /** - * Returns the memory address, pointing to the byte at the given index, - * modulus the given unit size. - * - *A return value greater than zero indicates the address of the byte at - * the index is misaligned for the unit size, and the value's quantity - * indicates how much the index should be rounded up or down to locate a - * byte at an aligned address. Otherwise, a value of {@code 0} indicates - * that the address of the byte at the index is aligned for the unit size. - * - * @apiNote - * This method may be utilized to determine if unit size bytes from an - * index can be accessed atomically, if supported by the native platform. - * - * @implNote - * This implementation throws {@code UnsupportedOperationException} for - * non-direct buffers when the given unit size is greater then {@code 8}. - * - * @param index - * The index to query for alignment offset, must be non-negative, no - * upper bounds check is performed - * - * @param unitSize - * The unit size in bytes, must be a power of {@code 2} - * - * @return The indexed byte's memory address modulus the unit size - * - * @throws IllegalArgumentException - * If the index is negative or the unit size is not a power of - * {@code 2} - * - * @throws UnsupportedOperationException - * If the native platform does not guarantee stable alignment offset - * values for the given unit size when managing the memory regions - * of buffers of the same kind as this buffer (direct or - * non-direct). For example, if garbage collection would result - * in the moving of a memory region covered by a non-direct buffer - * from one location to another and both locations have different - * alignment characteristics. - * - * @see #alignedSlice(int) - * @since 9 - */ - public final int alignmentOffset(int index, int unitSize) { - if (index < 0) - throw new IllegalArgumentException("Index less than zero: " + index); - if (unitSize < 1 || (unitSize & (unitSize - 1)) != 0) - throw new IllegalArgumentException("Unit size not a power of two: " + unitSize); - if (unitSize > 8 && !isDirect()) - throw new UnsupportedOperationException("Unit size unsupported for non-direct buffers: " + unitSize); - return (int) ((address + index) % unitSize); - } - /** - * Creates a new byte buffer whose content is a shared and aligned - * subsequence of this buffer's content. - * - *
The content of the new buffer will start at this buffer's current - * position rounded up to the index of the nearest aligned byte for the - * given unit size, and end at this buffer's limit rounded down to the index - * of the nearest aligned byte for the given unit size. - * If rounding results in out-of-bound values then the new buffer's capacity - * and limit will be zero. If rounding is within bounds the following - * expressions will be true for a new buffer {@code nb} and unit size - * {@code unitSize}: - *
{@code
- * nb.alignmentOffset(0, unitSize) == 0
- * nb.alignmentOffset(nb.limit(), unitSize) == 0
- * }
- *
- * Changes to this buffer's content will be visible in the new - * buffer, and vice versa; the two buffers' position, limit, and mark - * values will be independent. - * - *
The new buffer's position will be zero, its capacity and its limit - * will be the number of bytes remaining in this buffer or fewer subject to - * alignment, its mark will be undefined, and its byte order will be - * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. - * - * The new buffer will be direct if, and only if, this buffer is direct, and - * it will be read-only if, and only if, this buffer is read-only.
- * - * @apiNote - * This method may be utilized to create a new buffer where unit size bytes - * from index, that is a multiple of the unit size, may be accessed - * atomically, if supported by the native platform. - * - * @implNote - * This implementation throws {@code UnsupportedOperationException} for - * non-direct buffers when the given unit size is greater then {@code 8}. - * - * @param unitSize - * The unit size in bytes, must be a power of {@code 2} - * - * @return The new byte buffer - * - * @throws IllegalArgumentException - * If the unit size not a power of {@code 2} - * - * @throws UnsupportedOperationException - * If the native platform does not guarantee stable aligned slices - * for the given unit size when managing the memory regions - * of buffers of the same kind as this buffer (direct or - * non-direct). For example, if garbage collection would result - * in the moving of a memory region covered by a non-direct buffer - * from one location to another and both locations have different - * alignment characteristics. - * - * @see #alignmentOffset(int, int) - * @see #slice() - * @since 9 - */ - public final ByteBuffer alignedSlice(int unitSize) { - int pos = position(); - int lim = limit(); - int pos_mod = alignmentOffset(pos, unitSize); - int lim_mod = alignmentOffset(lim, unitSize); - // Round up the position to align with unit size - int aligned_pos = (pos_mod > 0) - ? pos + (unitSize - pos_mod) - : pos; - // Round down the limit to align with unit size - int aligned_lim = lim - lim_mod; - if (aligned_pos > lim || aligned_lim < pos) { - aligned_pos = aligned_lim = pos; - } - return slice(aligned_pos, aligned_lim); - } - abstract ByteBuffer slice(int pos, int lim); - // #BIN - // - // Binary-data access methods for short, char, int, long, float, - // and double will be inserted here + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // -- Other byte stuff: Access to binary data -- + + + + + + + + + + + + + + + + + + + + + + + + + + + + boolean bigEndian // package-private + = true; + boolean nativeByteOrder // package-private + = (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN); + + /** + * Retrieves this buffer's byte order. + * + *The byte order is used when reading or writing multibyte values, and + * when creating buffers that are views of this byte buffer. The order of + * a newly-created byte buffer is always {@link ByteOrder#BIG_ENDIAN + * BIG_ENDIAN}.
+ * + * @return This buffer's byte order + */ + public final ByteOrder order() { + return bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN; + } + + /** + * Modifies this buffer's byte order. + * + * @param bo + * The new byte order, + * either {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN} + * or {@link ByteOrder#LITTLE_ENDIAN LITTLE_ENDIAN} + * + * @return This buffer + */ + public final ByteBuffer order(ByteOrder bo) { + bigEndian = (bo == ByteOrder.BIG_ENDIAN); + nativeByteOrder = + (bigEndian == (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)); + return this; + } + + /** + * Returns the memory address, pointing to the byte at the given index, + * modulo the given unit size. + * + *The return value is non-negative in the range of {@code 0} + * (inclusive) up to {@code unitSize} (exclusive), with zero indicating + * that the address of the byte at the index is aligned for the unit size, + * and a positive value that the address is misaligned for the unit size. + * If the address of the byte at the index is misaligned, the return value + * represents how much the index should be adjusted to locate a byte at an + * aligned address. Specifically, the index should either be decremented by + * the return value if the latter is not greater than {@code index}, or be + * incremented by the unit size minus the return value. Therefore given + * {@snippet lang=java : + * int value = alignmentOffset(index, unitSize) + * } + * then the identities + * {@snippet lang=java : + * alignmentOffset(index - value, unitSize) == 0, value <= index + * } + * and + * {@snippet lang=java : + * alignmentOffset(index + (unitSize - value), unitSize) == 0 + * } + * must hold. + * + * @apiNote + * This method may be utilized to determine if unit size bytes from an + * index can be accessed atomically, if supported by the native platform. + * + * @param index + * The index to query for alignment offset, must be non-negative, no + * upper bounds check is performed + * + * @param unitSize + * The unit size in bytes, must be a power of {@code 2} + * + * @return The indexed byte's memory address modulo the unit size + * + * @throws IllegalArgumentException + * If the index is negative or the unit size is not a power of + * {@code 2} + * + * @throws UnsupportedOperationException + * If the buffer is non-direct, and {@code unitSize > 1} + * + * @see #alignedSlice(int) + * @since 9 + */ + public final int alignmentOffset(int index, int unitSize) { + if (index < 0) + throw new IllegalArgumentException("Index less than zero: " + index); + if (unitSize < 1 || (unitSize & (unitSize - 1)) != 0) + throw new IllegalArgumentException("Unit size not a power of two: " + unitSize); + if (unitSize > 1 && !isDirect()) + throw new UnsupportedOperationException("Unit size unsupported for non-direct buffers: " + unitSize); + + return (int) ((address + index) & (unitSize - 1)); + } + + /** + * Creates a new byte buffer whose content is a shared and aligned + * subsequence of this buffer's content. + * + *
The content of the new buffer will start at this buffer's current + * position rounded up to the index of the nearest aligned byte for the + * given unit size, and end at this buffer's limit rounded down to the index + * of the nearest aligned byte for the given unit size. + * If rounding results in out-of-bound values then the new buffer's capacity + * and limit will be zero. If rounding is within bounds the following + * expressions will be true for a new buffer {@code nb} and unit size + * {@code unitSize}: + * {@snippet lang=java : + * nb.alignmentOffset(0, unitSize) == 0 + * nb.alignmentOffset(nb.limit(), unitSize) == 0 + * } + * + *
Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer or fewer subject to + * alignment, its mark will be undefined, and its byte order will be + * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. + * + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @apiNote + * This method may be utilized to create a new buffer where unit size bytes + * from index, that is a multiple of the unit size, may be accessed + * atomically, if supported by the native platform. + * + * @param unitSize + * The unit size in bytes, must be a power of {@code 2} + * + * @return The new byte buffer + * + * @throws IllegalArgumentException + * If the unit size not a power of {@code 2} + * + * @throws UnsupportedOperationException + * If the buffer is non-direct, and {@code unitSize > 1} + * + * @see #alignmentOffset(int, int) + * @see #slice() + * @since 9 + */ + public final ByteBuffer alignedSlice(int unitSize) { + int pos = position(); + int lim = limit(); + + int pos_mod = alignmentOffset(pos, unitSize); + int lim_mod = alignmentOffset(lim, unitSize); + + // Round up the position to align with unit size + int aligned_pos = (pos_mod > 0) + ? pos + (unitSize - pos_mod) + : pos; + + // Round down the limit to align with unit size + int aligned_lim = lim - lim_mod; + + if (aligned_pos > lim || aligned_lim < pos) { + aligned_pos = aligned_lim = pos; + } + + return slice(aligned_pos, aligned_lim - aligned_pos); + } + + + /** + * Relative get method for reading a char value. + * + *Reads the next two bytes at this buffer's current position, + * composing them into a char value according to the current byte order, + * and then increments the position by two.
+ * + * @return The char value at the buffer's current position + * + * @throws BufferUnderflowException + * If there are fewer than two bytes + * remaining in this buffer + */ + public abstract char getChar(); + + /** + * Relative put method for writing a char + * value (optional operation). + * + *Writes two bytes containing the given char value, in the + * current byte order, into this buffer at the current position, and then + * increments the position by two.
+ * + * @param value + * The char value to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If there are fewer than two bytes + * remaining in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putChar(char value); + + /** + * Absolute get method for reading a char value. + * + *Reads two bytes at the given index, composing them into a + * char value according to the current byte order.
+ * + * @param index + * The index from which the bytes will be read + * + * @return The char value at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus one + */ + public abstract char getChar(int index); + + /** + * Absolute put method for writing a char + * value (optional operation). + * + *Writes two bytes containing the given char value, in the + * current byte order, into this buffer at the given index.
+ * + * @param index + * The index at which the bytes will be written + * + * @param value + * The char value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus one + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putChar(int index, char value); + + /** + * Creates a view of this byte buffer as a char buffer. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer divided by + * two, its mark will be undefined, and its byte order will be that + * of the byte buffer at the moment the view is created. The new buffer + * will be direct if, and only if, this buffer is direct, and it will be + * read-only if, and only if, this buffer is read-only.
+ * + * @return A new char buffer + */ + public abstract CharBuffer asCharBuffer(); + + + /** + * Relative get method for reading a short value. + * + *Reads the next two bytes at this buffer's current position, + * composing them into a short value according to the current byte order, + * and then increments the position by two.
+ * + * @return The short value at the buffer's current position + * + * @throws BufferUnderflowException + * If there are fewer than two bytes + * remaining in this buffer + */ + public abstract short getShort(); + + /** + * Relative put method for writing a short + * value (optional operation). + * + *Writes two bytes containing the given short value, in the + * current byte order, into this buffer at the current position, and then + * increments the position by two.
+ * + * @param value + * The short value to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If there are fewer than two bytes + * remaining in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putShort(short value); + + /** + * Absolute get method for reading a short value. + * + *Reads two bytes at the given index, composing them into a + * short value according to the current byte order.
+ * + * @param index + * The index from which the bytes will be read + * + * @return The short value at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus one + */ + public abstract short getShort(int index); + + /** + * Absolute put method for writing a short + * value (optional operation). + * + *Writes two bytes containing the given short value, in the + * current byte order, into this buffer at the given index.
+ * + * @param index + * The index at which the bytes will be written + * + * @param value + * The short value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus one + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putShort(int index, short value); + + /** + * Creates a view of this byte buffer as a short buffer. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer divided by + * two, its mark will be undefined, and its byte order will be that + * of the byte buffer at the moment the view is created. The new buffer + * will be direct if, and only if, this buffer is direct, and it will be + * read-only if, and only if, this buffer is read-only.
+ * + * @return A new short buffer + */ + public abstract ShortBuffer asShortBuffer(); + + + /** + * Relative get method for reading an int value. + * + *Reads the next four bytes at this buffer's current position, + * composing them into an int value according to the current byte order, + * and then increments the position by four.
+ * + * @return The int value at the buffer's current position + * + * @throws BufferUnderflowException + * If there are fewer than four bytes + * remaining in this buffer + */ + public abstract int getInt(); + + /** + * Relative put method for writing an int + * value (optional operation). + * + *Writes four bytes containing the given int value, in the + * current byte order, into this buffer at the current position, and then + * increments the position by four.
+ * + * @param value + * The int value to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If there are fewer than four bytes + * remaining in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putInt(int value); + + /** + * Absolute get method for reading an int value. + * + *Reads four bytes at the given index, composing them into a + * int value according to the current byte order.
+ * + * @param index + * The index from which the bytes will be read + * + * @return The int value at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus three + */ + public abstract int getInt(int index); + + /** + * Absolute put method for writing an int + * value (optional operation). + * + *Writes four bytes containing the given int value, in the + * current byte order, into this buffer at the given index.
+ * + * @param index + * The index at which the bytes will be written + * + * @param value + * The int value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus three + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putInt(int index, int value); + + /** + * Creates a view of this byte buffer as an int buffer. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer divided by + * four, its mark will be undefined, and its byte order will be that + * of the byte buffer at the moment the view is created. The new buffer + * will be direct if, and only if, this buffer is direct, and it will be + * read-only if, and only if, this buffer is read-only.
+ * + * @return A new int buffer + */ + public abstract IntBuffer asIntBuffer(); + + + /** + * Relative get method for reading a long value. + * + *Reads the next eight bytes at this buffer's current position, + * composing them into a long value according to the current byte order, + * and then increments the position by eight.
+ * + * @return The long value at the buffer's current position + * + * @throws BufferUnderflowException + * If there are fewer than eight bytes + * remaining in this buffer + */ + public abstract long getLong(); + + /** + * Relative put method for writing a long + * value (optional operation). + * + *Writes eight bytes containing the given long value, in the + * current byte order, into this buffer at the current position, and then + * increments the position by eight.
+ * + * @param value + * The long value to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If there are fewer than eight bytes + * remaining in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putLong(long value); + + /** + * Absolute get method for reading a long value. + * + *Reads eight bytes at the given index, composing them into a + * long value according to the current byte order.
+ * + * @param index + * The index from which the bytes will be read + * + * @return The long value at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus seven + */ + public abstract long getLong(int index); + + /** + * Absolute put method for writing a long + * value (optional operation). + * + *Writes eight bytes containing the given long value, in the + * current byte order, into this buffer at the given index.
+ * + * @param index + * The index at which the bytes will be written + * + * @param value + * The long value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus seven + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putLong(int index, long value); + + /** + * Creates a view of this byte buffer as a long buffer. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer divided by + * eight, its mark will be undefined, and its byte order will be that + * of the byte buffer at the moment the view is created. The new buffer + * will be direct if, and only if, this buffer is direct, and it will be + * read-only if, and only if, this buffer is read-only.
+ * + * @return A new long buffer + */ + public abstract LongBuffer asLongBuffer(); + + + /** + * Relative get method for reading a float value. + * + *Reads the next four bytes at this buffer's current position, + * composing them into a float value according to the current byte order, + * and then increments the position by four.
+ * + * @return The float value at the buffer's current position + * + * @throws BufferUnderflowException + * If there are fewer than four bytes + * remaining in this buffer + */ + public abstract float getFloat(); + + /** + * Relative put method for writing a float + * value (optional operation). + * + *Writes four bytes containing the given float value, in the + * current byte order, into this buffer at the current position, and then + * increments the position by four.
+ * + * @param value + * The float value to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If there are fewer than four bytes + * remaining in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putFloat(float value); + + /** + * Absolute get method for reading a float value. + * + *Reads four bytes at the given index, composing them into a + * float value according to the current byte order.
+ * + * @param index + * The index from which the bytes will be read + * + * @return The float value at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus three + */ + public abstract float getFloat(int index); + + /** + * Absolute put method for writing a float + * value (optional operation). + * + *Writes four bytes containing the given float value, in the + * current byte order, into this buffer at the given index.
+ * + * @param index + * The index at which the bytes will be written + * + * @param value + * The float value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus three + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putFloat(int index, float value); + + /** + * Creates a view of this byte buffer as a float buffer. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer divided by + * four, its mark will be undefined, and its byte order will be that + * of the byte buffer at the moment the view is created. The new buffer + * will be direct if, and only if, this buffer is direct, and it will be + * read-only if, and only if, this buffer is read-only.
+ * + * @return A new float buffer + */ + public abstract FloatBuffer asFloatBuffer(); + + + /** + * Relative get method for reading a double value. + * + *Reads the next eight bytes at this buffer's current position, + * composing them into a double value according to the current byte order, + * and then increments the position by eight.
+ * + * @return The double value at the buffer's current position + * + * @throws BufferUnderflowException + * If there are fewer than eight bytes + * remaining in this buffer + */ + public abstract double getDouble(); + + /** + * Relative put method for writing a double + * value (optional operation). + * + *Writes eight bytes containing the given double value, in the + * current byte order, into this buffer at the current position, and then + * increments the position by eight.
+ * + * @param value + * The double value to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If there are fewer than eight bytes + * remaining in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putDouble(double value); + + /** + * Absolute get method for reading a double value. + * + *Reads eight bytes at the given index, composing them into a + * double value according to the current byte order.
+ * + * @param index + * The index from which the bytes will be read + * + * @return The double value at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus seven + */ + public abstract double getDouble(int index); + + /** + * Absolute put method for writing a double + * value (optional operation). + * + *Writes eight bytes containing the given double value, in the + * current byte order, into this buffer at the given index.
+ * + * @param index + * The index at which the bytes will be written + * + * @param value + * The double value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit, + * minus seven + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ByteBuffer putDouble(int index, double value); + + /** + * Creates a view of this byte buffer as a double buffer. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of bytes remaining in this buffer divided by + * eight, its mark will be undefined, and its byte order will be that + * of the byte buffer at the moment the view is created. The new buffer + * will be direct if, and only if, this buffer is direct, and it will be + * read-only if, and only if, this buffer is read-only.
+ * + * @return A new double buffer + */ + public abstract DoubleBuffer asDoubleBuffer(); + } diff --git a/src/java.base/share/classes/java/nio/CharBuffer.java b/src/java.base/share/classes/java/nio/CharBuffer.java new file mode 100644 index 00000000000..104e11a2440 --- /dev/null +++ b/src/java.base/share/classes/java/nio/CharBuffer.java @@ -0,0 +1,2425 @@ +/* + * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// -- This file was mechanically generated: Do not edit! -- // + +package java.nio; + +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + + +import java.io.IOException; + +import java.lang.ref.Reference; + +import java.util.Spliterator; +import java.util.stream.StreamSupport; +import java.util.stream.IntStream; + + +import jdk.internal.foreign.AbstractMemorySegmentImpl; +import jdk.internal.foreign.MemorySessionImpl; +import jdk.internal.foreign.SegmentFactories; +import jdk.internal.vm.annotation.ForceInline; +import java.lang.foreign.MemorySegment; +import java.util.Objects; +import jdk.internal.util.ArraysSupport; + +/** + * A char buffer. + * + *This class defines four categories of operations upon + * char buffers: + * + *
Absolute and relative {@link #get() get} and + * {@link #put(char) put} methods that read and write + * single chars;
Absolute and relative {@link #get(char[]) bulk get} + * methods that transfer contiguous sequences of chars from this buffer + * into an array;
Absolute and relative {@link #put(char[]) bulk put} + * methods that transfer contiguous sequences of chars from a + * char array, a string, or some other char + * buffer into this buffer;
A method for {@link #compact compacting} + * a char buffer.
Char buffers can be created either by {@link #allocate + * allocation}, which allocates space for the buffer's + * + + + + + + + * + * content, by {@link #wrap(char[]) wrapping} an existing + * char array or string into a buffer, or by creating a + * view of an existing byte buffer. + * + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +* + + * + *
Like a byte buffer, a char buffer is either direct or non-direct. A + * char buffer created via the {@code wrap} methods of this class will + * be non-direct. A char buffer created as a view of a byte buffer will + * be direct if, and only if, the byte buffer itself is direct. Whether or not + * a char buffer is direct may be determined by invoking the {@link + * #isDirect isDirect} method.
+ * + +* + + * + *This class implements the {@link CharSequence} interface so that + * character buffers may be used wherever character sequences are accepted, for + * example in the regular-expression package {@link java.util.regex}. + * The methods defined by {@code CharSequence} operate relative to the current + * position of the buffer when they are invoked. + *
+ * + + * + + + + * + *Methods in this class that do not otherwise have a value to return are + * specified to return the buffer upon which they are invoked. This allows + * method invocations to be chained. + * + + + + + + + + + + + + + + + + + + + * + * The sequence of statements + * + * {@snippet lang=java : + * cb.put("text/"); + * cb.put(subtype); + * cb.put("; charset="); + * cb.put(enc); + * } + * + * can, for example, be replaced by the single statement + * + * {@snippet lang=java : + * cb.put("text/").put(subtype).put("; charset=").put(enc); + * } + * + + *
The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, each of its elements will be + * initialized to zero, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * It will have a {@link #array backing array}, and its + * {@link #arrayOffset array offset} will be zero. + * + * @param capacity + * The new buffer's capacity, in chars + * + * @return The new char buffer + * + * @throws IllegalArgumentException + * If the {@code capacity} is a negative integer + */ + public static CharBuffer allocate(int capacity) { + if (capacity < 0) + throw createCapacityException(capacity); + return new HeapCharBuffer(capacity, capacity, null); + } + + /** + * Wraps a char array into a buffer. + * + *
The new buffer will be backed by the given char array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity will be + * {@code array.length}, its position will be {@code offset}, its limit + * will be {@code offset + length}, its mark will be undefined, and its + * byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and + * its {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back the new buffer + * + * @param offset + * The offset of the subarray to be used; must be non-negative and + * no larger than {@code array.length}. The new buffer's position + * will be set to this value. + * + * @param length + * The length of the subarray to be used; + * must be non-negative and no larger than + * {@code array.length - offset}. + * The new buffer's limit will be set to {@code offset + length}. + * + * @return The new char buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code offset} and {@code length} + * parameters do not hold + */ + public static CharBuffer wrap(char[] array, + int offset, int length) + { + try { + return new HeapCharBuffer(array, offset, length, null); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps a char array into a buffer. + * + *The new buffer will be backed by the given char array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity and limit will be + * {@code array.length}, its position will be zero, its mark will be + * undefined, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and its + * {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back this buffer + * + * @return The new char buffer + */ + public static CharBuffer wrap(char[] array) { + return wrap(array, 0, array.length); + } + + + + /** + * Attempts to read characters into the specified character buffer. + * The buffer is used as a repository of characters as-is: the only + * changes made are the results of a put operation. No flipping or + * rewinding of the buffer is performed. If the {@linkplain #length + * length} of the specified character buffer is zero, then no characters + * will be read and zero will be returned. + * + * @param target the buffer to read characters into + * @return The number of characters added to the buffer, + * possibly zero, or -1 if this source of characters is at its end + * @throws IOException if an I/O error occurs + * @throws ReadOnlyBufferException if target is a read only buffer, + * even if its length is zero + * @since 1.5 + */ + public int read(CharBuffer target) throws IOException { + // Determine the number of bytes n that can be transferred + int limit = limit(); + int pos = position(); + int remaining = limit - pos; + assert remaining >= 0; + if (remaining <= 0) // include equality condition when remaining == 0 + return -1; + + int targetRemaining = target.remaining(); + assert targetRemaining >= 0; + if (targetRemaining <= 0) // include condition targetRemaining == 0 + return 0; + + int n = Math.min(remaining, targetRemaining); + + // Set source limit to prevent target overflow + if (targetRemaining < remaining) + limit(pos + n); + try { + if (n > 0) + target.put(this); + } finally { + limit(limit); // restore real limit + } + return n; + } + + /** + * Wraps a character sequence into a buffer. + * + *The content of the new, read-only buffer will be the content of the + * given character sequence. The buffer's capacity will be + * {@code csq.length()}, its position will be {@code start}, its limit + * will be {@code end}, and its mark will be undefined.
+ * + * @param csq + * The character sequence from which the new character buffer is to + * be created + * + * @param start + * The index of the first character to be used; + * must be non-negative and no larger than {@code csq.length()}. + * The new buffer's position will be set to this value. + * + * @param end + * The index of the character following the last character to be + * used; must be no smaller than {@code start} and no larger + * than {@code csq.length()}. + * The new buffer's limit will be set to this value. + * + * @return The new character buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code start} and {@code end} + * parameters do not hold + */ + public static CharBuffer wrap(CharSequence csq, int start, int end) { + try { + return new StringCharBuffer(csq, start, end); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps a character sequence into a buffer. + * + *The content of the new, read-only buffer will be the content of the + * given character sequence. The new buffer's capacity and limit will be + * {@code csq.length()}, its position will be zero, and its mark will be + * undefined.
+ * + * @param csq + * The character sequence from which the new character buffer is to + * be created + * + * @return The new character buffer + */ + public static CharBuffer wrap(CharSequence csq) { + return wrap(csq, 0, csq.length()); + } + + + + /** + * Creates a new char buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of chars remaining in this buffer, its mark will be + * undefined, and its byte order will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new char buffer + + + + + */ + @Override + public abstract CharBuffer slice(); + + /** + * Creates a new char buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at position {@code index} + * in this buffer, and will contain {@code length} elements. Changes to + * this buffer's content will be visible in the new buffer, and vice versa; + * the two buffers' position, limit, and mark values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be {@code length}, its mark will be undefined, and its byte order + * will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, + * and it will be read-only if, and only if, this buffer is read-only.
+ * + * @param index + * The position in this buffer at which the content of the new + * buffer will start; must be non-negative and no larger than + * {@link #limit() limit()} + * + * @param length + * The number of elements the new buffer will contain; must be + * non-negative and no larger than {@code limit() - index} + * + * @return The new buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative or greater than {@code limit()}, + * {@code length} is negative, or {@code length > limit() - index} + * + * @since 13 + */ + @Override + public abstract CharBuffer slice(int index, int length); + + /** + * Creates a new char buffer that shares this buffer's content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer, and vice + * versa; the two buffers' position, limit, and mark values will be + * independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new char buffer + */ + @Override + public abstract CharBuffer duplicate(); + + /** + * Creates a new, read-only char buffer that shares this buffer's + * content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer; the new + * buffer itself, however, will be read-only and will not allow the shared + * content to be modified. The two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * + *
If this buffer is itself read-only then this method behaves in + * exactly the same way as the {@link #duplicate duplicate} method.
+ * + * @return The new, read-only char buffer + */ + public abstract CharBuffer asReadOnlyBuffer(); + + + // -- Singleton get/put methods -- + + /** + * Relative get method. Reads the char at this buffer's + * current position, and then increments the position. + * + * @return The char at the buffer's current position + * + * @throws BufferUnderflowException + * If the buffer's current position is not smaller than its limit + */ + public abstract char get(); + + /** + * Relative put method (optional operation). + * + *Writes the given char into this buffer at the current + * position, and then increments the position.
+ * + * @param c + * The char to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If this buffer's current position is not smaller than its limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract CharBuffer put(char c); + + /** + * Absolute get method. Reads the char at the given + * index. + * + * @param index + * The index from which the char will be read + * + * @return The char at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + */ + public abstract char get(int index); + + + /** + * Absolute get method. Reads the char at the given + * index without any validation of the index. + * + * @param index + * The index from which the char will be read + * + * @return The char at the given index + */ + abstract char getUnchecked(int index); // package-private + + + /** + * Absolute put method (optional operation). + * + *Writes the given char into this buffer at the given + * index.
+ * + * @param index + * The index at which the char will be written + * + * @param c + * The char value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract CharBuffer put(int index, char c); + + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers chars from this buffer into the given + * destination array. If there are fewer chars remaining in the + * buffer than are required to satisfy the request, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * chars are transferred and a {@link BufferUnderflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} chars from this + * buffer into the given array, starting at the current position of this + * buffer and at the given offset in the array. The position of this + * buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * src.get(dst, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst[i] = src.get();
+ * }
+ *
+ * except that it first checks that there are sufficient chars in
+ * this buffer and it is potentially much more efficient.
+ *
+ * @param dst
+ * The array into which chars are to be written
+ *
+ * @param offset
+ * The offset within the array of the first char to be
+ * written; must be non-negative and no larger than
+ * {@code dst.length}
+ *
+ * @param length
+ * The maximum number of chars to be written to the given
+ * array; must be non-negative and no larger than
+ * {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} chars
+ * remaining in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public CharBuffer get(char[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(offset, length, dst.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferUnderflowException();
+
+ getArray(pos, dst, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk get method.
+ *
+ *
This method transfers chars from this buffer into the given + * destination array. An invocation of this method of the form + * {@code src.get(a)} behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * src.get(a, 0, a.length) + * } + * + * @param dst + * The destination array + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than {@code length} chars + * remaining in this buffer + */ + public CharBuffer get(char[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Absolute bulk get method. + * + *
This method transfers {@code length} chars from this + * buffer into the given array, starting at the given index in this + * buffer and at the given offset in the array. The position of this + * buffer is unchanged. + * + *
An invocation of this method of the form
+ * src.get(index, dst, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst[i] = src.get(j);
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first char will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @param offset
+ * The offset within the array of the first char to be
+ * written; must be non-negative and less than
+ * {@code dst.length}
+ *
+ * @param length
+ * The number of chars to be written to the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @since 13
+ */
+ public CharBuffer get(int index, char[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, dst.length);
+
+ getArray(index, dst, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk get method.
+ *
+ *
This method transfers chars from this buffer into the given
+ * destination array. The position of this buffer is unchanged. An
+ * invocation of this method of the form
+ * src.get(index, dst) behaves in exactly the same
+ * way as the invocation:
+ *
+ * {@snippet lang=java :
+ * src.get(index, dst, 0, dst.length)
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first char will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < dst.length}
+ *
+ * @since 13
+ */
+ public CharBuffer get(int index, char[] dst) {
+ return get(index, dst, 0, dst.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ CharBuffer getArray(int index, char[] dst, int offset, int length) {
+
+ assert isAddressable();
+
+ if (((long)length << 1) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 1);
+ long dstOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 1);
+ long len = (long)length << 1;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len, Character.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++) {
+ dst[i] = get(j);
+ }
+ }
+ return this;
+ }
+
+ // -- Bulk put operations --
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the chars remaining in the given source + * buffer into this buffer. If there are more chars remaining in the + * source buffer than in this buffer, that is, if + * {@code src.remaining()} {@code >} {@code remaining()}, + * then no chars are transferred and a {@link + * BufferOverflowException} is thrown. + * + *
Otherwise, this method copies + * n = {@code src.remaining()} chars from the given + * buffer into this buffer, starting at each buffer's current position. + * The positions of both buffers are then incremented by n. + * + *
In other words, an invocation of this method of the form + * {@code dst.put(src)} has exactly the same effect as the loop + * + * {@snippet lang=java : + * while (src.hasRemaining()) + * dst.put(src.get()); + * } + * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. If this buffer and + * the source buffer share the same backing array or memory, then the + * result will be as if the source elements were first copied to an + * intermediate location before being written into this buffer. + * + * @param src + * The source buffer from which chars are to be read; + * must not be this buffer + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * for the remaining chars in the source buffer + * + * @throws IllegalArgumentException + * If the source buffer is this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public CharBuffer put(CharBuffer src) { + if (src == this) + throw createSameBufferException(); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + + int srcPos = src.position(); + int srcLim = src.limit(); + int srcRem = (srcPos <= srcLim ? srcLim - srcPos : 0); + int pos = position(); + int lim = limit(); + int rem = (pos <= lim ? lim - pos : 0); + + if (srcRem > rem) + throw new BufferOverflowException(); + + putBuffer(pos, src, srcPos, srcRem); + + position(pos + srcRem); + src.position(srcPos + srcRem); + + return this; + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} chars into this buffer from + * the given source buffer, starting at the given {@code offset} in the + * source buffer and the given {@code index} in this buffer. The positions + * of both buffers are unchanged. + * + *
In other words, an invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src.get(i));
+ * }
+ *
+ * except that it first checks the consistency of the supplied parameters
+ * and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
+ *
+ * @param index
+ * The index in this buffer at which the first char will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The buffer from which chars are to be read
+ *
+ * @param offset
+ * The index within the source buffer of the first char to be
+ * read; must be non-negative and less than {@code src.limit()}
+ *
+ * @param length
+ * The number of chars to be read from the given buffer;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.limit() - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 16
+ */
+ public CharBuffer put(int index, CharBuffer src, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.limit());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+
+ putBuffer(index, src, offset, length);
+
+ return this;
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ void putBuffer(int pos, CharBuffer src, int srcPos, int n) {
+
+ Object srcBase = src.base();
+
+ if (src.isAddressable()) {
+
+
+
+
+ Object base = base();
+ assert base != null || isDirect();
+
+ long srcAddr = src.address + ((long)srcPos << 1);
+ long addr = address + ((long)pos << 1);
+ long len = (long)n << 1;
+
+ try {
+
+ if (this.order() != src.order())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len, Character.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len);
+ } finally {
+ Reference.reachabilityFence(src);
+ Reference.reachabilityFence(this);
+ }
+
+ } else { // src.isAddressable() == false
+ assert StringCharBuffer.class.isInstance(src);
+ if (this.hb != null && src instanceof StringCharBuffer scb) {
+ scb.getArray(srcPos, this.hb, pos, n);
+ } else {
+ int posMax = pos + n;
+ for (int i = pos, j = srcPos; i < posMax; i++, j++)
+ put(i, src.get(j));
+ }
+ }
+
+
+
+
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers chars into this buffer from the given + * source array. If there are more chars to be copied from the array + * than remain in this buffer, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * chars are transferred and a {@link BufferOverflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} chars from the + * given array into this buffer, starting at the given offset in the array + * and at the current position of this buffer. The position of this buffer + * is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * dst.put(src, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst.put(src[i]);
+ * }
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The array from which chars are to be read
+ *
+ * @param offset
+ * The offset within the array of the first char to be read;
+ * must be non-negative and no larger than {@code src.length}
+ *
+ * @param length
+ * The number of chars to be read from the given array;
+ * must be non-negative and no larger than
+ * {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public CharBuffer put(char[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(offset, length, src.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferOverflowException();
+
+ putArray(pos, src, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the entire content of the given source + * char array into this buffer. An invocation of this method of the + * form {@code dst.put(a)} behaves in exactly the same way as the + * invocation + * + * {@snippet lang=java : + * dst.put(a, 0, a.length) + * } + * + * @param src + * The source array + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final CharBuffer put(char[] src) { + return put(src, 0, src.length); + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} chars from the given + * array, starting at the given offset in the array and at the given index + * in this buffer. The position of this buffer is unchanged. + * + *
An invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src[i]);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first char will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which chars are to be read
+ *
+ * @param offset
+ * The offset within the array of the first char to be read;
+ * must be non-negative and less than {@code src.length}
+ *
+ * @param length
+ * The number of chars to be read from the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public CharBuffer put(int index, char[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.length);
+
+ putArray(index, src, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk put method (optional operation).
+ *
+ *
This method copies chars into this buffer from the given source
+ * array. The position of this buffer is unchanged. An invocation of this
+ * method of the form dst.put(index, src)
+ * behaves in exactly the same way as the invocation:
+ *
+ * {@snippet lang=java :
+ * dst.put(index, src, 0, src.length);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first char will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which chars are to be read
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < src.length}
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public CharBuffer put(int index, char[] src) {
+ return put(index, src, 0, src.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ CharBuffer putArray(int index, char[] src, int offset, int length) {
+
+ if (
+
+ isAddressable() &&
+
+ ((long)length << 1) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 1);
+ long srcOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 1);
+ long len = (long)length << 1;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len, Character.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++)
+ this.put(j, src[i]);
+ }
+ return this;
+
+
+
+ }
+
+
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers chars from the given string into this
+ * buffer. If there are more chars to be copied from the string than
+ * remain in this buffer, that is, if
+ * end - start {@code >} {@code remaining()},
+ * then no chars are transferred and a {@link
+ * BufferOverflowException} is thrown.
+ *
+ *
Otherwise, this method copies + * n = {@code end} - {@code start} chars + * from the given string into this buffer, starting at the given + * {@code start} index and at the current position of this buffer. The + * position of this buffer is then incremented by n. + * + *
In other words, an invocation of this method of the form
+ * dst.put(src, start, end) has exactly the same effect
+ * as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = start; i < end; i++)
+ * dst.put(src.charAt(i));
+ * }
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The string from which chars are to be read
+ *
+ * @param start
+ * The offset within the string of the first char to be read;
+ * must be non-negative and no larger than
+ * {@code string.length()}
+ *
+ * @param end
+ * The offset within the string of the last char to be read,
+ * plus one; must be non-negative and no larger than
+ * {@code string.length()}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code start} and {@code end}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public CharBuffer put(String src, int start, int end) {
+ Objects.checkFromIndexSize(start, end - start, src.length());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ if (end - start > remaining())
+ throw new BufferOverflowException();
+ for (int i = start; i < end; i++)
+ this.put(src.charAt(i));
+ return this;
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the entire content of the given source string + * into this buffer. An invocation of this method of the form + * {@code dst.put(s)} behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * dst.put(s, 0, s.length()) + * } + * + * @param src + * The source string + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final CharBuffer put(String src) { + return put(src, 0, src.length()); + } + + + + + // -- Other stuff -- + + /** + * Tells whether or not this buffer is backed by an accessible char + * array. + * + *
If this method returns {@code true} then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *
+ * + * @return {@code true} if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the char array that backs this + * buffer (optional operation). + * + *Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final char[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer (optional operation). + * + *If this buffer is backed by an array then buffer position p + * corresponds to array index p + {@code arrayOffset()}. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + // -- Covariant return type overrides + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + CharBuffer position(int newPosition) { + super.position(newPosition); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + CharBuffer limit(int newLimit) { + super.limit(newLimit); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + CharBuffer mark() { + super.mark(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + CharBuffer reset() { + super.reset(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + CharBuffer clear() { + super.clear(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + CharBuffer flip() { + super.flip(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + CharBuffer rewind() { + super.rewind(); + return this; + } + + /** + * Compacts this buffer (optional operation). + * + *The chars between the buffer's current position and its limit, + * if any, are copied to the beginning of the buffer. That is, the + * char at index p = {@code position()} is copied + * to index zero, the char at index p + 1 is copied + * to index one, and so forth until the char at index + * {@code limit()} - 1 is copied to index + * n = {@code limit()} - {@code 1} - p. + * The buffer's position is then set to n+1 and its limit is set to + * its capacity. The mark, if defined, is discarded. + * + *
The buffer's position is set to the number of chars copied, + * rather than to zero, so that an invocation of this method can be + * followed immediately by an invocation of another relative put + * method.
+ * + + + + + + + + + + + + + + + + + * + * @return This buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract CharBuffer compact(); + + /** + * Tells whether or not this char buffer is direct. + * + * @return {@code true} if, and only if, this buffer is direct + */ + public abstract boolean isDirect(); + + + /** + * Tells whether this buffer has addressable memory, e.g., a Java array or + * a native address. This method returns {@code true}. Subclasses such as + * {@code StringCharBuffer}, which wraps a {@code CharSequence}, should + * override this method to return {@code false}. + * + * @return {@code true} if, and only, this buffer has addressable memory + */ + boolean isAddressable() { + return true; + } + + + + + + + + + + + + + + + + + + + + + + + /** + * Returns the current hash code of this buffer. + * + *The hash code of a char buffer depends only upon its remaining + * elements; that is, upon the elements from {@code position()} up to, and + * including, the element at {@code limit()} - {@code 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.
+ * + * @return The current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) + + + + h = 31 * h + (int)get(i); + + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two char buffers are equal if, and only if, + * + *
They have the same element type,
They have the same number of remaining elements, and + *
The two sequences of remaining elements, considered + * independently of their starting positions, are pointwise equal. + + + + + + + + *
A char buffer is not equal to any other type of object.
+ * + * @param ob The object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(@Nullable Object ob) { + if (this == ob) + return true; + if (!(ob instanceof CharBuffer)) + return false; + CharBuffer that = (CharBuffer)ob; + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + if (thisRem < 0 || thisRem != thatRem) + return false; + return BufferMismatch.mismatch(this, thisPos, + that, thatPos, + thisRem) < 0; + } + + /** + * Compares this buffer to another. + * + *Two char buffers are compared by comparing their sequences of + * remaining elements lexicographically, without regard to the starting + * position of each sequence within its corresponding buffer. + + + + + + + + + * Pairs of {@code char} elements are compared as if by invoking + * {@link Character#compare(char,char)}. + + * + *
A char buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer + * is less than, equal to, or greater than the given buffer + */ + public int compareTo(CharBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int i = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + if (i >= 0) { + return compare(this.get(thisPos + i), that.get(thatPos + i)); + } + return thisRem - thatRem; + } + + private static int compare(char x, char y) { + + + + + + + return Character.compare(x, y); + + } + + /** + * Finds and returns the relative index of the first mismatch between this + * buffer and a given buffer. The index is relative to the + * {@link #position() position} of each buffer and will be in the range of + * 0 (inclusive) up to the smaller of the {@link #remaining() remaining} + * elements in each buffer (exclusive). + * + *
If the two buffers share a common prefix then the returned index is + * the length of the common prefix and it follows that there is a mismatch + * between the two buffers at that index within the respective buffers. + * If one buffer is a proper prefix of the other then the returned index is + * the smaller of the remaining elements in each buffer, and it follows that + * the index is only valid for the buffer with the larger number of + * remaining elements. + * Otherwise, there is no mismatch. + * + * @param that + * The byte buffer to be tested for a mismatch with this buffer + * + * @return The relative index of the first mismatch between this and the + * given buffer, otherwise -1 if no mismatch. + * + * @since 11 + */ + public int mismatch(CharBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int r = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + return (r == -1 && thisRem != thatRem) ? length : r; + } + + // -- Other char stuff -- + + + + /** + * Relative bulk get method. + * + *
This method transfers {@code srcEnd-srcBegin} characters from this + * buffer into the given array, starting at index + * {@code position() + srcBegin} in this buffer and at offset + * {@code dstBegin} in the array. The position of this buffer is unchanged. + * + *
An invocation of this method behaves exactly the same was as the + * invocation + * + * {@snippet lang=java : + * get(position() + srcBegin, dst, dstBegin, srcEnd - srcBegin) + * } + * + * @param srcBegin + * The index in this buffer, relative to the current position, + * of the first character to + * read; must be non-negative and less than + * {@code limit() - position()} + * + * @param srcEnd + * The index in this buffer, relative to the current position, + * after the last character to read; + * must be greater than or equal to {@code srcBegin} and less than + * or equal to {@code limit() - position()} + * + * @param dst + * The destination array + * + * @param dstBegin + * The offset within the array of the first character to be + * written; must be non-negative and less than {@code dst.length} + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code srcBegin}, {@code srcEnd}, + * and {@code dstBegin} parameters do not hold + * + * @since 25 + */ + @Override + public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) { + // Check [srcBegin,srcEnd) is a subset of [0,limit()-position) + int pos = position(); + int lim = limit(); + Objects.checkFromToIndex(srcBegin, srcEnd, lim - pos); + + get(pos + srcBegin, dst, dstBegin, srcEnd - srcBegin); + } + + /** + * Returns a string containing the characters in this buffer. + * + *
The first character of the resulting string will be the character at + * this buffer's position, while the last character will be the character + * at index {@code limit()} - 1. Invoking this method does not + * change the buffer's position.
+ * + * @return The specified string + */ + public String toString() { + return toString(position(), limit()); + } + + abstract String toString(int start, int end); // package-private + + + // --- Methods to support CharSequence --- + + /** + * Returns the length of this character buffer. + * + *When viewed as a character sequence, the length of a character + * buffer is simply the number of characters between the position + * (inclusive) and the limit (exclusive); that is, it is equivalent to + * {@code remaining()}.
+ * + * @return The length of this character buffer + */ + public final int length() { + return remaining(); + } + + /** + * Returns {@code true} if this character buffer is empty. + * + * @return {@code true} if there are {@code 0} remaining characters, + * otherwise {@code false} + * + * @since 15 + */ + public final boolean isEmpty() { + return remaining() == 0; + } + + /** + * Reads the character at the given index relative to the current + * position. + * + * @param index + * The index of the character to be read, relative to the position; + * must be non-negative and smaller than {@code remaining()} + * + * @return The character at index + *position() + index
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on {@code index} do not hold
+ */
+ public final char charAt(int index) {
+ return get(position() + checkIndex(index, 1));
+ }
+
+ /**
+ * Creates a new character buffer that represents the specified subsequence
+ * of this buffer, relative to the current position.
+ *
+ * The new buffer will share this buffer's content; that is, if the + * content of this buffer is mutable then modifications to one buffer will + * cause the other to be modified. The new buffer's capacity will be that + * of this buffer, its position will be + * {@code position()} + {@code start}, its limit will be + * {@code position()} + {@code end}, and its byte order + * will be identical to that of this buffer. The new buffer will be direct + * if, and only if, this buffer is direct, and it will be read-only + * if, and only if, this buffer is read-only.
+ * + * @param start + * The index, relative to the current position, of the first + * character in the subsequence; must be non-negative and no larger + * than {@code remaining()} + * + * @param end + * The index, relative to the current position, of the character + * following the last character in the subsequence; must be no + * smaller than {@code start} and no larger than + * {@code remaining()} + * + * @return The new character buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on {@code start} and {@code end} + * do not hold + */ + public abstract CharBuffer subSequence(int start, int end); + + + // --- Methods to support Appendable --- + + /** + * Appends the specified character sequence to this + * buffer (optional operation). + * + *An invocation of this method of the form {@code dst.append(csq)} + * behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * dst.put(csq.toString()) + * } + * + *
Depending on the specification of {@code toString} for the + * character sequence {@code csq}, the entire sequence may not be + * appended. For instance, invoking the {@link CharBuffer#toString() + * toString} method of a character buffer will return a subsequence whose + * content depends upon the buffer's position and limit. + * + * @param csq + * The character sequence to append. If {@code csq} is + * {@code null}, then the four characters {@code "null"} are + * appended to this character buffer. + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + * + * @since 1.5 + */ + public CharBuffer append(@Nullable CharSequence csq) { + if (csq == null) + return put("null"); + else if (csq instanceof CharBuffer cb) + return put(cb); + else + return put(csq.toString()); + } + + /** + * Appends a subsequence of the specified character sequence to this + * buffer (optional operation). + * + *
An invocation of this method of the form {@code dst.append(csq, start, + * end)} when {@code csq} is not {@code null}, behaves in exactly the + * same way as the invocation + * + * {@snippet lang=java : + * dst.put(csq.subSequence(start, end).toString()) + * } + * + * @param csq + * The character sequence from which a subsequence will be + * appended. If {@code csq} is {@code null}, then characters + * will be appended as if {@code csq} contained the four + * characters {@code "null"}. + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws IndexOutOfBoundsException + * If {@code start} or {@code end} are negative, {@code start} + * is greater than {@code end}, or {@code end} is greater than + * {@code csq.length()} + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + * + * @since 1.5 + */ + public CharBuffer append(@Nullable CharSequence csq, int start, int end) { + if (csq instanceof CharBuffer cb) { + Objects.checkFromToIndex(start, end, csq.length()); + + // + // the append method throws BufferOverflowException when + // there is insufficient space in the buffer + // + int length = end - start; + int pos = position(); + int lim = limit(); + int rem = (pos <= lim) ? lim - pos : 0; + if (length > rem) + throw new BufferOverflowException(); + + put(pos, cb, start, length); + position(pos + length); + return this; + } + CharSequence cs = (csq == null ? "null" : csq); + return put(cs.subSequence(start, end).toString()); + } + + /** + * Appends the specified char to this + * buffer (optional operation). + * + *
An invocation of this method of the form {@code dst.append(c)} + * behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * dst.put(c) + * } + * + * @param c + * The 16-bit char to append + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + * + * @since 1.5 + */ + public CharBuffer append(char c) { + return put(c); + } + + + + + // -- Other byte stuff: Access to binary data -- + + + + /** + * Retrieves this buffer's byte order. + * + *
The byte order of a char buffer created by allocation or by + * wrapping an existing {@code char} array is the {@link + * ByteOrder#nativeOrder native order} of the underlying + * hardware. The byte order of a char buffer created as a view of a byte buffer is that of the + * byte buffer at the moment that the view is created.
+ * + * @return This buffer's byte order + */ + public abstract ByteOrder order(); + + + + + // The order or null if the buffer does not cover a memory region, + // such as StringCharBuffer + abstract ByteOrder charRegionOrder(); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @ForceInline + @Override + int scaleShifts() { + return Integer.numberOfTrailingZeros(Character.BYTES); + } + + @ForceInline + @Override + AbstractMemorySegmentImpl heapSegment(Object base, + long offset, + long length, + boolean readOnly, + MemorySessionImpl bufferScope) { + return SegmentFactories.arrayOfCharSegment(base, offset, length, readOnly, bufferScope); + } + + + + + @Override + + public IntStream chars() { + return StreamSupport.intStream(() -> new CharBufferSpliterator(this), + Buffer.SPLITERATOR_CHARACTERISTICS, false); + } + + + +} diff --git a/src/java.base/share/classes/java/nio/DoubleBuffer.java b/src/java.base/share/classes/java/nio/DoubleBuffer.java new file mode 100644 index 00000000000..359fd3043f9 --- /dev/null +++ b/src/java.base/share/classes/java/nio/DoubleBuffer.java @@ -0,0 +1,2425 @@ +/* + * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// -- This file was mechanically generated: Do not edit! -- // + +package java.nio; + +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + + + + +import java.lang.ref.Reference; + + + + + + +import jdk.internal.foreign.AbstractMemorySegmentImpl; +import jdk.internal.foreign.MemorySessionImpl; +import jdk.internal.foreign.SegmentFactories; +import jdk.internal.vm.annotation.ForceInline; +import java.lang.foreign.MemorySegment; +import java.util.Objects; +import jdk.internal.util.ArraysSupport; + +/** + * A double buffer. + * + *This class defines four categories of operations upon + * double buffers: + * + *
Absolute and relative {@link #get() get} and + * {@link #put(double) put} methods that read and write + * single doubles;
Absolute and relative {@link #get(double[]) bulk get} + * methods that transfer contiguous sequences of doubles from this buffer + * into an array;
Absolute and relative {@link #put(double[]) bulk put} + * methods that transfer contiguous sequences of doubles from a + * double array or some other double + * buffer into this buffer;
A method for {@link #compact compacting} + * a double buffer.
Double buffers can be created either by {@link #allocate + * allocation}, which allocates space for the buffer's + * + + + + + + + * + * content, by {@link #wrap(double[]) wrapping} an existing + * double array into a buffer, or by creating a + * view of an existing byte buffer. + * + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +* + + * + *
Like a byte buffer, a double buffer is either direct or non-direct. A + * double buffer created via the {@code wrap} methods of this class will + * be non-direct. A double buffer created as a view of a byte buffer will + * be direct if, and only if, the byte buffer itself is direct. Whether or not + * a double buffer is direct may be determined by invoking the {@link + * #isDirect isDirect} method.
+ * + +* + + + + + + + + + + + * + + + + * + *Methods in this class that do not otherwise have a value to return are + * specified to return the buffer upon which they are invoked. This allows + * method invocations to be chained. + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + *
The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, each of its elements will be + * initialized to zero, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * It will have a {@link #array backing array}, and its + * {@link #arrayOffset array offset} will be zero. + * + * @param capacity + * The new buffer's capacity, in doubles + * + * @return The new double buffer + * + * @throws IllegalArgumentException + * If the {@code capacity} is a negative integer + */ + public static DoubleBuffer allocate(int capacity) { + if (capacity < 0) + throw createCapacityException(capacity); + return new HeapDoubleBuffer(capacity, capacity, null); + } + + /** + * Wraps a double array into a buffer. + * + *
The new buffer will be backed by the given double array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity will be + * {@code array.length}, its position will be {@code offset}, its limit + * will be {@code offset + length}, its mark will be undefined, and its + * byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and + * its {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back the new buffer + * + * @param offset + * The offset of the subarray to be used; must be non-negative and + * no larger than {@code array.length}. The new buffer's position + * will be set to this value. + * + * @param length + * The length of the subarray to be used; + * must be non-negative and no larger than + * {@code array.length - offset}. + * The new buffer's limit will be set to {@code offset + length}. + * + * @return The new double buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code offset} and {@code length} + * parameters do not hold + */ + public static DoubleBuffer wrap(double[] array, + int offset, int length) + { + try { + return new HeapDoubleBuffer(array, offset, length, null); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps a double array into a buffer. + * + *The new buffer will be backed by the given double array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity and limit will be + * {@code array.length}, its position will be zero, its mark will be + * undefined, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and its + * {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back this buffer + * + * @return The new double buffer + */ + public static DoubleBuffer wrap(double[] array) { + return wrap(array, 0, array.length); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** + * Creates a new double buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of doubles remaining in this buffer, its mark will be + * undefined, and its byte order will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new double buffer + + + + + */ + @Override + public abstract DoubleBuffer slice(); + + /** + * Creates a new double buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at position {@code index} + * in this buffer, and will contain {@code length} elements. Changes to + * this buffer's content will be visible in the new buffer, and vice versa; + * the two buffers' position, limit, and mark values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be {@code length}, its mark will be undefined, and its byte order + * will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, + * and it will be read-only if, and only if, this buffer is read-only.
+ * + * @param index + * The position in this buffer at which the content of the new + * buffer will start; must be non-negative and no larger than + * {@link #limit() limit()} + * + * @param length + * The number of elements the new buffer will contain; must be + * non-negative and no larger than {@code limit() - index} + * + * @return The new buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative or greater than {@code limit()}, + * {@code length} is negative, or {@code length > limit() - index} + * + * @since 13 + */ + @Override + public abstract DoubleBuffer slice(int index, int length); + + /** + * Creates a new double buffer that shares this buffer's content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer, and vice + * versa; the two buffers' position, limit, and mark values will be + * independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new double buffer + */ + @Override + public abstract DoubleBuffer duplicate(); + + /** + * Creates a new, read-only double buffer that shares this buffer's + * content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer; the new + * buffer itself, however, will be read-only and will not allow the shared + * content to be modified. The two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * + *
If this buffer is itself read-only then this method behaves in + * exactly the same way as the {@link #duplicate duplicate} method.
+ * + * @return The new, read-only double buffer + */ + public abstract DoubleBuffer asReadOnlyBuffer(); + + + // -- Singleton get/put methods -- + + /** + * Relative get method. Reads the double at this buffer's + * current position, and then increments the position. + * + * @return The double at the buffer's current position + * + * @throws BufferUnderflowException + * If the buffer's current position is not smaller than its limit + */ + public abstract double get(); + + /** + * Relative put method (optional operation). + * + *Writes the given double into this buffer at the current + * position, and then increments the position.
+ * + * @param d + * The double to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If this buffer's current position is not smaller than its limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract DoubleBuffer put(double d); + + /** + * Absolute get method. Reads the double at the given + * index. + * + * @param index + * The index from which the double will be read + * + * @return The double at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + */ + public abstract double get(int index); + + + + + + + + + + + + + + + /** + * Absolute put method (optional operation). + * + *Writes the given double into this buffer at the given + * index.
+ * + * @param index + * The index at which the double will be written + * + * @param d + * The double value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract DoubleBuffer put(int index, double d); + + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers doubles from this buffer into the given + * destination array. If there are fewer doubles remaining in the + * buffer than are required to satisfy the request, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * doubles are transferred and a {@link BufferUnderflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} doubles from this + * buffer into the given array, starting at the current position of this + * buffer and at the given offset in the array. The position of this + * buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * src.get(dst, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst[i] = src.get();
+ * }
+ *
+ * except that it first checks that there are sufficient doubles in
+ * this buffer and it is potentially much more efficient.
+ *
+ * @param dst
+ * The array into which doubles are to be written
+ *
+ * @param offset
+ * The offset within the array of the first double to be
+ * written; must be non-negative and no larger than
+ * {@code dst.length}
+ *
+ * @param length
+ * The maximum number of doubles to be written to the given
+ * array; must be non-negative and no larger than
+ * {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} doubles
+ * remaining in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public DoubleBuffer get(double[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(offset, length, dst.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferUnderflowException();
+
+ getArray(pos, dst, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk get method.
+ *
+ *
This method transfers doubles from this buffer into the given + * destination array. An invocation of this method of the form + * {@code src.get(a)} behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * src.get(a, 0, a.length) + * } + * + * @param dst + * The destination array + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than {@code length} doubles + * remaining in this buffer + */ + public DoubleBuffer get(double[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Absolute bulk get method. + * + *
This method transfers {@code length} doubles from this + * buffer into the given array, starting at the given index in this + * buffer and at the given offset in the array. The position of this + * buffer is unchanged. + * + *
An invocation of this method of the form
+ * src.get(index, dst, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst[i] = src.get(j);
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first double will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @param offset
+ * The offset within the array of the first double to be
+ * written; must be non-negative and less than
+ * {@code dst.length}
+ *
+ * @param length
+ * The number of doubles to be written to the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @since 13
+ */
+ public DoubleBuffer get(int index, double[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, dst.length);
+
+ getArray(index, dst, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk get method.
+ *
+ *
This method transfers doubles from this buffer into the given
+ * destination array. The position of this buffer is unchanged. An
+ * invocation of this method of the form
+ * src.get(index, dst) behaves in exactly the same
+ * way as the invocation:
+ *
+ * {@snippet lang=java :
+ * src.get(index, dst, 0, dst.length)
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first double will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < dst.length}
+ *
+ * @since 13
+ */
+ public DoubleBuffer get(int index, double[] dst) {
+ return get(index, dst, 0, dst.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ DoubleBuffer getArray(int index, double[] dst, int offset, int length) {
+
+
+
+ if (((long)length << 3) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 3);
+ long dstOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 3);
+ long len = (long)length << 3;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len, Double.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++) {
+ dst[i] = get(j);
+ }
+ }
+ return this;
+ }
+
+ // -- Bulk put operations --
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the doubles remaining in the given source + * buffer into this buffer. If there are more doubles remaining in the + * source buffer than in this buffer, that is, if + * {@code src.remaining()} {@code >} {@code remaining()}, + * then no doubles are transferred and a {@link + * BufferOverflowException} is thrown. + * + *
Otherwise, this method copies + * n = {@code src.remaining()} doubles from the given + * buffer into this buffer, starting at each buffer's current position. + * The positions of both buffers are then incremented by n. + * + *
In other words, an invocation of this method of the form + * {@code dst.put(src)} has exactly the same effect as the loop + * + * {@snippet lang=java : + * while (src.hasRemaining()) + * dst.put(src.get()); + * } + * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. If this buffer and + * the source buffer share the same backing array or memory, then the + * result will be as if the source elements were first copied to an + * intermediate location before being written into this buffer. + * + * @param src + * The source buffer from which doubles are to be read; + * must not be this buffer + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * for the remaining doubles in the source buffer + * + * @throws IllegalArgumentException + * If the source buffer is this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public DoubleBuffer put(DoubleBuffer src) { + if (src == this) + throw createSameBufferException(); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + + int srcPos = src.position(); + int srcLim = src.limit(); + int srcRem = (srcPos <= srcLim ? srcLim - srcPos : 0); + int pos = position(); + int lim = limit(); + int rem = (pos <= lim ? lim - pos : 0); + + if (srcRem > rem) + throw new BufferOverflowException(); + + putBuffer(pos, src, srcPos, srcRem); + + position(pos + srcRem); + src.position(srcPos + srcRem); + + return this; + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} doubles into this buffer from + * the given source buffer, starting at the given {@code offset} in the + * source buffer and the given {@code index} in this buffer. The positions + * of both buffers are unchanged. + * + *
In other words, an invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src.get(i));
+ * }
+ *
+ * except that it first checks the consistency of the supplied parameters
+ * and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
+ *
+ * @param index
+ * The index in this buffer at which the first double will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The buffer from which doubles are to be read
+ *
+ * @param offset
+ * The index within the source buffer of the first double to be
+ * read; must be non-negative and less than {@code src.limit()}
+ *
+ * @param length
+ * The number of doubles to be read from the given buffer;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.limit() - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 16
+ */
+ public DoubleBuffer put(int index, DoubleBuffer src, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.limit());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+
+ putBuffer(index, src, offset, length);
+
+ return this;
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ void putBuffer(int pos, DoubleBuffer src, int srcPos, int n) {
+
+ Object srcBase = src.base();
+
+
+
+ assert srcBase != null || src.isDirect();
+
+
+ Object base = base();
+ assert base != null || isDirect();
+
+ long srcAddr = src.address + ((long)srcPos << 3);
+ long addr = address + ((long)pos << 3);
+ long len = (long)n << 3;
+
+ try {
+
+ if (this.order() != src.order())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len, Double.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len);
+ } finally {
+ Reference.reachabilityFence(src);
+ Reference.reachabilityFence(this);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers doubles into this buffer from the given + * source array. If there are more doubles to be copied from the array + * than remain in this buffer, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * doubles are transferred and a {@link BufferOverflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} doubles from the + * given array into this buffer, starting at the given offset in the array + * and at the current position of this buffer. The position of this buffer + * is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * dst.put(src, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst.put(src[i]);
+ * }
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The array from which doubles are to be read
+ *
+ * @param offset
+ * The offset within the array of the first double to be read;
+ * must be non-negative and no larger than {@code src.length}
+ *
+ * @param length
+ * The number of doubles to be read from the given array;
+ * must be non-negative and no larger than
+ * {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public DoubleBuffer put(double[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(offset, length, src.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferOverflowException();
+
+ putArray(pos, src, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the entire content of the given source + * double array into this buffer. An invocation of this method of the + * form {@code dst.put(a)} behaves in exactly the same way as the + * invocation + * + * {@snippet lang=java : + * dst.put(a, 0, a.length) + * } + * + * @param src + * The source array + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final DoubleBuffer put(double[] src) { + return put(src, 0, src.length); + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} doubles from the given + * array, starting at the given offset in the array and at the given index + * in this buffer. The position of this buffer is unchanged. + * + *
An invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src[i]);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first double will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which doubles are to be read
+ *
+ * @param offset
+ * The offset within the array of the first double to be read;
+ * must be non-negative and less than {@code src.length}
+ *
+ * @param length
+ * The number of doubles to be read from the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public DoubleBuffer put(int index, double[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.length);
+
+ putArray(index, src, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk put method (optional operation).
+ *
+ *
This method copies doubles into this buffer from the given source
+ * array. The position of this buffer is unchanged. An invocation of this
+ * method of the form dst.put(index, src)
+ * behaves in exactly the same way as the invocation:
+ *
+ * {@snippet lang=java :
+ * dst.put(index, src, 0, src.length);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first double will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which doubles are to be read
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < src.length}
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public DoubleBuffer put(int index, double[] src) {
+ return put(index, src, 0, src.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ DoubleBuffer putArray(int index, double[] src, int offset, int length) {
+
+ if (
+
+
+
+ ((long)length << 3) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 3);
+ long srcOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 3);
+ long len = (long)length << 3;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len, Double.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++)
+ this.put(j, src[i]);
+ }
+ return this;
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ // -- Other stuff --
+
+ /**
+ * Tells whether or not this buffer is backed by an accessible double
+ * array.
+ *
+ *
If this method returns {@code true} then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *
+ * + * @return {@code true} if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the double array that backs this + * buffer (optional operation). + * + *Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final double[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer (optional operation). + * + *If this buffer is backed by an array then buffer position p + * corresponds to array index p + {@code arrayOffset()}. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + // -- Covariant return type overrides + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + DoubleBuffer position(int newPosition) { + super.position(newPosition); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + DoubleBuffer limit(int newLimit) { + super.limit(newLimit); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + DoubleBuffer mark() { + super.mark(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + DoubleBuffer reset() { + super.reset(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + DoubleBuffer clear() { + super.clear(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + DoubleBuffer flip() { + super.flip(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + DoubleBuffer rewind() { + super.rewind(); + return this; + } + + /** + * Compacts this buffer (optional operation). + * + *The doubles between the buffer's current position and its limit, + * if any, are copied to the beginning of the buffer. That is, the + * double at index p = {@code position()} is copied + * to index zero, the double at index p + 1 is copied + * to index one, and so forth until the double at index + * {@code limit()} - 1 is copied to index + * n = {@code limit()} - {@code 1} - p. + * The buffer's position is then set to n+1 and its limit is set to + * its capacity. The mark, if defined, is discarded. + * + *
The buffer's position is set to the number of doubles copied, + * rather than to zero, so that an invocation of this method can be + * followed immediately by an invocation of another relative put + * method.
+ * + + + + + + + + + + + + + + + + + * + * @return This buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract DoubleBuffer compact(); + + /** + * Tells whether or not this double buffer is direct. + * + * @return {@code true} if, and only if, this buffer is direct + */ + public abstract boolean isDirect(); + + + + + + + + + + + + + + + + + + /** + * Returns a string summarizing the state of this buffer. + * + * @return A summary string + */ + public String toString() { + return getClass().getName() + + "[pos=" + position() + + " lim=" + limit() + + " cap=" + capacity() + + "]"; + } + + + + + + + /** + * Returns the current hash code of this buffer. + * + *The hash code of a double buffer depends only upon its remaining + * elements; that is, upon the elements from {@code position()} up to, and + * including, the element at {@code limit()} - {@code 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.
+ * + * @return The current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) + + + + h = 31 * h + (int)get(i); + + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two double buffers are equal if, and only if, + * + *
They have the same element type,
They have the same number of remaining elements, and + *
The two sequences of remaining elements, considered + * independently of their starting positions, are pointwise equal. + + * This method considers two double elements {@code a} and {@code b} + * to be equal if + * {@code (a == b) || (Double.isNaN(a) && Double.isNaN(b))}. + * The values {@code -0.0} and {@code +0.0} are considered to be + * equal, unlike {@link Double#equals(Object)}. + + *
A double buffer is not equal to any other type of object.
+ * + * @param ob The object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(@Nullable Object ob) { + if (this == ob) + return true; + if (!(ob instanceof DoubleBuffer)) + return false; + DoubleBuffer that = (DoubleBuffer)ob; + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + if (thisRem < 0 || thisRem != thatRem) + return false; + return BufferMismatch.mismatch(this, thisPos, + that, thatPos, + thisRem) < 0; + } + + /** + * Compares this buffer to another. + * + *Two double buffers are compared by comparing their sequences of + * remaining elements lexicographically, without regard to the starting + * position of each sequence within its corresponding buffer. + + * Pairs of {@code double} elements are compared as if by invoking + * {@link Double#compare(double,double)}, except that + * {@code -0.0} and {@code 0.0} are considered to be equal. + * {@code Double.NaN} is considered by this method to be equal + * to itself and greater than all other {@code double} values + * (including {@code Double.POSITIVE_INFINITY}). + + + + + * + *
A double buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer + * is less than, equal to, or greater than the given buffer + */ + public int compareTo(DoubleBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int i = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + if (i >= 0) { + return compare(this.get(thisPos + i), that.get(thatPos + i)); + } + return thisRem - thatRem; + } + + private static int compare(double x, double y) { + + return ((x < y) ? -1 : + (x > y) ? +1 : + (x == y) ? 0 : + Double.isNaN(x) ? (Double.isNaN(y) ? 0 : +1) : -1); + + + + } + + /** + * Finds and returns the relative index of the first mismatch between this + * buffer and a given buffer. The index is relative to the + * {@link #position() position} of each buffer and will be in the range of + * 0 (inclusive) up to the smaller of the {@link #remaining() remaining} + * elements in each buffer (exclusive). + * + *
If the two buffers share a common prefix then the returned index is + * the length of the common prefix and it follows that there is a mismatch + * between the two buffers at that index within the respective buffers. + * If one buffer is a proper prefix of the other then the returned index is + * the smaller of the remaining elements in each buffer, and it follows that + * the index is only valid for the buffer with the larger number of + * remaining elements. + * Otherwise, there is no mismatch. + * + * @param that + * The byte buffer to be tested for a mismatch with this buffer + * + * @return The relative index of the first mismatch between this and the + * given buffer, otherwise -1 if no mismatch. + * + * @since 11 + */ + public int mismatch(DoubleBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int r = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + return (r == -1 && thisRem != thatRem) ? length : r; + } + + // -- Other char stuff -- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // -- Other byte stuff: Access to binary data -- + + + + /** + * Retrieves this buffer's byte order. + * + *
The byte order of a double buffer created by allocation or by + * wrapping an existing {@code double} array is the {@link + * ByteOrder#nativeOrder native order} of the underlying + * hardware. The byte order of a double buffer created as a view of a byte buffer is that of the + * byte buffer at the moment that the view is created.
+ * + * @return This buffer's byte order + */ + public abstract ByteOrder order(); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @ForceInline + @Override + int scaleShifts() { + return Integer.numberOfTrailingZeros(Double.BYTES); + } + + @ForceInline + @Override + AbstractMemorySegmentImpl heapSegment(Object base, + long offset, + long length, + boolean readOnly, + MemorySessionImpl bufferScope) { + return SegmentFactories.arrayOfDoubleSegment(base, offset, length, readOnly, bufferScope); + } + + + + + + + + + + + + + +} diff --git a/src/java.base/share/classes/java/nio/FloatBuffer.java b/src/java.base/share/classes/java/nio/FloatBuffer.java new file mode 100644 index 00000000000..ef139809f91 --- /dev/null +++ b/src/java.base/share/classes/java/nio/FloatBuffer.java @@ -0,0 +1,2425 @@ +/* + * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// -- This file was mechanically generated: Do not edit! -- // + +package java.nio; + +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + + + + +import java.lang.ref.Reference; + + + + + + +import jdk.internal.foreign.AbstractMemorySegmentImpl; +import jdk.internal.foreign.MemorySessionImpl; +import jdk.internal.foreign.SegmentFactories; +import jdk.internal.vm.annotation.ForceInline; +import java.lang.foreign.MemorySegment; +import java.util.Objects; +import jdk.internal.util.ArraysSupport; + +/** + * A float buffer. + * + *This class defines four categories of operations upon + * float buffers: + * + *
Absolute and relative {@link #get() get} and + * {@link #put(float) put} methods that read and write + * single floats;
Absolute and relative {@link #get(float[]) bulk get} + * methods that transfer contiguous sequences of floats from this buffer + * into an array;
Absolute and relative {@link #put(float[]) bulk put} + * methods that transfer contiguous sequences of floats from a + * float array or some other float + * buffer into this buffer;
A method for {@link #compact compacting} + * a float buffer.
Float buffers can be created either by {@link #allocate + * allocation}, which allocates space for the buffer's + * + + + + + + + * + * content, by {@link #wrap(float[]) wrapping} an existing + * float array into a buffer, or by creating a + * view of an existing byte buffer. + * + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +* + + * + *
Like a byte buffer, a float buffer is either direct or non-direct. A + * float buffer created via the {@code wrap} methods of this class will + * be non-direct. A float buffer created as a view of a byte buffer will + * be direct if, and only if, the byte buffer itself is direct. Whether or not + * a float buffer is direct may be determined by invoking the {@link + * #isDirect isDirect} method.
+ * + +* + + + + + + + + + + + * + + + + * + *Methods in this class that do not otherwise have a value to return are + * specified to return the buffer upon which they are invoked. This allows + * method invocations to be chained. + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + *
The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, each of its elements will be + * initialized to zero, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * It will have a {@link #array backing array}, and its + * {@link #arrayOffset array offset} will be zero. + * + * @param capacity + * The new buffer's capacity, in floats + * + * @return The new float buffer + * + * @throws IllegalArgumentException + * If the {@code capacity} is a negative integer + */ + public static FloatBuffer allocate(int capacity) { + if (capacity < 0) + throw createCapacityException(capacity); + return new HeapFloatBuffer(capacity, capacity, null); + } + + /** + * Wraps a float array into a buffer. + * + *
The new buffer will be backed by the given float array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity will be + * {@code array.length}, its position will be {@code offset}, its limit + * will be {@code offset + length}, its mark will be undefined, and its + * byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and + * its {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back the new buffer + * + * @param offset + * The offset of the subarray to be used; must be non-negative and + * no larger than {@code array.length}. The new buffer's position + * will be set to this value. + * + * @param length + * The length of the subarray to be used; + * must be non-negative and no larger than + * {@code array.length - offset}. + * The new buffer's limit will be set to {@code offset + length}. + * + * @return The new float buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code offset} and {@code length} + * parameters do not hold + */ + public static FloatBuffer wrap(float[] array, + int offset, int length) + { + try { + return new HeapFloatBuffer(array, offset, length, null); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps a float array into a buffer. + * + *The new buffer will be backed by the given float array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity and limit will be + * {@code array.length}, its position will be zero, its mark will be + * undefined, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and its + * {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back this buffer + * + * @return The new float buffer + */ + public static FloatBuffer wrap(float[] array) { + return wrap(array, 0, array.length); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** + * Creates a new float buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of floats remaining in this buffer, its mark will be + * undefined, and its byte order will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new float buffer + + + + + */ + @Override + public abstract FloatBuffer slice(); + + /** + * Creates a new float buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at position {@code index} + * in this buffer, and will contain {@code length} elements. Changes to + * this buffer's content will be visible in the new buffer, and vice versa; + * the two buffers' position, limit, and mark values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be {@code length}, its mark will be undefined, and its byte order + * will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, + * and it will be read-only if, and only if, this buffer is read-only.
+ * + * @param index + * The position in this buffer at which the content of the new + * buffer will start; must be non-negative and no larger than + * {@link #limit() limit()} + * + * @param length + * The number of elements the new buffer will contain; must be + * non-negative and no larger than {@code limit() - index} + * + * @return The new buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative or greater than {@code limit()}, + * {@code length} is negative, or {@code length > limit() - index} + * + * @since 13 + */ + @Override + public abstract FloatBuffer slice(int index, int length); + + /** + * Creates a new float buffer that shares this buffer's content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer, and vice + * versa; the two buffers' position, limit, and mark values will be + * independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new float buffer + */ + @Override + public abstract FloatBuffer duplicate(); + + /** + * Creates a new, read-only float buffer that shares this buffer's + * content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer; the new + * buffer itself, however, will be read-only and will not allow the shared + * content to be modified. The two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * + *
If this buffer is itself read-only then this method behaves in + * exactly the same way as the {@link #duplicate duplicate} method.
+ * + * @return The new, read-only float buffer + */ + public abstract FloatBuffer asReadOnlyBuffer(); + + + // -- Singleton get/put methods -- + + /** + * Relative get method. Reads the float at this buffer's + * current position, and then increments the position. + * + * @return The float at the buffer's current position + * + * @throws BufferUnderflowException + * If the buffer's current position is not smaller than its limit + */ + public abstract float get(); + + /** + * Relative put method (optional operation). + * + *Writes the given float into this buffer at the current + * position, and then increments the position.
+ * + * @param f + * The float to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If this buffer's current position is not smaller than its limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract FloatBuffer put(float f); + + /** + * Absolute get method. Reads the float at the given + * index. + * + * @param index + * The index from which the float will be read + * + * @return The float at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + */ + public abstract float get(int index); + + + + + + + + + + + + + + + /** + * Absolute put method (optional operation). + * + *Writes the given float into this buffer at the given + * index.
+ * + * @param index + * The index at which the float will be written + * + * @param f + * The float value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract FloatBuffer put(int index, float f); + + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers floats from this buffer into the given + * destination array. If there are fewer floats remaining in the + * buffer than are required to satisfy the request, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * floats are transferred and a {@link BufferUnderflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} floats from this + * buffer into the given array, starting at the current position of this + * buffer and at the given offset in the array. The position of this + * buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * src.get(dst, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst[i] = src.get();
+ * }
+ *
+ * except that it first checks that there are sufficient floats in
+ * this buffer and it is potentially much more efficient.
+ *
+ * @param dst
+ * The array into which floats are to be written
+ *
+ * @param offset
+ * The offset within the array of the first float to be
+ * written; must be non-negative and no larger than
+ * {@code dst.length}
+ *
+ * @param length
+ * The maximum number of floats to be written to the given
+ * array; must be non-negative and no larger than
+ * {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} floats
+ * remaining in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public FloatBuffer get(float[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(offset, length, dst.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferUnderflowException();
+
+ getArray(pos, dst, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk get method.
+ *
+ *
This method transfers floats from this buffer into the given + * destination array. An invocation of this method of the form + * {@code src.get(a)} behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * src.get(a, 0, a.length) + * } + * + * @param dst + * The destination array + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than {@code length} floats + * remaining in this buffer + */ + public FloatBuffer get(float[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Absolute bulk get method. + * + *
This method transfers {@code length} floats from this + * buffer into the given array, starting at the given index in this + * buffer and at the given offset in the array. The position of this + * buffer is unchanged. + * + *
An invocation of this method of the form
+ * src.get(index, dst, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst[i] = src.get(j);
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first float will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @param offset
+ * The offset within the array of the first float to be
+ * written; must be non-negative and less than
+ * {@code dst.length}
+ *
+ * @param length
+ * The number of floats to be written to the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @since 13
+ */
+ public FloatBuffer get(int index, float[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, dst.length);
+
+ getArray(index, dst, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk get method.
+ *
+ *
This method transfers floats from this buffer into the given
+ * destination array. The position of this buffer is unchanged. An
+ * invocation of this method of the form
+ * src.get(index, dst) behaves in exactly the same
+ * way as the invocation:
+ *
+ * {@snippet lang=java :
+ * src.get(index, dst, 0, dst.length)
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first float will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < dst.length}
+ *
+ * @since 13
+ */
+ public FloatBuffer get(int index, float[] dst) {
+ return get(index, dst, 0, dst.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ FloatBuffer getArray(int index, float[] dst, int offset, int length) {
+
+
+
+ if (((long)length << 2) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 2);
+ long dstOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 2);
+ long len = (long)length << 2;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len, Float.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++) {
+ dst[i] = get(j);
+ }
+ }
+ return this;
+ }
+
+ // -- Bulk put operations --
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the floats remaining in the given source + * buffer into this buffer. If there are more floats remaining in the + * source buffer than in this buffer, that is, if + * {@code src.remaining()} {@code >} {@code remaining()}, + * then no floats are transferred and a {@link + * BufferOverflowException} is thrown. + * + *
Otherwise, this method copies + * n = {@code src.remaining()} floats from the given + * buffer into this buffer, starting at each buffer's current position. + * The positions of both buffers are then incremented by n. + * + *
In other words, an invocation of this method of the form + * {@code dst.put(src)} has exactly the same effect as the loop + * + * {@snippet lang=java : + * while (src.hasRemaining()) + * dst.put(src.get()); + * } + * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. If this buffer and + * the source buffer share the same backing array or memory, then the + * result will be as if the source elements were first copied to an + * intermediate location before being written into this buffer. + * + * @param src + * The source buffer from which floats are to be read; + * must not be this buffer + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * for the remaining floats in the source buffer + * + * @throws IllegalArgumentException + * If the source buffer is this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public FloatBuffer put(FloatBuffer src) { + if (src == this) + throw createSameBufferException(); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + + int srcPos = src.position(); + int srcLim = src.limit(); + int srcRem = (srcPos <= srcLim ? srcLim - srcPos : 0); + int pos = position(); + int lim = limit(); + int rem = (pos <= lim ? lim - pos : 0); + + if (srcRem > rem) + throw new BufferOverflowException(); + + putBuffer(pos, src, srcPos, srcRem); + + position(pos + srcRem); + src.position(srcPos + srcRem); + + return this; + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} floats into this buffer from + * the given source buffer, starting at the given {@code offset} in the + * source buffer and the given {@code index} in this buffer. The positions + * of both buffers are unchanged. + * + *
In other words, an invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src.get(i));
+ * }
+ *
+ * except that it first checks the consistency of the supplied parameters
+ * and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
+ *
+ * @param index
+ * The index in this buffer at which the first float will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The buffer from which floats are to be read
+ *
+ * @param offset
+ * The index within the source buffer of the first float to be
+ * read; must be non-negative and less than {@code src.limit()}
+ *
+ * @param length
+ * The number of floats to be read from the given buffer;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.limit() - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 16
+ */
+ public FloatBuffer put(int index, FloatBuffer src, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.limit());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+
+ putBuffer(index, src, offset, length);
+
+ return this;
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ void putBuffer(int pos, FloatBuffer src, int srcPos, int n) {
+
+ Object srcBase = src.base();
+
+
+
+ assert srcBase != null || src.isDirect();
+
+
+ Object base = base();
+ assert base != null || isDirect();
+
+ long srcAddr = src.address + ((long)srcPos << 2);
+ long addr = address + ((long)pos << 2);
+ long len = (long)n << 2;
+
+ try {
+
+ if (this.order() != src.order())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len, Float.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len);
+ } finally {
+ Reference.reachabilityFence(src);
+ Reference.reachabilityFence(this);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers floats into this buffer from the given + * source array. If there are more floats to be copied from the array + * than remain in this buffer, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * floats are transferred and a {@link BufferOverflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} floats from the + * given array into this buffer, starting at the given offset in the array + * and at the current position of this buffer. The position of this buffer + * is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * dst.put(src, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst.put(src[i]);
+ * }
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The array from which floats are to be read
+ *
+ * @param offset
+ * The offset within the array of the first float to be read;
+ * must be non-negative and no larger than {@code src.length}
+ *
+ * @param length
+ * The number of floats to be read from the given array;
+ * must be non-negative and no larger than
+ * {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public FloatBuffer put(float[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(offset, length, src.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferOverflowException();
+
+ putArray(pos, src, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the entire content of the given source + * float array into this buffer. An invocation of this method of the + * form {@code dst.put(a)} behaves in exactly the same way as the + * invocation + * + * {@snippet lang=java : + * dst.put(a, 0, a.length) + * } + * + * @param src + * The source array + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final FloatBuffer put(float[] src) { + return put(src, 0, src.length); + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} floats from the given + * array, starting at the given offset in the array and at the given index + * in this buffer. The position of this buffer is unchanged. + * + *
An invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src[i]);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first float will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which floats are to be read
+ *
+ * @param offset
+ * The offset within the array of the first float to be read;
+ * must be non-negative and less than {@code src.length}
+ *
+ * @param length
+ * The number of floats to be read from the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public FloatBuffer put(int index, float[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.length);
+
+ putArray(index, src, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk put method (optional operation).
+ *
+ *
This method copies floats into this buffer from the given source
+ * array. The position of this buffer is unchanged. An invocation of this
+ * method of the form dst.put(index, src)
+ * behaves in exactly the same way as the invocation:
+ *
+ * {@snippet lang=java :
+ * dst.put(index, src, 0, src.length);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first float will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which floats are to be read
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < src.length}
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public FloatBuffer put(int index, float[] src) {
+ return put(index, src, 0, src.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ FloatBuffer putArray(int index, float[] src, int offset, int length) {
+
+ if (
+
+
+
+ ((long)length << 2) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 2);
+ long srcOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 2);
+ long len = (long)length << 2;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len, Float.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++)
+ this.put(j, src[i]);
+ }
+ return this;
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ // -- Other stuff --
+
+ /**
+ * Tells whether or not this buffer is backed by an accessible float
+ * array.
+ *
+ *
If this method returns {@code true} then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *
+ * + * @return {@code true} if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the float array that backs this + * buffer (optional operation). + * + *Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final float[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer (optional operation). + * + *If this buffer is backed by an array then buffer position p + * corresponds to array index p + {@code arrayOffset()}. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + // -- Covariant return type overrides + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + FloatBuffer position(int newPosition) { + super.position(newPosition); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + FloatBuffer limit(int newLimit) { + super.limit(newLimit); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + FloatBuffer mark() { + super.mark(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + FloatBuffer reset() { + super.reset(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + FloatBuffer clear() { + super.clear(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + FloatBuffer flip() { + super.flip(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + FloatBuffer rewind() { + super.rewind(); + return this; + } + + /** + * Compacts this buffer (optional operation). + * + *The floats between the buffer's current position and its limit, + * if any, are copied to the beginning of the buffer. That is, the + * float at index p = {@code position()} is copied + * to index zero, the float at index p + 1 is copied + * to index one, and so forth until the float at index + * {@code limit()} - 1 is copied to index + * n = {@code limit()} - {@code 1} - p. + * The buffer's position is then set to n+1 and its limit is set to + * its capacity. The mark, if defined, is discarded. + * + *
The buffer's position is set to the number of floats copied, + * rather than to zero, so that an invocation of this method can be + * followed immediately by an invocation of another relative put + * method.
+ * + + + + + + + + + + + + + + + + + * + * @return This buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract FloatBuffer compact(); + + /** + * Tells whether or not this float buffer is direct. + * + * @return {@code true} if, and only if, this buffer is direct + */ + public abstract boolean isDirect(); + + + + + + + + + + + + + + + + + + /** + * Returns a string summarizing the state of this buffer. + * + * @return A summary string + */ + public String toString() { + return getClass().getName() + + "[pos=" + position() + + " lim=" + limit() + + " cap=" + capacity() + + "]"; + } + + + + + + + /** + * Returns the current hash code of this buffer. + * + *The hash code of a float buffer depends only upon its remaining + * elements; that is, upon the elements from {@code position()} up to, and + * including, the element at {@code limit()} - {@code 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.
+ * + * @return The current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) + + + + h = 31 * h + (int)get(i); + + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two float buffers are equal if, and only if, + * + *
They have the same element type,
They have the same number of remaining elements, and + *
The two sequences of remaining elements, considered + * independently of their starting positions, are pointwise equal. + + * This method considers two float elements {@code a} and {@code b} + * to be equal if + * {@code (a == b) || (Float.isNaN(a) && Float.isNaN(b))}. + * The values {@code -0.0} and {@code +0.0} are considered to be + * equal, unlike {@link Float#equals(Object)}. + + *
A float buffer is not equal to any other type of object.
+ * + * @param ob The object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(@Nullable Object ob) { + if (this == ob) + return true; + if (!(ob instanceof FloatBuffer)) + return false; + FloatBuffer that = (FloatBuffer)ob; + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + if (thisRem < 0 || thisRem != thatRem) + return false; + return BufferMismatch.mismatch(this, thisPos, + that, thatPos, + thisRem) < 0; + } + + /** + * Compares this buffer to another. + * + *Two float buffers are compared by comparing their sequences of + * remaining elements lexicographically, without regard to the starting + * position of each sequence within its corresponding buffer. + + * Pairs of {@code float} elements are compared as if by invoking + * {@link Float#compare(float,float)}, except that + * {@code -0.0} and {@code 0.0} are considered to be equal. + * {@code Float.NaN} is considered by this method to be equal + * to itself and greater than all other {@code float} values + * (including {@code Float.POSITIVE_INFINITY}). + + + + + * + *
A float buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer + * is less than, equal to, or greater than the given buffer + */ + public int compareTo(FloatBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int i = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + if (i >= 0) { + return compare(this.get(thisPos + i), that.get(thatPos + i)); + } + return thisRem - thatRem; + } + + private static int compare(float x, float y) { + + return ((x < y) ? -1 : + (x > y) ? +1 : + (x == y) ? 0 : + Float.isNaN(x) ? (Float.isNaN(y) ? 0 : +1) : -1); + + + + } + + /** + * Finds and returns the relative index of the first mismatch between this + * buffer and a given buffer. The index is relative to the + * {@link #position() position} of each buffer and will be in the range of + * 0 (inclusive) up to the smaller of the {@link #remaining() remaining} + * elements in each buffer (exclusive). + * + *
If the two buffers share a common prefix then the returned index is + * the length of the common prefix and it follows that there is a mismatch + * between the two buffers at that index within the respective buffers. + * If one buffer is a proper prefix of the other then the returned index is + * the smaller of the remaining elements in each buffer, and it follows that + * the index is only valid for the buffer with the larger number of + * remaining elements. + * Otherwise, there is no mismatch. + * + * @param that + * The byte buffer to be tested for a mismatch with this buffer + * + * @return The relative index of the first mismatch between this and the + * given buffer, otherwise -1 if no mismatch. + * + * @since 11 + */ + public int mismatch(FloatBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int r = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + return (r == -1 && thisRem != thatRem) ? length : r; + } + + // -- Other char stuff -- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // -- Other byte stuff: Access to binary data -- + + + + /** + * Retrieves this buffer's byte order. + * + *
The byte order of a float buffer created by allocation or by + * wrapping an existing {@code float} array is the {@link + * ByteOrder#nativeOrder native order} of the underlying + * hardware. The byte order of a float buffer created as a view of a byte buffer is that of the + * byte buffer at the moment that the view is created.
+ * + * @return This buffer's byte order + */ + public abstract ByteOrder order(); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @ForceInline + @Override + int scaleShifts() { + return Integer.numberOfTrailingZeros(Float.BYTES); + } + + @ForceInline + @Override + AbstractMemorySegmentImpl heapSegment(Object base, + long offset, + long length, + boolean readOnly, + MemorySessionImpl bufferScope) { + return SegmentFactories.arrayOfFloatSegment(base, offset, length, readOnly, bufferScope); + } + + + + + + + + + + + + + +} diff --git a/src/java.base/share/classes/java/nio/IntBuffer.java b/src/java.base/share/classes/java/nio/IntBuffer.java new file mode 100644 index 00000000000..e40e3018b29 --- /dev/null +++ b/src/java.base/share/classes/java/nio/IntBuffer.java @@ -0,0 +1,2425 @@ +/* + * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// -- This file was mechanically generated: Do not edit! -- // + +package java.nio; + +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + + + + +import java.lang.ref.Reference; + + + + + + +import jdk.internal.foreign.AbstractMemorySegmentImpl; +import jdk.internal.foreign.MemorySessionImpl; +import jdk.internal.foreign.SegmentFactories; +import jdk.internal.vm.annotation.ForceInline; +import java.lang.foreign.MemorySegment; +import java.util.Objects; +import jdk.internal.util.ArraysSupport; + +/** + * An int buffer. + * + *This class defines four categories of operations upon + * int buffers: + * + *
Absolute and relative {@link #get() get} and + * {@link #put(int) put} methods that read and write + * single ints;
Absolute and relative {@link #get(int[]) bulk get} + * methods that transfer contiguous sequences of ints from this buffer + * into an array;
Absolute and relative {@link #put(int[]) bulk put} + * methods that transfer contiguous sequences of ints from an + * int array or some other int + * buffer into this buffer;
A method for {@link #compact compacting} + * an int buffer.
Int buffers can be created either by {@link #allocate + * allocation}, which allocates space for the buffer's + * + + + + + + + * + * content, by {@link #wrap(int[]) wrapping} an existing + * int array into a buffer, or by creating a + * view of an existing byte buffer. + * + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +* + + * + *
Like a byte buffer, an int buffer is either direct or non-direct. A + * int buffer created via the {@code wrap} methods of this class will + * be non-direct. An int buffer created as a view of a byte buffer will + * be direct if, and only if, the byte buffer itself is direct. Whether or not + * an int buffer is direct may be determined by invoking the {@link + * #isDirect isDirect} method.
+ * + +* + + + + + + + + + + + * + + + + * + *Methods in this class that do not otherwise have a value to return are + * specified to return the buffer upon which they are invoked. This allows + * method invocations to be chained. + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + *
The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, each of its elements will be + * initialized to zero, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * It will have a {@link #array backing array}, and its + * {@link #arrayOffset array offset} will be zero. + * + * @param capacity + * The new buffer's capacity, in ints + * + * @return The new int buffer + * + * @throws IllegalArgumentException + * If the {@code capacity} is a negative integer + */ + public static IntBuffer allocate(int capacity) { + if (capacity < 0) + throw createCapacityException(capacity); + return new HeapIntBuffer(capacity, capacity, null); + } + + /** + * Wraps an int array into a buffer. + * + *
The new buffer will be backed by the given int array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity will be + * {@code array.length}, its position will be {@code offset}, its limit + * will be {@code offset + length}, its mark will be undefined, and its + * byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and + * its {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back the new buffer + * + * @param offset + * The offset of the subarray to be used; must be non-negative and + * no larger than {@code array.length}. The new buffer's position + * will be set to this value. + * + * @param length + * The length of the subarray to be used; + * must be non-negative and no larger than + * {@code array.length - offset}. + * The new buffer's limit will be set to {@code offset + length}. + * + * @return The new int buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code offset} and {@code length} + * parameters do not hold + */ + public static IntBuffer wrap(int[] array, + int offset, int length) + { + try { + return new HeapIntBuffer(array, offset, length, null); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps an int array into a buffer. + * + *The new buffer will be backed by the given int array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity and limit will be + * {@code array.length}, its position will be zero, its mark will be + * undefined, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and its + * {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back this buffer + * + * @return The new int buffer + */ + public static IntBuffer wrap(int[] array) { + return wrap(array, 0, array.length); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** + * Creates a new int buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of ints remaining in this buffer, its mark will be + * undefined, and its byte order will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new int buffer + + + + + */ + @Override + public abstract IntBuffer slice(); + + /** + * Creates a new int buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at position {@code index} + * in this buffer, and will contain {@code length} elements. Changes to + * this buffer's content will be visible in the new buffer, and vice versa; + * the two buffers' position, limit, and mark values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be {@code length}, its mark will be undefined, and its byte order + * will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, + * and it will be read-only if, and only if, this buffer is read-only.
+ * + * @param index + * The position in this buffer at which the content of the new + * buffer will start; must be non-negative and no larger than + * {@link #limit() limit()} + * + * @param length + * The number of elements the new buffer will contain; must be + * non-negative and no larger than {@code limit() - index} + * + * @return The new buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative or greater than {@code limit()}, + * {@code length} is negative, or {@code length > limit() - index} + * + * @since 13 + */ + @Override + public abstract IntBuffer slice(int index, int length); + + /** + * Creates a new int buffer that shares this buffer's content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer, and vice + * versa; the two buffers' position, limit, and mark values will be + * independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new int buffer + */ + @Override + public abstract IntBuffer duplicate(); + + /** + * Creates a new, read-only int buffer that shares this buffer's + * content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer; the new + * buffer itself, however, will be read-only and will not allow the shared + * content to be modified. The two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * + *
If this buffer is itself read-only then this method behaves in + * exactly the same way as the {@link #duplicate duplicate} method.
+ * + * @return The new, read-only int buffer + */ + public abstract IntBuffer asReadOnlyBuffer(); + + + // -- Singleton get/put methods -- + + /** + * Relative get method. Reads the int at this buffer's + * current position, and then increments the position. + * + * @return The int at the buffer's current position + * + * @throws BufferUnderflowException + * If the buffer's current position is not smaller than its limit + */ + public abstract int get(); + + /** + * Relative put method (optional operation). + * + *Writes the given int into this buffer at the current + * position, and then increments the position.
+ * + * @param i + * The int to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If this buffer's current position is not smaller than its limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract IntBuffer put(int i); + + /** + * Absolute get method. Reads the int at the given + * index. + * + * @param index + * The index from which the int will be read + * + * @return The int at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + */ + public abstract int get(int index); + + + + + + + + + + + + + + + /** + * Absolute put method (optional operation). + * + *Writes the given int into this buffer at the given + * index.
+ * + * @param index + * The index at which the int will be written + * + * @param i + * The int value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract IntBuffer put(int index, int i); + + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers ints from this buffer into the given + * destination array. If there are fewer ints remaining in the + * buffer than are required to satisfy the request, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * ints are transferred and a {@link BufferUnderflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} ints from this + * buffer into the given array, starting at the current position of this + * buffer and at the given offset in the array. The position of this + * buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * src.get(dst, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst[i] = src.get();
+ * }
+ *
+ * except that it first checks that there are sufficient ints in
+ * this buffer and it is potentially much more efficient.
+ *
+ * @param dst
+ * The array into which ints are to be written
+ *
+ * @param offset
+ * The offset within the array of the first int to be
+ * written; must be non-negative and no larger than
+ * {@code dst.length}
+ *
+ * @param length
+ * The maximum number of ints to be written to the given
+ * array; must be non-negative and no larger than
+ * {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} ints
+ * remaining in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public IntBuffer get(int[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(offset, length, dst.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferUnderflowException();
+
+ getArray(pos, dst, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk get method.
+ *
+ *
This method transfers ints from this buffer into the given + * destination array. An invocation of this method of the form + * {@code src.get(a)} behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * src.get(a, 0, a.length) + * } + * + * @param dst + * The destination array + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than {@code length} ints + * remaining in this buffer + */ + public IntBuffer get(int[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Absolute bulk get method. + * + *
This method transfers {@code length} ints from this + * buffer into the given array, starting at the given index in this + * buffer and at the given offset in the array. The position of this + * buffer is unchanged. + * + *
An invocation of this method of the form
+ * src.get(index, dst, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst[i] = src.get(j);
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first int will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @param offset
+ * The offset within the array of the first int to be
+ * written; must be non-negative and less than
+ * {@code dst.length}
+ *
+ * @param length
+ * The number of ints to be written to the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @since 13
+ */
+ public IntBuffer get(int index, int[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, dst.length);
+
+ getArray(index, dst, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk get method.
+ *
+ *
This method transfers ints from this buffer into the given
+ * destination array. The position of this buffer is unchanged. An
+ * invocation of this method of the form
+ * src.get(index, dst) behaves in exactly the same
+ * way as the invocation:
+ *
+ * {@snippet lang=java :
+ * src.get(index, dst, 0, dst.length)
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first int will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < dst.length}
+ *
+ * @since 13
+ */
+ public IntBuffer get(int index, int[] dst) {
+ return get(index, dst, 0, dst.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ IntBuffer getArray(int index, int[] dst, int offset, int length) {
+
+
+
+ if (((long)length << 2) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 2);
+ long dstOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 2);
+ long len = (long)length << 2;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len, Integer.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++) {
+ dst[i] = get(j);
+ }
+ }
+ return this;
+ }
+
+ // -- Bulk put operations --
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the ints remaining in the given source + * buffer into this buffer. If there are more ints remaining in the + * source buffer than in this buffer, that is, if + * {@code src.remaining()} {@code >} {@code remaining()}, + * then no ints are transferred and a {@link + * BufferOverflowException} is thrown. + * + *
Otherwise, this method copies + * n = {@code src.remaining()} ints from the given + * buffer into this buffer, starting at each buffer's current position. + * The positions of both buffers are then incremented by n. + * + *
In other words, an invocation of this method of the form + * {@code dst.put(src)} has exactly the same effect as the loop + * + * {@snippet lang=java : + * while (src.hasRemaining()) + * dst.put(src.get()); + * } + * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. If this buffer and + * the source buffer share the same backing array or memory, then the + * result will be as if the source elements were first copied to an + * intermediate location before being written into this buffer. + * + * @param src + * The source buffer from which ints are to be read; + * must not be this buffer + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * for the remaining ints in the source buffer + * + * @throws IllegalArgumentException + * If the source buffer is this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public IntBuffer put(IntBuffer src) { + if (src == this) + throw createSameBufferException(); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + + int srcPos = src.position(); + int srcLim = src.limit(); + int srcRem = (srcPos <= srcLim ? srcLim - srcPos : 0); + int pos = position(); + int lim = limit(); + int rem = (pos <= lim ? lim - pos : 0); + + if (srcRem > rem) + throw new BufferOverflowException(); + + putBuffer(pos, src, srcPos, srcRem); + + position(pos + srcRem); + src.position(srcPos + srcRem); + + return this; + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} ints into this buffer from + * the given source buffer, starting at the given {@code offset} in the + * source buffer and the given {@code index} in this buffer. The positions + * of both buffers are unchanged. + * + *
In other words, an invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src.get(i));
+ * }
+ *
+ * except that it first checks the consistency of the supplied parameters
+ * and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
+ *
+ * @param index
+ * The index in this buffer at which the first int will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The buffer from which ints are to be read
+ *
+ * @param offset
+ * The index within the source buffer of the first int to be
+ * read; must be non-negative and less than {@code src.limit()}
+ *
+ * @param length
+ * The number of ints to be read from the given buffer;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.limit() - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 16
+ */
+ public IntBuffer put(int index, IntBuffer src, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.limit());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+
+ putBuffer(index, src, offset, length);
+
+ return this;
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ void putBuffer(int pos, IntBuffer src, int srcPos, int n) {
+
+ Object srcBase = src.base();
+
+
+
+ assert srcBase != null || src.isDirect();
+
+
+ Object base = base();
+ assert base != null || isDirect();
+
+ long srcAddr = src.address + ((long)srcPos << 2);
+ long addr = address + ((long)pos << 2);
+ long len = (long)n << 2;
+
+ try {
+
+ if (this.order() != src.order())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len, Integer.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len);
+ } finally {
+ Reference.reachabilityFence(src);
+ Reference.reachabilityFence(this);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers ints into this buffer from the given + * source array. If there are more ints to be copied from the array + * than remain in this buffer, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * ints are transferred and a {@link BufferOverflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} ints from the + * given array into this buffer, starting at the given offset in the array + * and at the current position of this buffer. The position of this buffer + * is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * dst.put(src, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst.put(src[i]);
+ * }
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The array from which ints are to be read
+ *
+ * @param offset
+ * The offset within the array of the first int to be read;
+ * must be non-negative and no larger than {@code src.length}
+ *
+ * @param length
+ * The number of ints to be read from the given array;
+ * must be non-negative and no larger than
+ * {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public IntBuffer put(int[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(offset, length, src.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferOverflowException();
+
+ putArray(pos, src, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the entire content of the given source + * int array into this buffer. An invocation of this method of the + * form {@code dst.put(a)} behaves in exactly the same way as the + * invocation + * + * {@snippet lang=java : + * dst.put(a, 0, a.length) + * } + * + * @param src + * The source array + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final IntBuffer put(int[] src) { + return put(src, 0, src.length); + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} ints from the given + * array, starting at the given offset in the array and at the given index + * in this buffer. The position of this buffer is unchanged. + * + *
An invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src[i]);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first int will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which ints are to be read
+ *
+ * @param offset
+ * The offset within the array of the first int to be read;
+ * must be non-negative and less than {@code src.length}
+ *
+ * @param length
+ * The number of ints to be read from the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public IntBuffer put(int index, int[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.length);
+
+ putArray(index, src, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk put method (optional operation).
+ *
+ *
This method copies ints into this buffer from the given source
+ * array. The position of this buffer is unchanged. An invocation of this
+ * method of the form dst.put(index, src)
+ * behaves in exactly the same way as the invocation:
+ *
+ * {@snippet lang=java :
+ * dst.put(index, src, 0, src.length);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first int will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which ints are to be read
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < src.length}
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public IntBuffer put(int index, int[] src) {
+ return put(index, src, 0, src.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ IntBuffer putArray(int index, int[] src, int offset, int length) {
+
+ if (
+
+
+
+ ((long)length << 2) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 2);
+ long srcOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 2);
+ long len = (long)length << 2;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len, Integer.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++)
+ this.put(j, src[i]);
+ }
+ return this;
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ // -- Other stuff --
+
+ /**
+ * Tells whether or not this buffer is backed by an accessible int
+ * array.
+ *
+ *
If this method returns {@code true} then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *
+ * + * @return {@code true} if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the int array that backs this + * buffer (optional operation). + * + *Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer (optional operation). + * + *If this buffer is backed by an array then buffer position p + * corresponds to array index p + {@code arrayOffset()}. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + // -- Covariant return type overrides + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + IntBuffer position(int newPosition) { + super.position(newPosition); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + IntBuffer limit(int newLimit) { + super.limit(newLimit); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + IntBuffer mark() { + super.mark(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + IntBuffer reset() { + super.reset(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + IntBuffer clear() { + super.clear(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + IntBuffer flip() { + super.flip(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + IntBuffer rewind() { + super.rewind(); + return this; + } + + /** + * Compacts this buffer (optional operation). + * + *The ints between the buffer's current position and its limit, + * if any, are copied to the beginning of the buffer. That is, the + * int at index p = {@code position()} is copied + * to index zero, the int at index p + 1 is copied + * to index one, and so forth until the int at index + * {@code limit()} - 1 is copied to index + * n = {@code limit()} - {@code 1} - p. + * The buffer's position is then set to n+1 and its limit is set to + * its capacity. The mark, if defined, is discarded. + * + *
The buffer's position is set to the number of ints copied, + * rather than to zero, so that an invocation of this method can be + * followed immediately by an invocation of another relative put + * method.
+ * + + + + + + + + + + + + + + + + + * + * @return This buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract IntBuffer compact(); + + /** + * Tells whether or not this int buffer is direct. + * + * @return {@code true} if, and only if, this buffer is direct + */ + public abstract boolean isDirect(); + + + + + + + + + + + + + + + + + + /** + * Returns a string summarizing the state of this buffer. + * + * @return A summary string + */ + public String toString() { + return getClass().getName() + + "[pos=" + position() + + " lim=" + limit() + + " cap=" + capacity() + + "]"; + } + + + + + + + /** + * Returns the current hash code of this buffer. + * + *The hash code of a int buffer depends only upon its remaining + * elements; that is, upon the elements from {@code position()} up to, and + * including, the element at {@code limit()} - {@code 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.
+ * + * @return The current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) + + h = 31 * h + get(i); + + + + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two int buffers are equal if, and only if, + * + *
They have the same element type,
They have the same number of remaining elements, and + *
The two sequences of remaining elements, considered + * independently of their starting positions, are pointwise equal. + + + + + + + + *
A int buffer is not equal to any other type of object.
+ * + * @param ob The object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(@Nullable Object ob) { + if (this == ob) + return true; + if (!(ob instanceof IntBuffer)) + return false; + IntBuffer that = (IntBuffer)ob; + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + if (thisRem < 0 || thisRem != thatRem) + return false; + return BufferMismatch.mismatch(this, thisPos, + that, thatPos, + thisRem) < 0; + } + + /** + * Compares this buffer to another. + * + *Two int buffers are compared by comparing their sequences of + * remaining elements lexicographically, without regard to the starting + * position of each sequence within its corresponding buffer. + + + + + + + + + * Pairs of {@code int} elements are compared as if by invoking + * {@link Integer#compare(int,int)}. + + * + *
A int buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer + * is less than, equal to, or greater than the given buffer + */ + public int compareTo(IntBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int i = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + if (i >= 0) { + return compare(this.get(thisPos + i), that.get(thatPos + i)); + } + return thisRem - thatRem; + } + + private static int compare(int x, int y) { + + + + + + + return Integer.compare(x, y); + + } + + /** + * Finds and returns the relative index of the first mismatch between this + * buffer and a given buffer. The index is relative to the + * {@link #position() position} of each buffer and will be in the range of + * 0 (inclusive) up to the smaller of the {@link #remaining() remaining} + * elements in each buffer (exclusive). + * + *
If the two buffers share a common prefix then the returned index is + * the length of the common prefix and it follows that there is a mismatch + * between the two buffers at that index within the respective buffers. + * If one buffer is a proper prefix of the other then the returned index is + * the smaller of the remaining elements in each buffer, and it follows that + * the index is only valid for the buffer with the larger number of + * remaining elements. + * Otherwise, there is no mismatch. + * + * @param that + * The byte buffer to be tested for a mismatch with this buffer + * + * @return The relative index of the first mismatch between this and the + * given buffer, otherwise -1 if no mismatch. + * + * @since 11 + */ + public int mismatch(IntBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int r = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + return (r == -1 && thisRem != thatRem) ? length : r; + } + + // -- Other char stuff -- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // -- Other byte stuff: Access to binary data -- + + + + /** + * Retrieves this buffer's byte order. + * + *
The byte order of an int buffer created by allocation or by + * wrapping an existing {@code int} array is the {@link + * ByteOrder#nativeOrder native order} of the underlying + * hardware. The byte order of an int buffer created as a view of a byte buffer is that of the + * byte buffer at the moment that the view is created.
+ * + * @return This buffer's byte order + */ + public abstract ByteOrder order(); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @ForceInline + @Override + int scaleShifts() { + return Integer.numberOfTrailingZeros(Integer.BYTES); + } + + @ForceInline + @Override + AbstractMemorySegmentImpl heapSegment(Object base, + long offset, + long length, + boolean readOnly, + MemorySessionImpl bufferScope) { + return SegmentFactories.arrayOfIntSegment(base, offset, length, readOnly, bufferScope); + } + + + + + + + + + + + + + +} diff --git a/src/java.base/share/classes/java/nio/LongBuffer.java b/src/java.base/share/classes/java/nio/LongBuffer.java new file mode 100644 index 00000000000..c0b99970643 --- /dev/null +++ b/src/java.base/share/classes/java/nio/LongBuffer.java @@ -0,0 +1,2425 @@ +/* + * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// -- This file was mechanically generated: Do not edit! -- // + +package java.nio; + +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + + + + +import java.lang.ref.Reference; + + + + + + +import jdk.internal.foreign.AbstractMemorySegmentImpl; +import jdk.internal.foreign.MemorySessionImpl; +import jdk.internal.foreign.SegmentFactories; +import jdk.internal.vm.annotation.ForceInline; +import java.lang.foreign.MemorySegment; +import java.util.Objects; +import jdk.internal.util.ArraysSupport; + +/** + * A long buffer. + * + *This class defines four categories of operations upon + * long buffers: + * + *
Absolute and relative {@link #get() get} and + * {@link #put(long) put} methods that read and write + * single longs;
Absolute and relative {@link #get(long[]) bulk get} + * methods that transfer contiguous sequences of longs from this buffer + * into an array;
Absolute and relative {@link #put(long[]) bulk put} + * methods that transfer contiguous sequences of longs from a + * long array or some other long + * buffer into this buffer;
A method for {@link #compact compacting} + * a long buffer.
Long buffers can be created either by {@link #allocate + * allocation}, which allocates space for the buffer's + * + + + + + + + * + * content, by {@link #wrap(long[]) wrapping} an existing + * long array into a buffer, or by creating a + * view of an existing byte buffer. + * + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +* + + * + *
Like a byte buffer, a long buffer is either direct or non-direct. A + * long buffer created via the {@code wrap} methods of this class will + * be non-direct. A long buffer created as a view of a byte buffer will + * be direct if, and only if, the byte buffer itself is direct. Whether or not + * a long buffer is direct may be determined by invoking the {@link + * #isDirect isDirect} method.
+ * + +* + + + + + + + + + + + * + + + + * + *Methods in this class that do not otherwise have a value to return are + * specified to return the buffer upon which they are invoked. This allows + * method invocations to be chained. + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + *
The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, each of its elements will be + * initialized to zero, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * It will have a {@link #array backing array}, and its + * {@link #arrayOffset array offset} will be zero. + * + * @param capacity + * The new buffer's capacity, in longs + * + * @return The new long buffer + * + * @throws IllegalArgumentException + * If the {@code capacity} is a negative integer + */ + public static LongBuffer allocate(int capacity) { + if (capacity < 0) + throw createCapacityException(capacity); + return new HeapLongBuffer(capacity, capacity, null); + } + + /** + * Wraps a long array into a buffer. + * + *
The new buffer will be backed by the given long array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity will be + * {@code array.length}, its position will be {@code offset}, its limit + * will be {@code offset + length}, its mark will be undefined, and its + * byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and + * its {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back the new buffer + * + * @param offset + * The offset of the subarray to be used; must be non-negative and + * no larger than {@code array.length}. The new buffer's position + * will be set to this value. + * + * @param length + * The length of the subarray to be used; + * must be non-negative and no larger than + * {@code array.length - offset}. + * The new buffer's limit will be set to {@code offset + length}. + * + * @return The new long buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code offset} and {@code length} + * parameters do not hold + */ + public static LongBuffer wrap(long[] array, + int offset, int length) + { + try { + return new HeapLongBuffer(array, offset, length, null); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps a long array into a buffer. + * + *The new buffer will be backed by the given long array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity and limit will be + * {@code array.length}, its position will be zero, its mark will be + * undefined, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and its + * {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back this buffer + * + * @return The new long buffer + */ + public static LongBuffer wrap(long[] array) { + return wrap(array, 0, array.length); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** + * Creates a new long buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of longs remaining in this buffer, its mark will be + * undefined, and its byte order will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new long buffer + + + + + */ + @Override + public abstract LongBuffer slice(); + + /** + * Creates a new long buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at position {@code index} + * in this buffer, and will contain {@code length} elements. Changes to + * this buffer's content will be visible in the new buffer, and vice versa; + * the two buffers' position, limit, and mark values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be {@code length}, its mark will be undefined, and its byte order + * will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, + * and it will be read-only if, and only if, this buffer is read-only.
+ * + * @param index + * The position in this buffer at which the content of the new + * buffer will start; must be non-negative and no larger than + * {@link #limit() limit()} + * + * @param length + * The number of elements the new buffer will contain; must be + * non-negative and no larger than {@code limit() - index} + * + * @return The new buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative or greater than {@code limit()}, + * {@code length} is negative, or {@code length > limit() - index} + * + * @since 13 + */ + @Override + public abstract LongBuffer slice(int index, int length); + + /** + * Creates a new long buffer that shares this buffer's content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer, and vice + * versa; the two buffers' position, limit, and mark values will be + * independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new long buffer + */ + @Override + public abstract LongBuffer duplicate(); + + /** + * Creates a new, read-only long buffer that shares this buffer's + * content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer; the new + * buffer itself, however, will be read-only and will not allow the shared + * content to be modified. The two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * + *
If this buffer is itself read-only then this method behaves in + * exactly the same way as the {@link #duplicate duplicate} method.
+ * + * @return The new, read-only long buffer + */ + public abstract LongBuffer asReadOnlyBuffer(); + + + // -- Singleton get/put methods -- + + /** + * Relative get method. Reads the long at this buffer's + * current position, and then increments the position. + * + * @return The long at the buffer's current position + * + * @throws BufferUnderflowException + * If the buffer's current position is not smaller than its limit + */ + public abstract long get(); + + /** + * Relative put method (optional operation). + * + *Writes the given long into this buffer at the current + * position, and then increments the position.
+ * + * @param l + * The long to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If this buffer's current position is not smaller than its limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract LongBuffer put(long l); + + /** + * Absolute get method. Reads the long at the given + * index. + * + * @param index + * The index from which the long will be read + * + * @return The long at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + */ + public abstract long get(int index); + + + + + + + + + + + + + + + /** + * Absolute put method (optional operation). + * + *Writes the given long into this buffer at the given + * index.
+ * + * @param index + * The index at which the long will be written + * + * @param l + * The long value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract LongBuffer put(int index, long l); + + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers longs from this buffer into the given + * destination array. If there are fewer longs remaining in the + * buffer than are required to satisfy the request, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * longs are transferred and a {@link BufferUnderflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} longs from this + * buffer into the given array, starting at the current position of this + * buffer and at the given offset in the array. The position of this + * buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * src.get(dst, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * 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.
+ *
+ * @param dst
+ * The array into which longs are to be written
+ *
+ * @param offset
+ * The offset within the array of the first long to be
+ * written; must be non-negative and no larger than
+ * {@code dst.length}
+ *
+ * @param length
+ * The maximum number of longs to be written to the given
+ * array; must be non-negative and no larger than
+ * {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} longs
+ * remaining in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public LongBuffer get(long[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(offset, length, dst.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferUnderflowException();
+
+ getArray(pos, dst, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk get method.
+ *
+ *
This method transfers longs from this buffer into the given + * destination array. An invocation of this method of the form + * {@code src.get(a)} behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * src.get(a, 0, a.length) + * } + * + * @param dst + * The destination array + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than {@code length} longs + * remaining in this buffer + */ + public LongBuffer get(long[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Absolute bulk get method. + * + *
This method transfers {@code length} longs from this + * buffer into the given array, starting at the given index in this + * buffer and at the given offset in the array. The position of this + * buffer is unchanged. + * + *
An invocation of this method of the form
+ * src.get(index, dst, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst[i] = src.get(j);
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first long will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @param offset
+ * The offset within the array of the first long to be
+ * written; must be non-negative and less than
+ * {@code dst.length}
+ *
+ * @param length
+ * The number of longs to be written to the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @since 13
+ */
+ public LongBuffer get(int index, long[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, dst.length);
+
+ getArray(index, dst, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk get method.
+ *
+ *
This method transfers longs from this buffer into the given
+ * destination array. The position of this buffer is unchanged. An
+ * invocation of this method of the form
+ * src.get(index, dst) behaves in exactly the same
+ * way as the invocation:
+ *
+ * {@snippet lang=java :
+ * src.get(index, dst, 0, dst.length)
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first long will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < dst.length}
+ *
+ * @since 13
+ */
+ public LongBuffer get(int index, long[] dst) {
+ return get(index, dst, 0, dst.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ LongBuffer getArray(int index, long[] dst, int offset, int length) {
+
+
+
+ if (((long)length << 3) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 3);
+ long dstOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 3);
+ long len = (long)length << 3;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len, Long.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++) {
+ dst[i] = get(j);
+ }
+ }
+ return this;
+ }
+
+ // -- Bulk put operations --
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the longs remaining in the given source + * buffer into this buffer. If there are more longs remaining in the + * source buffer than in this buffer, that is, if + * {@code src.remaining()} {@code >} {@code remaining()}, + * then no longs are transferred and a {@link + * BufferOverflowException} is thrown. + * + *
Otherwise, this method copies + * n = {@code src.remaining()} longs from the given + * buffer into this buffer, starting at each buffer's current position. + * The positions of both buffers are then incremented by n. + * + *
In other words, an invocation of this method of the form + * {@code dst.put(src)} has exactly the same effect as the loop + * + * {@snippet lang=java : + * while (src.hasRemaining()) + * dst.put(src.get()); + * } + * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. If this buffer and + * the source buffer share the same backing array or memory, then the + * result will be as if the source elements were first copied to an + * intermediate location before being written into this buffer. + * + * @param src + * The source buffer from which longs are to be read; + * must not be this buffer + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * for the remaining longs in the source buffer + * + * @throws IllegalArgumentException + * If the source buffer is this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public LongBuffer put(LongBuffer src) { + if (src == this) + throw createSameBufferException(); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + + int srcPos = src.position(); + int srcLim = src.limit(); + int srcRem = (srcPos <= srcLim ? srcLim - srcPos : 0); + int pos = position(); + int lim = limit(); + int rem = (pos <= lim ? lim - pos : 0); + + if (srcRem > rem) + throw new BufferOverflowException(); + + putBuffer(pos, src, srcPos, srcRem); + + position(pos + srcRem); + src.position(srcPos + srcRem); + + return this; + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} longs into this buffer from + * the given source buffer, starting at the given {@code offset} in the + * source buffer and the given {@code index} in this buffer. The positions + * of both buffers are unchanged. + * + *
In other words, an invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src.get(i));
+ * }
+ *
+ * except that it first checks the consistency of the supplied parameters
+ * and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
+ *
+ * @param index
+ * The index in this buffer at which the first long will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The buffer from which longs are to be read
+ *
+ * @param offset
+ * The index within the source buffer of the first long to be
+ * read; must be non-negative and less than {@code src.limit()}
+ *
+ * @param length
+ * The number of longs to be read from the given buffer;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.limit() - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 16
+ */
+ public LongBuffer put(int index, LongBuffer src, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.limit());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+
+ putBuffer(index, src, offset, length);
+
+ return this;
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ void putBuffer(int pos, LongBuffer src, int srcPos, int n) {
+
+ Object srcBase = src.base();
+
+
+
+ assert srcBase != null || src.isDirect();
+
+
+ Object base = base();
+ assert base != null || isDirect();
+
+ long srcAddr = src.address + ((long)srcPos << 3);
+ long addr = address + ((long)pos << 3);
+ long len = (long)n << 3;
+
+ try {
+
+ if (this.order() != src.order())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len, Long.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len);
+ } finally {
+ Reference.reachabilityFence(src);
+ Reference.reachabilityFence(this);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers longs into this buffer from the given + * source array. If there are more longs to be copied from the array + * than remain in this buffer, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * longs are transferred and a {@link BufferOverflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} longs from the + * given array into this buffer, starting at the given offset in the array + * and at the current position of this buffer. The position of this buffer + * is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * dst.put(src, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst.put(src[i]);
+ * }
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The array from which longs are to be read
+ *
+ * @param offset
+ * The offset within the array of the first long to be read;
+ * must be non-negative and no larger than {@code src.length}
+ *
+ * @param length
+ * The number of longs to be read from the given array;
+ * must be non-negative and no larger than
+ * {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public LongBuffer put(long[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(offset, length, src.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferOverflowException();
+
+ putArray(pos, src, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the entire content of the given source + * long array into this buffer. An invocation of this method of the + * form {@code dst.put(a)} behaves in exactly the same way as the + * invocation + * + * {@snippet lang=java : + * dst.put(a, 0, a.length) + * } + * + * @param src + * The source array + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final LongBuffer put(long[] src) { + return put(src, 0, src.length); + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} longs from the given + * array, starting at the given offset in the array and at the given index + * in this buffer. The position of this buffer is unchanged. + * + *
An invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src[i]);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first long will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which longs are to be read
+ *
+ * @param offset
+ * The offset within the array of the first long to be read;
+ * must be non-negative and less than {@code src.length}
+ *
+ * @param length
+ * The number of longs to be read from the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public LongBuffer put(int index, long[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.length);
+
+ putArray(index, src, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk put method (optional operation).
+ *
+ *
This method copies longs into this buffer from the given source
+ * array. The position of this buffer is unchanged. An invocation of this
+ * method of the form dst.put(index, src)
+ * behaves in exactly the same way as the invocation:
+ *
+ * {@snippet lang=java :
+ * dst.put(index, src, 0, src.length);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first long will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which longs are to be read
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < src.length}
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public LongBuffer put(int index, long[] src) {
+ return put(index, src, 0, src.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ LongBuffer putArray(int index, long[] src, int offset, int length) {
+
+ if (
+
+
+
+ ((long)length << 3) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 3);
+ long srcOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 3);
+ long len = (long)length << 3;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len, Long.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++)
+ this.put(j, src[i]);
+ }
+ return this;
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ // -- Other stuff --
+
+ /**
+ * Tells whether or not this buffer is backed by an accessible long
+ * array.
+ *
+ *
If this method returns {@code true} then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *
+ * + * @return {@code true} if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the long array that backs this + * buffer (optional operation). + * + *Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final long[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer (optional operation). + * + *If this buffer is backed by an array then buffer position p + * corresponds to array index p + {@code arrayOffset()}. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + // -- Covariant return type overrides + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + LongBuffer position(int newPosition) { + super.position(newPosition); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + LongBuffer limit(int newLimit) { + super.limit(newLimit); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + LongBuffer mark() { + super.mark(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + LongBuffer reset() { + super.reset(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + LongBuffer clear() { + super.clear(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + LongBuffer flip() { + super.flip(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + LongBuffer rewind() { + super.rewind(); + return this; + } + + /** + * Compacts this buffer (optional operation). + * + *The longs between the buffer's current position and its limit, + * if any, are copied to the beginning of the buffer. That is, the + * long at index p = {@code position()} is copied + * to index zero, the long at index p + 1 is copied + * to index one, and so forth until the long at index + * {@code limit()} - 1 is copied to index + * n = {@code limit()} - {@code 1} - p. + * The buffer's position is then set to n+1 and its limit is set to + * its capacity. The mark, if defined, is discarded. + * + *
The buffer's position is set to the number of longs copied, + * rather than to zero, so that an invocation of this method can be + * followed immediately by an invocation of another relative put + * method.
+ * + + + + + + + + + + + + + + + + + * + * @return This buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract LongBuffer compact(); + + /** + * Tells whether or not this long buffer is direct. + * + * @return {@code true} if, and only if, this buffer is direct + */ + public abstract boolean isDirect(); + + + + + + + + + + + + + + + + + + /** + * Returns a string summarizing the state of this buffer. + * + * @return A summary string + */ + public String toString() { + return getClass().getName() + + "[pos=" + position() + + " lim=" + limit() + + " cap=" + capacity() + + "]"; + } + + + + + + + /** + * 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 {@code position()} up to, and + * including, the element at {@code limit()} - {@code 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.
+ * + * @return The current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) + + + + h = 31 * h + (int)get(i); + + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two long buffers are equal if, and only if, + * + *
They have the same element type,
They have the same number of remaining elements, and + *
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.
+ * + * @param ob The object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(@Nullable Object ob) { + if (this == ob) + return true; + if (!(ob instanceof LongBuffer)) + return false; + LongBuffer that = (LongBuffer)ob; + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + if (thisRem < 0 || thisRem != thatRem) + return false; + return BufferMismatch.mismatch(this, thisPos, + that, thatPos, + thisRem) < 0; + } + + /** + * 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. + + + + + + + + + * Pairs of {@code long} elements are compared as if by invoking + * {@link Long#compare(long,long)}. + + * + *
A long buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer + * is less than, equal to, or greater than the given buffer + */ + public int compareTo(LongBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int i = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + if (i >= 0) { + return compare(this.get(thisPos + i), that.get(thatPos + i)); + } + return thisRem - thatRem; + } + + private static int compare(long x, long y) { + + + + + + + return Long.compare(x, y); + + } + + /** + * Finds and returns the relative index of the first mismatch between this + * buffer and a given buffer. The index is relative to the + * {@link #position() position} of each buffer and will be in the range of + * 0 (inclusive) up to the smaller of the {@link #remaining() remaining} + * elements in each buffer (exclusive). + * + *
If the two buffers share a common prefix then the returned index is + * the length of the common prefix and it follows that there is a mismatch + * between the two buffers at that index within the respective buffers. + * If one buffer is a proper prefix of the other then the returned index is + * the smaller of the remaining elements in each buffer, and it follows that + * the index is only valid for the buffer with the larger number of + * remaining elements. + * Otherwise, there is no mismatch. + * + * @param that + * The byte buffer to be tested for a mismatch with this buffer + * + * @return The relative index of the first mismatch between this and the + * given buffer, otherwise -1 if no mismatch. + * + * @since 11 + */ + public int mismatch(LongBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int r = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + return (r == -1 && thisRem != thatRem) ? length : r; + } + + // -- Other char stuff -- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // -- Other byte stuff: Access to binary data -- + + + + /** + * Retrieves this buffer's byte order. + * + *
The byte order of a long buffer created by allocation or by + * wrapping an existing {@code long} array is the {@link + * ByteOrder#nativeOrder native order} of the underlying + * hardware. The byte order of a long buffer created as a view of a byte buffer is that of the + * byte buffer at the moment that the view is created.
+ * + * @return This buffer's byte order + */ + public abstract ByteOrder order(); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @ForceInline + @Override + int scaleShifts() { + return Integer.numberOfTrailingZeros(Long.BYTES); + } + + @ForceInline + @Override + AbstractMemorySegmentImpl heapSegment(Object base, + long offset, + long length, + boolean readOnly, + MemorySessionImpl bufferScope) { + return SegmentFactories.arrayOfLongSegment(base, offset, length, readOnly, bufferScope); + } + + + + + + + + + + + + + +} diff --git a/src/java.base/share/classes/java/nio/ShortBuffer.java b/src/java.base/share/classes/java/nio/ShortBuffer.java new file mode 100644 index 00000000000..ac0e646e646 --- /dev/null +++ b/src/java.base/share/classes/java/nio/ShortBuffer.java @@ -0,0 +1,2425 @@ +/* + * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// -- This file was mechanically generated: Do not edit! -- // + +package java.nio; + +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + + + + +import java.lang.ref.Reference; + + + + + + +import jdk.internal.foreign.AbstractMemorySegmentImpl; +import jdk.internal.foreign.MemorySessionImpl; +import jdk.internal.foreign.SegmentFactories; +import jdk.internal.vm.annotation.ForceInline; +import java.lang.foreign.MemorySegment; +import java.util.Objects; +import jdk.internal.util.ArraysSupport; + +/** + * A short buffer. + * + *This class defines four categories of operations upon + * short buffers: + * + *
Absolute and relative {@link #get() get} and + * {@link #put(short) put} methods that read and write + * single shorts;
Absolute and relative {@link #get(short[]) bulk get} + * methods that transfer contiguous sequences of shorts from this buffer + * into an array;
Absolute and relative {@link #put(short[]) bulk put} + * methods that transfer contiguous sequences of shorts from a + * short array or some other short + * buffer into this buffer;
A method for {@link #compact compacting} + * a short buffer.
Short buffers can be created either by {@link #allocate + * allocation}, which allocates space for the buffer's + * + + + + + + + * + * content, by {@link #wrap(short[]) wrapping} an existing + * short array into a buffer, or by creating a + * view of an existing byte buffer. + * + + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +* + + * + *
Like a byte buffer, a short buffer is either direct or non-direct. A + * short buffer created via the {@code wrap} methods of this class will + * be non-direct. A short buffer created as a view of a byte buffer will + * be direct if, and only if, the byte buffer itself is direct. Whether or not + * a short buffer is direct may be determined by invoking the {@link + * #isDirect isDirect} method.
+ * + +* + + + + + + + + + + + * + + + + * + *Methods in this class that do not otherwise have a value to return are + * specified to return the buffer upon which they are invoked. This allows + * method invocations to be chained. + * + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + *
The new buffer's position will be zero, its limit will be its + * capacity, its mark will be undefined, each of its elements will be + * initialized to zero, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * It will have a {@link #array backing array}, and its + * {@link #arrayOffset array offset} will be zero. + * + * @param capacity + * The new buffer's capacity, in shorts + * + * @return The new short buffer + * + * @throws IllegalArgumentException + * If the {@code capacity} is a negative integer + */ + public static ShortBuffer allocate(int capacity) { + if (capacity < 0) + throw createCapacityException(capacity); + return new HeapShortBuffer(capacity, capacity, null); + } + + /** + * Wraps a short array into a buffer. + * + *
The new buffer will be backed by the given short array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity will be + * {@code array.length}, its position will be {@code offset}, its limit + * will be {@code offset + length}, its mark will be undefined, and its + * byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and + * its {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back the new buffer + * + * @param offset + * The offset of the subarray to be used; must be non-negative and + * no larger than {@code array.length}. The new buffer's position + * will be set to this value. + * + * @param length + * The length of the subarray to be used; + * must be non-negative and no larger than + * {@code array.length - offset}. + * The new buffer's limit will be set to {@code offset + length}. + * + * @return The new short buffer + * + * @throws IndexOutOfBoundsException + * If the preconditions on the {@code offset} and {@code length} + * parameters do not hold + */ + public static ShortBuffer wrap(short[] array, + int offset, int length) + { + try { + return new HeapShortBuffer(array, offset, length, null); + } catch (IllegalArgumentException x) { + throw new IndexOutOfBoundsException(); + } + } + + /** + * Wraps a short array into a buffer. + * + *The new buffer will be backed by the given short array; + * that is, modifications to the buffer will cause the array to be modified + * and vice versa. The new buffer's capacity and limit will be + * {@code array.length}, its position will be zero, its mark will be + * undefined, and its byte order will be + + + + * the {@link ByteOrder#nativeOrder native order} of the underlying + * hardware. + + * Its {@link #array backing array} will be the given array, and its + * {@link #arrayOffset array offset} will be zero.
+ * + * @param array + * The array that will back this buffer + * + * @return The new short buffer + */ + public static ShortBuffer wrap(short[] array) { + return wrap(array, 0, array.length); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** + * Creates a new short buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at this buffer's current + * position. Changes to this buffer's content will be visible in the new + * buffer, and vice versa; the two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be the number of shorts remaining in this buffer, its mark will be + * undefined, and its byte order will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new short buffer + + + + + */ + @Override + public abstract ShortBuffer slice(); + + /** + * Creates a new short buffer whose content is a shared subsequence of + * this buffer's content. + * + *The content of the new buffer will start at position {@code index} + * in this buffer, and will contain {@code length} elements. Changes to + * this buffer's content will be visible in the new buffer, and vice versa; + * the two buffers' position, limit, and mark values will be independent. + * + *
The new buffer's position will be zero, its capacity and its limit + * will be {@code length}, its mark will be undefined, and its byte order + * will be + + + + * identical to that of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, + * and it will be read-only if, and only if, this buffer is read-only.
+ * + * @param index + * The position in this buffer at which the content of the new + * buffer will start; must be non-negative and no larger than + * {@link #limit() limit()} + * + * @param length + * The number of elements the new buffer will contain; must be + * non-negative and no larger than {@code limit() - index} + * + * @return The new buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative or greater than {@code limit()}, + * {@code length} is negative, or {@code length > limit() - index} + * + * @since 13 + */ + @Override + public abstract ShortBuffer slice(int index, int length); + + /** + * Creates a new short buffer that shares this buffer's content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer, and vice + * versa; the two buffers' position, limit, and mark values will be + * independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * The new buffer will be direct if, and only if, this buffer is direct, and + * it will be read-only if, and only if, this buffer is read-only.
+ * + * @return The new short buffer + */ + @Override + public abstract ShortBuffer duplicate(); + + /** + * Creates a new, read-only short buffer that shares this buffer's + * content. + * + *The content of the new buffer will be that of this buffer. Changes + * to this buffer's content will be visible in the new buffer; the new + * buffer itself, however, will be read-only and will not allow the shared + * content to be modified. The two buffers' position, limit, and mark + * values will be independent. + * + *
The new buffer's capacity, limit, position, + + + + + * mark values, and byte order will be identical to those of this buffer. + + * + *
If this buffer is itself read-only then this method behaves in + * exactly the same way as the {@link #duplicate duplicate} method.
+ * + * @return The new, read-only short buffer + */ + public abstract ShortBuffer asReadOnlyBuffer(); + + + // -- Singleton get/put methods -- + + /** + * Relative get method. Reads the short at this buffer's + * current position, and then increments the position. + * + * @return The short at the buffer's current position + * + * @throws BufferUnderflowException + * If the buffer's current position is not smaller than its limit + */ + public abstract short get(); + + /** + * Relative put method (optional operation). + * + *Writes the given short into this buffer at the current + * position, and then increments the position.
+ * + * @param s + * The short to be written + * + * @return This buffer + * + * @throws BufferOverflowException + * If this buffer's current position is not smaller than its limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ShortBuffer put(short s); + + /** + * Absolute get method. Reads the short at the given + * index. + * + * @param index + * The index from which the short will be read + * + * @return The short at the given index + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + */ + public abstract short get(int index); + + + + + + + + + + + + + + + /** + * Absolute put method (optional operation). + * + *Writes the given short into this buffer at the given + * index.
+ * + * @param index + * The index at which the short will be written + * + * @param s + * The short value to be written + * + * @return This buffer + * + * @throws IndexOutOfBoundsException + * If {@code index} is negative + * or not smaller than the buffer's limit + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ShortBuffer put(int index, short s); + + + // -- Bulk get operations -- + + /** + * Relative bulk get method. + * + *This method transfers shorts from this buffer into the given + * destination array. If there are fewer shorts remaining in the + * buffer than are required to satisfy the request, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * shorts are transferred and a {@link BufferUnderflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} shorts from this + * buffer into the given array, starting at the current position of this + * buffer and at the given offset in the array. The position of this + * buffer is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * src.get(dst, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst[i] = src.get();
+ * }
+ *
+ * except that it first checks that there are sufficient shorts in
+ * this buffer and it is potentially much more efficient.
+ *
+ * @param dst
+ * The array into which shorts are to be written
+ *
+ * @param offset
+ * The offset within the array of the first short to be
+ * written; must be non-negative and no larger than
+ * {@code dst.length}
+ *
+ * @param length
+ * The maximum number of shorts to be written to the given
+ * array; must be non-negative and no larger than
+ * {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferUnderflowException
+ * If there are fewer than {@code length} shorts
+ * remaining in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ */
+ public ShortBuffer get(short[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(offset, length, dst.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferUnderflowException();
+
+ getArray(pos, dst, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk get method.
+ *
+ *
This method transfers shorts from this buffer into the given + * destination array. An invocation of this method of the form + * {@code src.get(a)} behaves in exactly the same way as the invocation + * + * {@snippet lang=java : + * src.get(a, 0, a.length) + * } + * + * @param dst + * The destination array + * + * @return This buffer + * + * @throws BufferUnderflowException + * If there are fewer than {@code length} shorts + * remaining in this buffer + */ + public ShortBuffer get(short[] dst) { + return get(dst, 0, dst.length); + } + + /** + * Absolute bulk get method. + * + *
This method transfers {@code length} shorts from this + * buffer into the given array, starting at the given index in this + * buffer and at the given offset in the array. The position of this + * buffer is unchanged. + * + *
An invocation of this method of the form
+ * src.get(index, dst, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst[i] = src.get(j);
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first short will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @param offset
+ * The offset within the array of the first short to be
+ * written; must be non-negative and less than
+ * {@code dst.length}
+ *
+ * @param length
+ * The number of shorts to be written to the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code dst.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @since 13
+ */
+ public ShortBuffer get(int index, short[] dst, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, dst.length);
+
+ getArray(index, dst, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk get method.
+ *
+ *
This method transfers shorts from this buffer into the given
+ * destination array. The position of this buffer is unchanged. An
+ * invocation of this method of the form
+ * src.get(index, dst) behaves in exactly the same
+ * way as the invocation:
+ *
+ * {@snippet lang=java :
+ * src.get(index, dst, 0, dst.length)
+ * }
+ *
+ * @param index
+ * The index in this buffer from which the first short will be
+ * read; must be non-negative and less than {@code limit()}
+ *
+ * @param dst
+ * The destination array
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < dst.length}
+ *
+ * @since 13
+ */
+ public ShortBuffer get(int index, short[] dst) {
+ return get(index, dst, 0, dst.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ ShortBuffer getArray(int index, short[] dst, int offset, int length) {
+
+
+
+ if (((long)length << 1) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 1);
+ long dstOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 1);
+ long len = (long)length << 1;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len, Short.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ session(), null, base(), bufAddr,
+ dst, dstOffset, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++) {
+ dst[i] = get(j);
+ }
+ }
+ return this;
+ }
+
+ // -- Bulk put operations --
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the shorts remaining in the given source + * buffer into this buffer. If there are more shorts remaining in the + * source buffer than in this buffer, that is, if + * {@code src.remaining()} {@code >} {@code remaining()}, + * then no shorts are transferred and a {@link + * BufferOverflowException} is thrown. + * + *
Otherwise, this method copies + * n = {@code src.remaining()} shorts from the given + * buffer into this buffer, starting at each buffer's current position. + * The positions of both buffers are then incremented by n. + * + *
In other words, an invocation of this method of the form + * {@code dst.put(src)} has exactly the same effect as the loop + * + * {@snippet lang=java : + * while (src.hasRemaining()) + * dst.put(src.get()); + * } + * + * except that it first checks that there is sufficient space in this + * buffer and it is potentially much more efficient. If this buffer and + * the source buffer share the same backing array or memory, then the + * result will be as if the source elements were first copied to an + * intermediate location before being written into this buffer. + * + * @param src + * The source buffer from which shorts are to be read; + * must not be this buffer + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * for the remaining shorts in the source buffer + * + * @throws IllegalArgumentException + * If the source buffer is this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public ShortBuffer put(ShortBuffer src) { + if (src == this) + throw createSameBufferException(); + if (isReadOnly()) + throw new ReadOnlyBufferException(); + + int srcPos = src.position(); + int srcLim = src.limit(); + int srcRem = (srcPos <= srcLim ? srcLim - srcPos : 0); + int pos = position(); + int lim = limit(); + int rem = (pos <= lim ? lim - pos : 0); + + if (srcRem > rem) + throw new BufferOverflowException(); + + putBuffer(pos, src, srcPos, srcRem); + + position(pos + srcRem); + src.position(srcPos + srcRem); + + return this; + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} shorts into this buffer from + * the given source buffer, starting at the given {@code offset} in the + * source buffer and the given {@code index} in this buffer. The positions + * of both buffers are unchanged. + * + *
In other words, an invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src.get(i));
+ * }
+ *
+ * except that it first checks the consistency of the supplied parameters
+ * and it is potentially much more efficient. If this buffer and
+ * the source buffer share the same backing array or memory, then the
+ * result will be as if the source elements were first copied to an
+ * intermediate location before being written into this buffer.
+ *
+ * @param index
+ * The index in this buffer at which the first short will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The buffer from which shorts are to be read
+ *
+ * @param offset
+ * The index within the source buffer of the first short to be
+ * read; must be non-negative and less than {@code src.limit()}
+ *
+ * @param length
+ * The number of shorts to be read from the given buffer;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.limit() - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 16
+ */
+ public ShortBuffer put(int index, ShortBuffer src, int offset, int length) {
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.limit());
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+
+ putBuffer(index, src, offset, length);
+
+ return this;
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ void putBuffer(int pos, ShortBuffer src, int srcPos, int n) {
+
+ Object srcBase = src.base();
+
+
+
+ assert srcBase != null || src.isDirect();
+
+
+ Object base = base();
+ assert base != null || isDirect();
+
+ long srcAddr = src.address + ((long)srcPos << 1);
+ long addr = address + ((long)pos << 1);
+ long len = (long)n << 1;
+
+ try {
+
+ if (this.order() != src.order())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len, Short.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ src.session(), session(), srcBase, srcAddr,
+ base, addr, len);
+ } finally {
+ Reference.reachabilityFence(src);
+ Reference.reachabilityFence(this);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers shorts into this buffer from the given + * source array. If there are more shorts to be copied from the array + * than remain in this buffer, that is, if + * {@code length} {@code >} {@code remaining()}, then no + * shorts are transferred and a {@link BufferOverflowException} is + * thrown. + * + *
Otherwise, this method copies {@code length} shorts from the + * given array into this buffer, starting at the given offset in the array + * and at the current position of this buffer. The position of this buffer + * is then incremented by {@code length}. + * + *
In other words, an invocation of this method of the form
+ * dst.put(src, off, len) has exactly the same effect as
+ * the loop
+ *
+ * {@snippet lang=java :
+ * for (int i = off; i < off + len; i++)
+ * dst.put(src[i]);
+ * }
+ *
+ * except that it first checks that there is sufficient space in this
+ * buffer and it is potentially much more efficient.
+ *
+ * @param src
+ * The array from which shorts are to be read
+ *
+ * @param offset
+ * The offset within the array of the first short to be read;
+ * must be non-negative and no larger than {@code src.length}
+ *
+ * @param length
+ * The number of shorts to be read from the given array;
+ * must be non-negative and no larger than
+ * {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws BufferOverflowException
+ * If there is insufficient space in this buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code offset} and {@code length}
+ * parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ */
+ public ShortBuffer put(short[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(offset, length, src.length);
+ int pos = position();
+ if (length > limit() - pos)
+ throw new BufferOverflowException();
+
+ putArray(pos, src, offset, length);
+
+ position(pos + length);
+ return this;
+ }
+
+ /**
+ * Relative bulk put method (optional operation).
+ *
+ *
This method transfers the entire content of the given source + * short array into this buffer. An invocation of this method of the + * form {@code dst.put(a)} behaves in exactly the same way as the + * invocation + * + * {@snippet lang=java : + * dst.put(a, 0, a.length) + * } + * + * @param src + * The source array + * + * @return This buffer + * + * @throws BufferOverflowException + * If there is insufficient space in this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public final ShortBuffer put(short[] src) { + return put(src, 0, src.length); + } + + /** + * Absolute bulk put method (optional operation). + * + *
This method transfers {@code length} shorts from the given + * array, starting at the given offset in the array and at the given index + * in this buffer. The position of this buffer is unchanged. + * + *
An invocation of this method of the form
+ * dst.put(index, src, offset, length)
+ * has exactly the same effect as the following loop except that it first
+ * checks the consistency of the supplied parameters and it is potentially
+ * much more efficient:
+ *
+ * {@snippet lang=java :
+ * for (int i = offset, j = index; i < offset + length; i++, j++)
+ * dst.put(j, src[i]);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first short will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which shorts are to be read
+ *
+ * @param offset
+ * The offset within the array of the first short to be read;
+ * must be non-negative and less than {@code src.length}
+ *
+ * @param length
+ * The number of shorts to be read from the given array;
+ * must be non-negative and no larger than the smaller of
+ * {@code limit() - index} and {@code src.length - offset}
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If the preconditions on the {@code index}, {@code offset}, and
+ * {@code length} parameters do not hold
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public ShortBuffer put(int index, short[] src, int offset, int length) {
+ if (isReadOnly())
+ throw new ReadOnlyBufferException();
+ Objects.checkFromIndexSize(index, length, limit());
+ Objects.checkFromIndexSize(offset, length, src.length);
+
+ putArray(index, src, offset, length);
+
+ return this;
+ }
+
+ /**
+ * Absolute bulk put method (optional operation).
+ *
+ *
This method copies shorts into this buffer from the given source
+ * array. The position of this buffer is unchanged. An invocation of this
+ * method of the form dst.put(index, src)
+ * behaves in exactly the same way as the invocation:
+ *
+ * {@snippet lang=java :
+ * dst.put(index, src, 0, src.length);
+ * }
+ *
+ * @param index
+ * The index in this buffer at which the first short will be
+ * written; must be non-negative and less than {@code limit()}
+ *
+ * @param src
+ * The array from which shorts are to be read
+ *
+ * @return This buffer
+ *
+ * @throws IndexOutOfBoundsException
+ * If {@code index} is negative, not smaller than {@code limit()},
+ * or {@code limit() - index < src.length}
+ *
+ * @throws ReadOnlyBufferException
+ * If this buffer is read-only
+ *
+ * @since 13
+ */
+ public ShortBuffer put(int index, short[] src) {
+ return put(index, src, 0, src.length);
+ }
+
+ //
+ // This method does not perform bounds checking which it expects
+ // will have been done by the caller
+ //
+ ShortBuffer putArray(int index, short[] src, int offset, int length) {
+
+ if (
+
+
+
+ ((long)length << 1) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
+ long bufAddr = address + ((long)index << 1);
+ long srcOffset =
+ ARRAY_BASE_OFFSET + ((long)offset << 1);
+ long len = (long)length << 1;
+
+ try {
+
+ if (order() != ByteOrder.nativeOrder())
+ SCOPED_MEMORY_ACCESS.copySwapMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len, Short.BYTES);
+ else
+
+ SCOPED_MEMORY_ACCESS.copyMemory(
+ null, session(), src, srcOffset,
+ base(), bufAddr, len);
+ } finally {
+ Reference.reachabilityFence(this);
+ }
+ } else {
+ int end = offset + length;
+ for (int i = offset, j = index; i < end; i++, j++)
+ this.put(j, src[i]);
+ }
+ return this;
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ // -- Other stuff --
+
+ /**
+ * Tells whether or not this buffer is backed by an accessible short
+ * array.
+ *
+ *
If this method returns {@code true} then the {@link #array() array} + * and {@link #arrayOffset() arrayOffset} methods may safely be invoked. + *
+ * + * @return {@code true} if, and only if, this buffer + * is backed by an array and is not read-only + */ + public final boolean hasArray() { + return (hb != null) && !isReadOnly; + } + + /** + * Returns the short array that backs this + * buffer (optional operation). + * + *Modifications to this buffer's content will cause the returned + * array's content to be modified, and vice versa. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The array that backs this buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final short[] array() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return hb; + } + + /** + * Returns the offset within this buffer's backing array of the first + * element of the buffer (optional operation). + * + *If this buffer is backed by an array then buffer position p + * corresponds to array index p + {@code arrayOffset()}. + * + *
Invoke the {@link #hasArray hasArray} method before invoking this + * method in order to ensure that this buffer has an accessible backing + * array.
+ * + * @return The offset within this buffer's array + * of the first element of the buffer + * + * @throws ReadOnlyBufferException + * If this buffer is backed by an array but is read-only + * + * @throws UnsupportedOperationException + * If this buffer is not backed by an accessible array + */ + public final int arrayOffset() { + if (hb == null) + throw new UnsupportedOperationException(); + if (isReadOnly) + throw new ReadOnlyBufferException(); + return offset; + } + + // -- Covariant return type overrides + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + ShortBuffer position(int newPosition) { + super.position(newPosition); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + ShortBuffer limit(int newLimit) { + super.limit(newLimit); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + ShortBuffer mark() { + super.mark(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + ShortBuffer reset() { + super.reset(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + ShortBuffer clear() { + super.clear(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + ShortBuffer flip() { + super.flip(); + return this; + } + + /** + * {@inheritDoc} + * @since 9 + */ + @Override + public + + final + + ShortBuffer rewind() { + super.rewind(); + return this; + } + + /** + * Compacts this buffer (optional operation). + * + *The shorts between the buffer's current position and its limit, + * if any, are copied to the beginning of the buffer. That is, the + * short at index p = {@code position()} is copied + * to index zero, the short at index p + 1 is copied + * to index one, and so forth until the short at index + * {@code limit()} - 1 is copied to index + * n = {@code limit()} - {@code 1} - p. + * The buffer's position is then set to n+1 and its limit is set to + * its capacity. The mark, if defined, is discarded. + * + *
The buffer's position is set to the number of shorts copied, + * rather than to zero, so that an invocation of this method can be + * followed immediately by an invocation of another relative put + * method.
+ * + + + + + + + + + + + + + + + + + * + * @return This buffer + * + * @throws ReadOnlyBufferException + * If this buffer is read-only + */ + public abstract ShortBuffer compact(); + + /** + * Tells whether or not this short buffer is direct. + * + * @return {@code true} if, and only if, this buffer is direct + */ + public abstract boolean isDirect(); + + + + + + + + + + + + + + + + + + /** + * Returns a string summarizing the state of this buffer. + * + * @return A summary string + */ + public String toString() { + return getClass().getName() + + "[pos=" + position() + + " lim=" + limit() + + " cap=" + capacity() + + "]"; + } + + + + + + + /** + * Returns the current hash code of this buffer. + * + *The hash code of a short buffer depends only upon its remaining + * elements; that is, upon the elements from {@code position()} up to, and + * including, the element at {@code limit()} - {@code 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.
+ * + * @return The current hash code of this buffer + */ + public int hashCode() { + int h = 1; + int p = position(); + for (int i = limit() - 1; i >= p; i--) + + + + h = 31 * h + (int)get(i); + + return h; + } + + /** + * Tells whether or not this buffer is equal to another object. + * + *Two short buffers are equal if, and only if, + * + *
They have the same element type,
They have the same number of remaining elements, and + *
The two sequences of remaining elements, considered + * independently of their starting positions, are pointwise equal. + + + + + + + + *
A short buffer is not equal to any other type of object.
+ * + * @param ob The object to which this buffer is to be compared + * + * @return {@code true} if, and only if, this buffer is equal to the + * given object + */ + public boolean equals(@Nullable Object ob) { + if (this == ob) + return true; + if (!(ob instanceof ShortBuffer)) + return false; + ShortBuffer that = (ShortBuffer)ob; + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + if (thisRem < 0 || thisRem != thatRem) + return false; + return BufferMismatch.mismatch(this, thisPos, + that, thatPos, + thisRem) < 0; + } + + /** + * Compares this buffer to another. + * + *Two short buffers are compared by comparing their sequences of + * remaining elements lexicographically, without regard to the starting + * position of each sequence within its corresponding buffer. + + + + + + + + + * Pairs of {@code short} elements are compared as if by invoking + * {@link Short#compare(short,short)}. + + * + *
A short buffer is not comparable to any other type of object. + * + * @return A negative integer, zero, or a positive integer as this buffer + * is less than, equal to, or greater than the given buffer + */ + public int compareTo(ShortBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int i = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + if (i >= 0) { + return compare(this.get(thisPos + i), that.get(thatPos + i)); + } + return thisRem - thatRem; + } + + private static int compare(short x, short y) { + + + + + + + return Short.compare(x, y); + + } + + /** + * Finds and returns the relative index of the first mismatch between this + * buffer and a given buffer. The index is relative to the + * {@link #position() position} of each buffer and will be in the range of + * 0 (inclusive) up to the smaller of the {@link #remaining() remaining} + * elements in each buffer (exclusive). + * + *
If the two buffers share a common prefix then the returned index is + * the length of the common prefix and it follows that there is a mismatch + * between the two buffers at that index within the respective buffers. + * If one buffer is a proper prefix of the other then the returned index is + * the smaller of the remaining elements in each buffer, and it follows that + * the index is only valid for the buffer with the larger number of + * remaining elements. + * Otherwise, there is no mismatch. + * + * @param that + * The byte buffer to be tested for a mismatch with this buffer + * + * @return The relative index of the first mismatch between this and the + * given buffer, otherwise -1 if no mismatch. + * + * @since 11 + */ + public int mismatch(ShortBuffer that) { + int thisPos = this.position(); + int thisRem = this.limit() - thisPos; + int thatPos = that.position(); + int thatRem = that.limit() - thatPos; + int length = Math.min(thisRem, thatRem); + if (length < 0) + return -1; + int r = BufferMismatch.mismatch(this, thisPos, + that, thatPos, + length); + return (r == -1 && thisRem != thatRem) ? length : r; + } + + // -- Other char stuff -- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // -- Other byte stuff: Access to binary data -- + + + + /** + * Retrieves this buffer's byte order. + * + *
The byte order of a short buffer created by allocation or by + * wrapping an existing {@code short} array is the {@link + * ByteOrder#nativeOrder native order} of the underlying + * hardware. The byte order of a short buffer created as a view of a byte buffer is that of the + * byte buffer at the moment that the view is created.
+ * + * @return This buffer's byte order + */ + public abstract ByteOrder order(); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @ForceInline + @Override + int scaleShifts() { + return Integer.numberOfTrailingZeros(Short.BYTES); + } + + @ForceInline + @Override + AbstractMemorySegmentImpl heapSegment(Object base, + long offset, + long length, + boolean readOnly, + MemorySessionImpl bufferScope) { + return SegmentFactories.arrayOfShortSegment(base, offset, length, readOnly, bufferScope); + } + + + + + + + + + + + + + +} diff --git a/src/java.base/share/classes/java/nio/X-Buffer.java.template b/src/java.base/share/classes/java/nio/X-Buffer.java.template index b2b96288d57..bd772fb7bb2 100644 --- a/src/java.base/share/classes/java/nio/X-Buffer.java.template +++ b/src/java.base/share/classes/java/nio/X-Buffer.java.template @@ -27,6 +27,9 @@ package java.nio; +import org.jspecify.annotations.NullMarked; +import org.jspecify.annotations.Nullable; + #if[char] import java.io.IOException; #end[char] @@ -289,6 +292,7 @@ import jdk.internal.util.ArraysSupport; * @since 1.4 */ +@NullMarked public abstract sealed class $Type$Buffer extends Buffer implements Comparable<$Type$Buffer>{#if[char]?, Appendable, CharSequence, Readable} @@ -1801,7 +1805,7 @@ public abstract sealed class $Type$Buffer * @return {@code true} if, and only if, this buffer is equal to the * given object */ - public boolean equals(Object ob) { + public boolean equals(@Nullable Object ob) { if (this == ob) return true; if (!(ob instanceof $Type$Buffer)) @@ -2092,7 +2096,7 @@ public abstract sealed class $Type$Buffer * * @since 1.5 */ - public $Type$Buffer append(CharSequence csq) { + public $Type$Buffer append(@Nullable CharSequence csq) { if (csq == null) return put("null"); else if (csq instanceof CharBuffer cb) @@ -2134,7 +2138,7 @@ public abstract sealed class $Type$Buffer * * @since 1.5 */ - public $Type$Buffer append(CharSequence csq, int start, int end) { + public $Type$Buffer append(@Nullable CharSequence csq, int start, int end) { if (csq instanceof CharBuffer cb) { Objects.checkFromToIndex(start, end, csq.length());