This class defines six categories of operations upon * byte buffers: * *
Absolute and relative {@link #get() get} and * {@link #put(byte) put} methods that read and write * single bytes;
Absolute and relative {@link #get(byte[]) bulk get} * methods that transfer contiguous sequences of bytes from this buffer * into an array;
Absolute and relative {@link #put(byte[]) bulk put} * methods that transfer contiguous sequences of bytes from a * byte array or some other byte * buffer into this buffer;
Absolute and relative {@link #getChar() get} * and {@link #putChar(char) put} methods that read and * write values of other primitive types, translating them to and from * sequences of bytes in a particular byte order;
Methods for creating view buffers, * 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 * * * content, or by {@link #wrap(byte[]) wrapping} an * existing byte array {#if[char]?or string} into a buffer. * * * * *
A byte buffer is either direct or non-direct. Given a * direct byte buffer, the Java virtual machine will make a best effort to * perform native I/O operations directly upon it. That is, it will attempt to * avoid copying the buffer's content to (or from) an intermediate buffer * before (or after) each invocation of one of the underlying operating * system's native I/O operations. * *
A direct byte buffer may be created by invoking the {@link * #allocateDirect(int) allocateDirect} factory method of this class. The * buffers returned by this method typically have somewhat higher allocation * and deallocation costs than non-direct buffers. The contents of direct * buffers may reside outside of the normal garbage-collected heap, and so * their impact upon the memory footprint of an application might not be * obvious. It is therefore recommended that direct buffers be allocated * primarily for large, long-lived buffers that are subject to the underlying * system's native I/O operations. In general it is best to allocate direct * buffers only when they yield a measurable gain in program performance. * *
A direct byte buffer may also be created by {@link * java.nio.channels.FileChannel#map mapping} a region of a file * directly into memory. An implementation of the Java platform may optionally * support the creation of direct byte buffers from native code via JNI. If an * instance of one of these kinds of buffers refers to an inaccessible region * of memory then an attempt to access that region will not change the buffer's * content and will cause an unspecified exception to be thrown either at the * time of the access or at some later time. * *
Whether a byte buffer is direct or non-direct may be determined by * invoking its {@link #isDirect isDirect} method. This method is provided so * that explicit buffer management can be done in performance-critical code. * * * *
This class defines methods for reading and writing values of all other * primitive types, except {@code boolean}. Primitive values are translated * to (or from) sequences of bytes according to the buffer's current byte * order, which may be retrieved and modified via the {@link #order order} * methods. Specific byte orders are represented by instances of the {@link * ByteOrder} class. The initial order of a byte buffer is always {@link * ByteOrder#BIG_ENDIAN BIG_ENDIAN}. * *
For access to heterogeneous binary data, that is, sequences of values of * different types, this class defines a family of absolute and relative * 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)}Corresponding methods are defined for the types {@code char, * short, int, long}, and {@code double}. The index * parameters of the absolute get and put methods are in terms of * bytes rather than of the type being read or written. * * * *
For access to homogeneous binary data, that is, sequences of values of * the same type, this class defines methods that can create views of a * given byte buffer. A view buffer is simply another buffer whose * content is backed by the byte buffer. Changes to the byte buffer's content * will be visible in the view buffer, and vice versa; the two buffers' * position, limit, and mark values are independent. The {@link * #asFloatBuffer() asFloatBuffer} method, for example, creates an instance of * the {@link FloatBuffer} class that is backed by the byte buffer upon which * the method is invoked. Corresponding view-creation methods are defined for * the types {@code char, short, int, long}, and {@code double}. * *
View buffers have three important advantages over the families of * type-specific get and put methods described above: * *
A view buffer is indexed not in terms of bytes but rather in terms * of the type-specific size of its values;
A view buffer provides relative bulk get and put * methods that can transfer contiguous sequences of values between a buffer * and an array or some other buffer of the same type; and
A view buffer is potentially much more efficient because it will * be direct if, and only if, its backing byte buffer is direct.
The byte order of a view buffer is fixed to be that of its byte buffer * at the time that the view is created.
* * * * *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 * *
* * can, for example, be replaced by the single statement * ** bb.putInt(0xCAFEBABE); * bb.putShort(3); * bb.putShort(45);
* * * * @author Mark Reinhold * @author JSR-51 Expert Group * @since 1.4 */ public abstract class ByteBuffer extends Buffer implements Comparable* bb.putInt(0xCAFEBABE).putShort(3).putShort(45);
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 * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. Whether or not it has a * {@link #hasArray backing array} is unspecified. * * @param capacity * The new buffer's capacity, in bytes * * @return The new byte buffer * * @throws IllegalArgumentException * If the {@code capacity} is a negative integer */ public static ByteBuffer allocateDirect(int capacity) { // Android-changed: Android's DirectByteBuffers carry a MemoryRef. // return new DirectByteBuffer(capacity); DirectByteBuffer.MemoryRef memoryRef = new DirectByteBuffer.MemoryRef(capacity); return new DirectByteBuffer(capacity, memoryRef); } /** * Allocates a new byte buffer. * *
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 * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. * 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 bytes * * @return The new byte buffer * * @throws IllegalArgumentException * If the {@code capacity} is a negative integer */ public static ByteBuffer allocate(int capacity) { if (capacity < 0) throw createCapacityException(capacity); // Android-removed: Removed MemorySegmentProxy not supported yet. return new HeapByteBuffer(capacity, capacity); } /** * Wraps a byte array into a buffer. * *
The new buffer will be backed by the given byte 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 * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. * 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 byte buffer * * @throws IndexOutOfBoundsException * If the preconditions on the {@code offset} and {@code length} * parameters do not hold */ public static ByteBuffer wrap(byte[] array, int offset, int length) { try { // Android-removed: Removed MemorySegmentProxy not supported yet. return new HeapByteBuffer(array, offset, length); } catch (IllegalArgumentException x) { throw new IndexOutOfBoundsException(); } } /** * Wraps a byte array into a buffer. * *The new buffer will be backed by the given byte 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 * {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. * 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 byte buffer */ public static ByteBuffer wrap(byte[] array) { return wrap(array, 0, array.length); } /** * 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 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, 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.
* * @return The new byte buffer * * @see #alignedSlice(int) */ @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. * *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, * and mark values will be identical to those of this buffer, 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.
* * @return The new byte buffer */ @Override public abstract ByteBuffer duplicate(); /** * Creates a new, read-only byte 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, * and mark values will be identical to those of this buffer, and its byte * order will be {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}. * *
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 byte buffer */ public abstract ByteBuffer asReadOnlyBuffer(); // -- Singleton get/put methods -- /** * Relative get method. Reads the byte at this buffer's * current position, and then increments the position. * * @return The byte at the buffer's current position * * @throws BufferUnderflowException * If the buffer's current position is not smaller than its limit */ public abstract byte get(); /** * Relative put method (optional operation). * *Writes the given byte into this buffer at the current * position, and then increments the position.
* * @param b * The byte 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 ByteBuffer put(byte b); /** * Absolute get method. Reads the byte at the given * index. * * @param index * The index from which the byte will be read * * @return The byte at the given index * * @throws IndexOutOfBoundsException * If {@code index} is negative * or not smaller than the buffer's limit */ public abstract byte get(int 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 b * The byte 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 ByteBuffer put(int index, byte b); // -- Bulk get operations -- /** * Relative bulk get method. * *This method transfers bytes from this buffer into the given * destination array. If there are fewer bytes remaining in the * buffer than are required to satisfy the request, that is, if * {@code length} {@code >} {@code remaining()}, then no * bytes are transferred and a {@link BufferUnderflowException} is * thrown. * *
Otherwise, this method copies {@code length} bytes 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
*
*
{@code
* 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.
*
* @param dst
* The array into which bytes are to be written
*
* @param offset
* The offset within the array of the first byte to be
* written; must be non-negative and no larger than
* {@code dst.length}
*
* @param length
* The maximum number of bytes 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} bytes
* remaining in this buffer
*
* @throws IndexOutOfBoundsException
* If the preconditions on the {@code offset} and {@code length}
* parameters do not hold
*/
public ByteBuffer get(byte[] 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 bytes 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 * *
* src.get(a, 0, a.length)
*
* @param dst
* The destination array
*
* @return This buffer
*
* @throws BufferUnderflowException
* If there are fewer than {@code length} bytes
* remaining in this buffer
*/
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:
*
*
{@code
* 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:
*
*
* 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);
}
private ByteBuffer getArray(int index, byte[] dst, int offset, int length) {
// Android-changed: ScopedMemoryAccess is not yet supported.
/*
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(
scope(), 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);
}
}
*/
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 bytes remaining in the given source * buffer into this buffer. If there are more bytes remaining in the * source buffer than in this buffer, that is, if * {@code src.remaining()} {@code >} {@code remaining()}, * then no bytes are transferred and a {@link * BufferOverflowException} is thrown. * *
Otherwise, this method copies * n = {@code src.remaining()} bytes 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 * *
* 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 bytes 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 bytes in the source buffer
*
* @throws IllegalArgumentException
* If the source buffer is this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public ByteBuffer put(ByteBuffer 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} 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
*
*
{@code
* 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;
}
void putBuffer(int pos, ByteBuffer src, int srcPos, int n) {
// Android-changed: ScopedMemoryAccess is not yet supported.
// Android-changed: improve ByteBuffer.put(ByteBuffer) performance through bulk copy.
/*
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.scope(), scope(), srcBase, srcAddr,
base, addr, len);
} finally {
Reference.reachabilityFence(src);
Reference.reachabilityFence(this);
}
*/
// Note that we use offset instead of arrayOffset because arrayOffset is specified to
// throw for read only buffers. Our use of arrayOffset here is provably safe, we only
// use it to read *from* readOnly buffers.
if (this.hb != null && src.hb != null) {
// System.arraycopy is intrinsified by ART and therefore tiny bit faster than memmove
System.arraycopy(src.hb, srcPos + src.offset, hb, pos + offset, n);
} else {
// Use the buffer object (and the raw memory address) if it's a direct buffer. Note that
// isDirect() doesn't imply !hasArray(), ByteBuffer.allocateDirect allocated buffer will
// have a backing, non-gc-movable byte array. JNI allocated direct byte buffers WILL NOT
// have a backing array.
final Object srcObject = src.isDirect() ? src : src.hb;
int srcOffset = srcPos;
if (!src.isDirect()) {
srcOffset += src.offset;
}
final ByteBuffer dst = this;
final Object dstObject = dst.isDirect() ? dst : dst.hb;
int dstOffset = pos;
if (!dst.isDirect()) {
dstOffset += dst.offset;
}
Memory.memmove(dstObject, dstOffset, srcObject, srcOffset, n);
}
}
/**
* Relative bulk put method (optional operation).
*
* This method transfers bytes into this buffer from the given * source array. If there are more bytes to be copied from the array * than remain in this buffer, that is, if * {@code length} {@code >} {@code remaining()}, then no * bytes are transferred and a {@link BufferOverflowException} is * thrown. * *
Otherwise, this method copies {@code length} bytes 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
*
*
{@code
* 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 bytes are to be read
*
* @param offset
* The offset within the array of the first byte to be read;
* 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 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 ByteBuffer put(byte[] 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 * byte 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 * *
* 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 ByteBuffer put(byte[] src) {
return put(src, 0, src.length);
}
/**
* Absolute bulk put method (optional operation).
*
* 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. * *
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:
*
*
{@code
* 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 byte will be
* written; must be non-negative and less than {@code limit()}
*
* @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 read-only
*
* @since 13
*/
public ByteBuffer put(int index, byte[] 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 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:
*
*
* dst.put(index, src, 0, src.length);
*
* @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 read-only
*
* @since 13
*/
public ByteBuffer put(int index, byte[] src) {
return put(index, src, 0, src.length);
}
private ByteBuffer putArray(int index, byte[] src, int offset, int length) {
// Android-changed: ScopedMemoryAccess is not yet supported.
/*
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, scope(), 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]);
}
*/
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 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 // BEGIN Android-added: covariant overloads of *Buffer methods that return this. /** * {@inheritDoc} */ // Android-changed: Un-final the method until confirmation of causing no app compat. @CovariantReturnType(returnType = ByteBuffer.class, presentAfter = 28) @Override public Buffer position(int newPosition) { super.position(newPosition); return this; } /** * {@inheritDoc} */ // Android-changed: Un-final the method until confirmation of causing no app compat. @CovariantReturnType(returnType = ByteBuffer.class, presentAfter = 28) @Override public Buffer limit(int newLimit) { super.limit(newLimit); return this; } /** * {@inheritDoc} */ // Android-changed: Un-final the method until confirmation of causing no app compat. @Override @CovariantReturnType(returnType = ByteBuffer.class, presentAfter = 28) public Buffer mark() { super.mark(); return this; } /** * {@inheritDoc} */ // Android-changed: Un-final the method until confirmation of causing no app compat. @CovariantReturnType(returnType = ByteBuffer.class, presentAfter = 28) @Override public Buffer reset() { super.reset(); return this; } /** * {@inheritDoc} */ // Android-changed: Un-final the method until confirmation of causing no app compat. @CovariantReturnType(returnType = ByteBuffer.class, presentAfter = 28) @Override public Buffer clear() { super.clear(); return this; } /** * {@inheritDoc} */ // Android-changed: Un-final the method until confirmation of causing no app compat. @CovariantReturnType(returnType = ByteBuffer.class, presentAfter = 28) @Override public Buffer flip() { super.flip(); return this; } /** * {@inheritDoc} */ // Android-changed: Un-final the method until confirmation of causing no app compat. @Override @CovariantReturnType(returnType = ByteBuffer.class, presentAfter = 28) public Buffer rewind() { super.rewind(); return this; } // END Android-added: covariant overloads of *Buffer methods that return this. /** * Compacts this buffer (optional operation). * *The bytes between the buffer's current position and its limit, * if any, are copied to the beginning of the buffer. That is, the * byte at index p = {@code position()} is copied * to index zero, the byte at index p + 1 is copied * to index one, and so forth until the byte 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 bytes copied, * rather than to zero, so that an invocation of this method can be * followed immediately by an invocation of another relative put * method.
* * *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
* }
* }The hash code of a byte 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 byte 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 byte 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(Object ob) { if (this == ob) return true; if (!(ob instanceof ByteBuffer)) return false; ByteBuffer that = (ByteBuffer)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 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. * 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 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(byte x, byte y) { return Byte.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(ByteBuffer 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 -- 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 *
* int value = alignmentOffset(index, unitSize)
* alignmentOffset(index - value, unitSize) == 0, value ≤ index
* alignmentOffset(index + (unitSize - value), unitSize) == 0The 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 than {@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 - aligned_pos); } // Android-added: Unchecked accessors, for use by ByteBufferAs-X-Buffer and Bits classes abstract byte _get(int i); // package-private abstract void _put(int i, byte b); // package-private // BEGIN Android-added: isAccessible(), setAccessible(), for use by frameworks (MediaCodec). /** * @hide */ public boolean isAccessible() { return true; } /** * @hide */ public void setAccessible(boolean value) { throw new UnsupportedOperationException(); } // END Android-added: isAccessible(), setAccessible(), for use by frameworks (MediaCodec). /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract char getCharUnchecked(int index); abstract void getUnchecked(int pos, char[] dst, int dstOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract void putCharUnchecked(int index, char value); abstract void putUnchecked(int pos, char[] dst, int srcOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract short getShortUnchecked(int index); abstract void getUnchecked(int pos, short[] dst, int dstOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract void putShortUnchecked(int index, short value); abstract void putUnchecked(int pos, short[] dst, int srcOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract int getIntUnchecked(int index); abstract void getUnchecked(int pos, int[] dst, int dstOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract void putIntUnchecked(int index, int value); abstract void putUnchecked(int pos, int[] dst, int srcOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract long getLongUnchecked(int index); abstract void getUnchecked(int pos, long[] dst, int dstOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract void putLongUnchecked(int index, long value); abstract void putUnchecked(int pos, long[] dst, int srcOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract float getFloatUnchecked(int index); abstract void getUnchecked(int pos, float[] dst, int dstOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract void putFloatUnchecked(int index, float value); abstract void putUnchecked(int pos, float[] dst, int srcOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract double getDoubleUnchecked(int index); abstract void getUnchecked(int pos, double[] dst, int dstOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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); // BEGIN Android-added: {get,put}*Unchecked() accessors. abstract void putDoubleUnchecked(int index, double value); abstract void putUnchecked(int pos, double[] dst, int srcOffset, int length); // END Android-added: {get,put}*Unchecked() accessors. /** * 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(); }