918 lines
31 KiB
Java
918 lines
31 KiB
Java
/*
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
* Copyright (c) 2000, 2021, 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.
|
|
*/
|
|
|
|
package java.nio;
|
|
|
|
import jdk.internal.misc.Unsafe;
|
|
import jdk.internal.vm.annotation.IntrinsicCandidate;
|
|
|
|
import java.io.FileDescriptor;
|
|
import java.util.Spliterator;
|
|
|
|
import jdk.internal.misc.Unsafe;
|
|
|
|
/**
|
|
* A container for data of a specific primitive type.
|
|
*
|
|
* <p> A buffer is a linear, finite sequence of elements of a specific
|
|
* primitive type. Aside from its content, the essential properties of a
|
|
* buffer are its capacity, limit, and position: </p>
|
|
*
|
|
* <blockquote>
|
|
*
|
|
* <p> A buffer's <i>capacity</i> is the number of elements it contains. The
|
|
* capacity of a buffer is never negative and never changes. </p>
|
|
*
|
|
* <p> A buffer's <i>limit</i> is the index of the first element that should
|
|
* not be read or written. A buffer's limit is never negative and is never
|
|
* greater than its capacity. </p>
|
|
*
|
|
* <p> A buffer's <i>position</i> is the index of the next element to be
|
|
* read or written. A buffer's position is never negative and is never
|
|
* greater than its limit. </p>
|
|
*
|
|
* </blockquote>
|
|
*
|
|
* <p> There is one subclass of this class for each non-boolean primitive type.
|
|
*
|
|
*
|
|
* <h2> Transferring data </h2>
|
|
*
|
|
* <p> Each subclass of this class defines two categories of <i>get</i> and
|
|
* <i>put</i> operations: </p>
|
|
*
|
|
* <blockquote>
|
|
*
|
|
* <p> <i>Relative</i> operations read or write one or more elements starting
|
|
* at the current position and then increment the position by the number of
|
|
* elements transferred. If the requested transfer exceeds the limit then a
|
|
* relative <i>get</i> operation throws a {@link BufferUnderflowException}
|
|
* and a relative <i>put</i> operation throws a {@link
|
|
* BufferOverflowException}; in either case, no data is transferred. </p>
|
|
*
|
|
* <p> <i>Absolute</i> operations take an explicit element index and do not
|
|
* affect the position. Absolute <i>get</i> and <i>put</i> operations throw
|
|
* an {@link IndexOutOfBoundsException} if the index argument exceeds the
|
|
* limit. </p>
|
|
*
|
|
* </blockquote>
|
|
*
|
|
* <p> Data may also, of course, be transferred in to or out of a buffer by the
|
|
* I/O operations of an appropriate channel, which are always relative to the
|
|
* current position.
|
|
*
|
|
*
|
|
* <h2> Marking and resetting </h2>
|
|
*
|
|
* <p> A buffer's <i>mark</i> is the index to which its position will be reset
|
|
* when the {@link #reset reset} method is invoked. The mark is not always
|
|
* defined, but when it is defined it is never negative and is never greater
|
|
* than the position. If the mark is defined then it is discarded when the
|
|
* position or the limit is adjusted to a value smaller than the mark. If the
|
|
* mark is not defined then invoking the {@link #reset reset} method causes an
|
|
* {@link InvalidMarkException} to be thrown.
|
|
*
|
|
*
|
|
* <h2> Invariants </h2>
|
|
*
|
|
* <p> The following invariant holds for the mark, position, limit, and
|
|
* capacity values:
|
|
*
|
|
* <blockquote>
|
|
* {@code 0} {@code <=}
|
|
* <i>mark</i> {@code <=}
|
|
* <i>position</i> {@code <=}
|
|
* <i>limit</i> {@code <=}
|
|
* <i>capacity</i>
|
|
* </blockquote>
|
|
*
|
|
* <p> A newly-created buffer always has a position of zero and a mark that is
|
|
* undefined. The initial limit may be zero, or it may be some other value
|
|
* that depends upon the type of the buffer and the manner in which it is
|
|
* constructed. Each element of a newly-allocated buffer is initialized
|
|
* to zero.
|
|
*
|
|
*
|
|
* <h2> Additional operations </h2>
|
|
*
|
|
* <p> In addition to methods for accessing the position, limit, and capacity
|
|
* values and for marking and resetting, this class also defines the following
|
|
* operations upon buffers:
|
|
*
|
|
* <ul>
|
|
*
|
|
* <li><p> {@link #clear} makes a buffer ready for a new sequence of
|
|
* channel-read or relative <i>put</i> operations: It sets the limit to the
|
|
* capacity and the position to zero. </p></li>
|
|
*
|
|
* <li><p> {@link #flip} makes a buffer ready for a new sequence of
|
|
* channel-write or relative <i>get</i> operations: It sets the limit to the
|
|
* current position and then sets the position to zero. </p></li>
|
|
*
|
|
* <li><p> {@link #rewind} makes a buffer ready for re-reading the data that
|
|
* it already contains: It leaves the limit unchanged and sets the position
|
|
* to zero. </p></li>
|
|
*
|
|
* <li><p> The {@link #slice} and {@link #slice(int,int) slice(index,length)}
|
|
* methods create a subsequence of a buffer: They leave the limit and the
|
|
* position unchanged. </p></li>
|
|
*
|
|
* <li><p> {@link #duplicate} creates a shallow copy of a buffer: It leaves
|
|
* the limit and the position unchanged. </p></li>
|
|
*
|
|
* </ul>
|
|
*
|
|
*
|
|
* <h2> Read-only buffers </h2>
|
|
*
|
|
* <p> Every buffer is readable, but not every buffer is writable. The
|
|
* mutation methods of each buffer class are specified as <i>optional
|
|
* operations</i> that will throw a {@link ReadOnlyBufferException} when
|
|
* invoked upon a read-only buffer. A read-only buffer does not allow its
|
|
* content to be changed, but its mark, position, and limit values are mutable.
|
|
* Whether or not a buffer is read-only may be determined by invoking its
|
|
* {@link #isReadOnly isReadOnly} method.
|
|
*
|
|
*
|
|
* <h2> Thread safety </h2>
|
|
*
|
|
* <p> Buffers are not safe for use by multiple concurrent threads. If a
|
|
* buffer is to be used by more than one thread then access to the buffer
|
|
* should be controlled by appropriate synchronization.
|
|
*
|
|
*
|
|
* <h2> Invocation chaining </h2>
|
|
*
|
|
* <p> 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; for example, the sequence of statements
|
|
*
|
|
* <blockquote><pre>
|
|
* b.flip();
|
|
* b.position(23);
|
|
* b.limit(42);</pre></blockquote>
|
|
*
|
|
* can be replaced by the single, more compact statement
|
|
*
|
|
* <blockquote><pre>
|
|
* b.flip().position(23).limit(42);</pre></blockquote>
|
|
*
|
|
*
|
|
* @author Mark Reinhold
|
|
* @author JSR-51 Expert Group
|
|
* @since 1.4
|
|
*/
|
|
|
|
public abstract class Buffer {
|
|
// Cached unsafe-access object
|
|
static final Unsafe UNSAFE = Unsafe.getUnsafe();
|
|
|
|
// Android-removed: Remove unsupported scoped memory access.
|
|
// static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
|
|
|
|
/**
|
|
* The characteristics of Spliterators that traverse and split elements
|
|
* maintained in Buffers.
|
|
*/
|
|
static final int SPLITERATOR_CHARACTERISTICS =
|
|
Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;
|
|
|
|
// Invariants: mark <= position <= limit <= capacity
|
|
private int mark = -1;
|
|
// Android-changed: position field non-private for use by Android's nio implementation classes.
|
|
int position = 0;
|
|
private int limit;
|
|
private int capacity;
|
|
|
|
// Used by heap byte buffers or direct buffers with Unsafe access
|
|
// For heap byte buffers this field will be the address relative to the
|
|
// array base address and offset into that array. The address might
|
|
// not align on a word boundary for slices, nor align at a long word
|
|
// (8 byte) boundary for byte[] allocations on 32-bit systems.
|
|
// For direct buffers it is the start address of the memory region. The
|
|
// address might not align on a word boundary for slices, nor when created
|
|
// using JNI, see NewDirectByteBuffer(void*, long).
|
|
// Should ideally be declared final
|
|
// NOTE: hoisted here for speed in JNI GetDirectBufferAddress
|
|
long address;
|
|
|
|
// Android-added: _elementSizeShift field for NIOAccess class and framework native code.
|
|
/**
|
|
* The log base 2 of the element size of this buffer. Each typed subclass
|
|
* (ByteBuffer, CharBuffer, etc.) is responsible for initializing this
|
|
* value. The value is used by JNI code in frameworks/base/ to avoid the
|
|
* need for costly 'instanceof' tests.
|
|
*/
|
|
final int _elementSizeShift;
|
|
|
|
// Used by buffers generated by the memory access API (JEP-370)
|
|
// Android-removed: Remove unsupported MemorySegmentProxy.
|
|
// final MemorySegmentProxy segment;
|
|
|
|
|
|
// Creates a new buffer with given address and capacity.
|
|
//
|
|
// Android-removed: Remove unsupported constructor.
|
|
/*
|
|
Buffer(long addr, int cap, MemorySegmentProxy segement) {
|
|
this.address = addr;
|
|
this.capacity = cap;
|
|
this.segement = segement;
|
|
}
|
|
*/
|
|
|
|
// Creates a new buffer with the given mark, position, limit, and capacity,
|
|
// after checking invariants.
|
|
//
|
|
// Android-added: _elementSizeShift field for NIOAccess class and framework native code.
|
|
Buffer(int mark, int pos, int lim, int cap, int elementSizeShift) { // package-private
|
|
if (cap < 0)
|
|
throw createCapacityException(cap);
|
|
this.capacity = cap;
|
|
limit(lim);
|
|
position(pos);
|
|
if (mark >= 0) {
|
|
if (mark > pos)
|
|
throw new IllegalArgumentException("mark > position: ("
|
|
+ mark + " > " + pos + ")");
|
|
this.mark = mark;
|
|
}
|
|
// Android-added: _elementSizeShift field for NIOAccess class and framework native code.
|
|
_elementSizeShift = elementSizeShift;
|
|
}
|
|
|
|
/**
|
|
* Returns an {@code IllegalArgumentException} indicating that the source
|
|
* and target are the same {@code Buffer}. Intended for use in
|
|
* {@code put(src)} when the parameter is the {@code Buffer} on which the
|
|
* method is being invoked.
|
|
*
|
|
* @return IllegalArgumentException
|
|
* With a message indicating equal source and target buffers
|
|
*/
|
|
static IllegalArgumentException createSameBufferException() {
|
|
return new IllegalArgumentException("The source buffer is this buffer");
|
|
}
|
|
|
|
/**
|
|
* Verify that the capacity is nonnegative.
|
|
*
|
|
* @param capacity
|
|
* The new buffer's capacity, in $type$s
|
|
*
|
|
* @throws IllegalArgumentException
|
|
* If the {@code capacity} is a negative integer
|
|
*/
|
|
static IllegalArgumentException createCapacityException(int capacity) {
|
|
assert capacity < 0 : "capacity expected to be negative";
|
|
return new IllegalArgumentException("capacity < 0: ("
|
|
+ capacity + " < 0)");
|
|
}
|
|
|
|
/**
|
|
* Returns this buffer's capacity.
|
|
*
|
|
* @return The capacity of this buffer
|
|
*/
|
|
public final int capacity() {
|
|
return capacity;
|
|
}
|
|
|
|
/**
|
|
* Returns this buffer's position.
|
|
*
|
|
* @return The position of this buffer
|
|
*/
|
|
public final int position() {
|
|
return position;
|
|
}
|
|
|
|
/**
|
|
* Sets this buffer's position. If the mark is defined and larger than the
|
|
* new position then it is discarded.
|
|
*
|
|
* @param newPosition
|
|
* The new position value; must be non-negative
|
|
* and no larger than the current limit
|
|
*
|
|
* @return This buffer
|
|
*
|
|
* @throws IllegalArgumentException
|
|
* If the preconditions on {@code newPosition} do not hold
|
|
*/
|
|
public Buffer position(int newPosition) {
|
|
if (newPosition > limit | newPosition < 0)
|
|
throw createPositionException(newPosition);
|
|
if (mark > newPosition) mark = -1;
|
|
position = newPosition;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Verify that {@code 0 < newPosition <= limit}
|
|
*
|
|
* @param newPosition
|
|
* The new position value
|
|
*
|
|
* @throws IllegalArgumentException
|
|
* If the specified position is out of bounds.
|
|
*/
|
|
private IllegalArgumentException createPositionException(int newPosition) {
|
|
String msg = null;
|
|
|
|
if (newPosition > limit) {
|
|
msg = "newPosition > limit: (" + newPosition + " > " + limit + ")";
|
|
} else { // assume negative
|
|
assert newPosition < 0 : "newPosition expected to be negative";
|
|
msg = "newPosition < 0: (" + newPosition + " < 0)";
|
|
}
|
|
|
|
return new IllegalArgumentException(msg);
|
|
}
|
|
|
|
/**
|
|
* Returns this buffer's limit.
|
|
*
|
|
* @return The limit of this buffer
|
|
*/
|
|
public final int limit() {
|
|
return limit;
|
|
}
|
|
|
|
/**
|
|
* Sets this buffer's limit. If the position is larger than the new limit
|
|
* then it is set to the new limit. If the mark is defined and larger than
|
|
* the new limit then it is discarded.
|
|
*
|
|
* @param newLimit
|
|
* The new limit value; must be non-negative
|
|
* and no larger than this buffer's capacity
|
|
*
|
|
* @return This buffer
|
|
*
|
|
* @throws IllegalArgumentException
|
|
* If the preconditions on {@code newLimit} do not hold
|
|
*/
|
|
public Buffer limit(int newLimit) {
|
|
if (newLimit > capacity | newLimit < 0)
|
|
throw createLimitException(newLimit);
|
|
limit = newLimit;
|
|
if (position > newLimit) position = newLimit;
|
|
if (mark > newLimit) mark = -1;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Verify that {@code 0 < newLimit <= capacity}
|
|
*
|
|
* @param newLimit
|
|
* The new limit value
|
|
*
|
|
* @throws IllegalArgumentException
|
|
* If the specified limit is out of bounds.
|
|
*/
|
|
private IllegalArgumentException createLimitException(int newLimit) {
|
|
String msg = null;
|
|
|
|
if (newLimit > capacity) {
|
|
msg = "newLimit > capacity: (" + newLimit + " > " + capacity + ")";
|
|
} else { // assume negative
|
|
assert newLimit < 0 : "newLimit expected to be negative";
|
|
msg = "newLimit < 0: (" + newLimit + " < 0)";
|
|
}
|
|
|
|
return new IllegalArgumentException(msg);
|
|
}
|
|
|
|
/**
|
|
* Sets this buffer's mark at its position.
|
|
*
|
|
* @return This buffer
|
|
*/
|
|
public Buffer mark() {
|
|
mark = position;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Resets this buffer's position to the previously-marked position.
|
|
*
|
|
* <p> Invoking this method neither changes nor discards the mark's
|
|
* value. </p>
|
|
*
|
|
* @return This buffer
|
|
*
|
|
* @throws InvalidMarkException
|
|
* If the mark has not been set
|
|
*/
|
|
public Buffer reset() {
|
|
int m = mark;
|
|
if (m < 0)
|
|
throw new InvalidMarkException();
|
|
position = m;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Clears this buffer. The position is set to zero, the limit is set to
|
|
* the capacity, and the mark is discarded.
|
|
*
|
|
* <p> Invoke this method before using a sequence of channel-read or
|
|
* <i>put</i> operations to fill this buffer. For example:
|
|
*
|
|
* <blockquote><pre>
|
|
* buf.clear(); // Prepare buffer for reading
|
|
* in.read(buf); // Read data</pre></blockquote>
|
|
*
|
|
* <p> This method does not actually erase the data in the buffer, but it
|
|
* is named as if it did because it will most often be used in situations
|
|
* in which that might as well be the case. </p>
|
|
*
|
|
* @return This buffer
|
|
*/
|
|
public Buffer clear() {
|
|
position = 0;
|
|
limit = capacity;
|
|
mark = -1;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Flips this buffer. The limit is set to the current position and then
|
|
* the position is set to zero. If the mark is defined then it is
|
|
* discarded.
|
|
*
|
|
* <p> After a sequence of channel-read or <i>put</i> operations, invoke
|
|
* this method to prepare for a sequence of channel-write or relative
|
|
* <i>get</i> operations. For example:
|
|
*
|
|
* <blockquote><pre>
|
|
* buf.put(magic); // Prepend header
|
|
* in.read(buf); // Read data into rest of buffer
|
|
* buf.flip(); // Flip buffer
|
|
* out.write(buf); // Write header + data to channel</pre></blockquote>
|
|
*
|
|
* <p> This method is often used in conjunction with the {@link
|
|
* java.nio.ByteBuffer#compact compact} method when transferring data from
|
|
* one place to another. </p>
|
|
*
|
|
* @return This buffer
|
|
*/
|
|
public Buffer flip() {
|
|
limit = position;
|
|
position = 0;
|
|
mark = -1;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Rewinds this buffer. The position is set to zero and the mark is
|
|
* discarded.
|
|
*
|
|
* <p> Invoke this method before a sequence of channel-write or <i>get</i>
|
|
* operations, assuming that the limit has already been set
|
|
* appropriately. For example:
|
|
*
|
|
* <blockquote><pre>
|
|
* out.write(buf); // Write remaining data
|
|
* buf.rewind(); // Rewind buffer
|
|
* buf.get(array); // Copy data into array</pre></blockquote>
|
|
*
|
|
* @return This buffer
|
|
*/
|
|
public Buffer rewind() {
|
|
position = 0;
|
|
mark = -1;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of elements between the current position and the
|
|
* limit.
|
|
*
|
|
* @return The number of elements remaining in this buffer
|
|
*/
|
|
public final int remaining() {
|
|
int rem = limit - position;
|
|
return rem > 0 ? rem : 0;
|
|
}
|
|
|
|
/**
|
|
* Tells whether there are any elements between the current position and
|
|
* the limit.
|
|
*
|
|
* @return {@code true} if, and only if, there is at least one element
|
|
* remaining in this buffer
|
|
*/
|
|
public final boolean hasRemaining() {
|
|
return position < limit;
|
|
}
|
|
|
|
/**
|
|
* Tells whether or not this buffer is read-only.
|
|
*
|
|
* @return {@code true} if, and only if, this buffer is read-only
|
|
*/
|
|
public abstract boolean isReadOnly();
|
|
|
|
/**
|
|
* Tells whether or not this buffer is backed by an accessible
|
|
* array.
|
|
*
|
|
* <p> If this method returns {@code true} then the {@link #array() array}
|
|
* and {@link #arrayOffset() arrayOffset} methods may safely be invoked.
|
|
* </p>
|
|
*
|
|
* @return {@code true} if, and only if, this buffer
|
|
* is backed by an array and is not read-only
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public abstract boolean hasArray();
|
|
|
|
/**
|
|
* Returns the array that backs this
|
|
* buffer <i>(optional operation)</i>.
|
|
*
|
|
* <p> This method is intended to allow array-backed buffers to be
|
|
* passed to native code more efficiently. Concrete subclasses
|
|
* provide more strongly-typed return values for this method.
|
|
*
|
|
* <p> Modifications to this buffer's content will cause the returned
|
|
* array's content to be modified, and vice versa.
|
|
*
|
|
* <p> Invoke the {@link #hasArray hasArray} method before invoking this
|
|
* method in order to ensure that this buffer has an accessible backing
|
|
* array. </p>
|
|
*
|
|
* @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
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public abstract Object array();
|
|
|
|
/**
|
|
* Returns the offset within this buffer's backing array of the first
|
|
* element of the buffer <i>(optional operation)</i>.
|
|
*
|
|
* <p> If this buffer is backed by an array then buffer position <i>p</i>
|
|
* corresponds to array index <i>p</i> + {@code arrayOffset()}.
|
|
*
|
|
* <p> Invoke the {@link #hasArray hasArray} method before invoking this
|
|
* method in order to ensure that this buffer has an accessible backing
|
|
* array. </p>
|
|
*
|
|
* @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
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public abstract int arrayOffset();
|
|
|
|
/**
|
|
* Tells whether or not this buffer is
|
|
* <a href="ByteBuffer.html#direct"><i>direct</i></a>.
|
|
*
|
|
* @return {@code true} if, and only if, this buffer is direct
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public abstract boolean isDirect();
|
|
|
|
/**
|
|
* Creates a new buffer whose content is a shared subsequence of
|
|
* this buffer's content.
|
|
*
|
|
* <p> 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.
|
|
*
|
|
* <p> The new buffer's position will be zero, its capacity and its limit
|
|
* will be the number of elements remaining in this buffer, its mark will be
|
|
* undefined. 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. </p>
|
|
*
|
|
* @return The new buffer
|
|
*
|
|
* @since 9
|
|
*/
|
|
public abstract Buffer slice();
|
|
|
|
/**
|
|
* Creates a new buffer whose content is a shared subsequence of
|
|
* this buffer's content.
|
|
*
|
|
* <p> 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.
|
|
*
|
|
* <p> The new buffer's position will be zero, its capacity and its limit
|
|
* will be {@code length}, its mark will be undefined. 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. </p>
|
|
*
|
|
* @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
|
|
*/
|
|
public abstract Buffer slice(int index, int length);
|
|
|
|
/**
|
|
* Creates a new buffer that shares this buffer's content.
|
|
*
|
|
* <p> 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.
|
|
*
|
|
* <p> The new buffer's capacity, limit, position and mark values 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. </p>
|
|
*
|
|
* @return The new buffer
|
|
*
|
|
* @since 9
|
|
*/
|
|
public abstract Buffer duplicate();
|
|
|
|
|
|
// -- Package-private methods for bounds checking, etc. --
|
|
|
|
/**
|
|
*
|
|
* @return the base reference, paired with the address
|
|
* field, which in combination can be used for unsafe access into a heap
|
|
* buffer or direct byte buffer (and views of).
|
|
*/
|
|
abstract Object base();
|
|
|
|
/**
|
|
* Checks the current position against the limit, throwing a {@link
|
|
* BufferUnderflowException} if it is not smaller than the limit, and then
|
|
* increments the position.
|
|
*
|
|
* @return The current position value, before it is incremented
|
|
*/
|
|
final int nextGetIndex() { // package-private
|
|
int p = position;
|
|
if (p >= limit)
|
|
throw new BufferUnderflowException();
|
|
position = p + 1;
|
|
return p;
|
|
}
|
|
|
|
final int nextGetIndex(int nb) { // package-private
|
|
int p = position;
|
|
if (limit - p < nb)
|
|
throw new BufferUnderflowException();
|
|
position = p + nb;
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Checks the current position against the limit, throwing a {@link
|
|
* BufferOverflowException} if it is not smaller than the limit, and then
|
|
* increments the position.
|
|
*
|
|
* @return The current position value, before it is incremented
|
|
*/
|
|
final int nextPutIndex() { // package-private
|
|
int p = position;
|
|
if (p >= limit)
|
|
throw new BufferOverflowException();
|
|
position = p + 1;
|
|
return p;
|
|
}
|
|
|
|
final int nextPutIndex(int nb) { // package-private
|
|
int p = position;
|
|
if (limit - p < nb)
|
|
throw new BufferOverflowException();
|
|
position = p + nb;
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Checks the given index against the limit, throwing an {@link
|
|
* IndexOutOfBoundsException} if it is not smaller than the limit
|
|
* or is smaller than zero.
|
|
*/
|
|
@IntrinsicCandidate
|
|
final int checkIndex(int i) { // package-private
|
|
if ((i < 0) || (i >= limit))
|
|
// Android-changed: Add bounds details to exception.
|
|
throw new IndexOutOfBoundsException(
|
|
"index=" + i + " out of bounds (limit=" + limit + ")");
|
|
return i;
|
|
}
|
|
|
|
final int checkIndex(int i, int nb) { // package-private
|
|
if ((i < 0) || (nb > limit - i))
|
|
// Android-changed: Add bounds details to exception.
|
|
throw new IndexOutOfBoundsException(
|
|
"index=" + i + " out of bounds (limit=" + limit + ", nb=" + nb + ")");
|
|
return i;
|
|
}
|
|
|
|
final int markValue() { // package-private
|
|
return mark;
|
|
}
|
|
|
|
final void discardMark() { // package-private
|
|
mark = -1;
|
|
}
|
|
|
|
static void checkBounds(int off, int len, int size) { // package-private
|
|
if ((off | len | (off + len) | (size - (off + len))) < 0)
|
|
// Android-changed: Add bounds details to exception.
|
|
throw new IndexOutOfBoundsException(
|
|
"off=" + off + ", len=" + len + " out of bounds (size=" + size + ")");
|
|
}
|
|
|
|
final void checkScope() {
|
|
// Android-removed: ScopedMemoryAccess isn't used, as Android doesn't support it yet.
|
|
/*
|
|
ScopedMemoryAccess.Scope scope = scope();
|
|
if (scope != null) {
|
|
scope.checkValidState();
|
|
}
|
|
*/
|
|
}
|
|
|
|
// Android-removed: Remove unsupported scoped memory access.
|
|
/*
|
|
@ForceInline
|
|
final ScopedMemoryAccess.Scope scope() {
|
|
if (segment != null) {
|
|
return segment.scope();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
// Android-added: getElementSizeShift() method for testing.
|
|
/**
|
|
* For testing only. This field is accessed directly via JNI from frameworks code.
|
|
*
|
|
* @hide
|
|
*/
|
|
public int getElementSizeShift() {
|
|
return _elementSizeShift;
|
|
}
|
|
|
|
// Android-removed: Remove unused SharedSecrets.
|
|
/*
|
|
static {
|
|
// setup access to this package in SharedSecrets
|
|
SharedSecrets.setJavaNioAccess(
|
|
new JavaNioAccess() {
|
|
@Override
|
|
public BufferPool getDirectBufferPool() {
|
|
return Bits.BUFFER_POOL;
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer newDirectByteBuffer(long addr, int cap, Object obj, MemorySegmentProxy segment) {
|
|
return new DirectByteBuffer(addr, cap, obj, segment);
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer newMappedByteBuffer(UnmapperProxy unmapperProxy, long address, int cap, Object obj, MemorySegmentProxy segment) {
|
|
return new DirectByteBuffer(address, cap, obj, unmapperProxy.fileDescriptor(), unmapperProxy.isSync(), segment);
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer newHeapByteBuffer(byte[] hb, int offset, int capacity, MemorySegmentProxy segment) {
|
|
return new HeapByteBuffer(hb, -1, 0, capacity, capacity, offset, segment);
|
|
}
|
|
|
|
@Override
|
|
public Object getBufferBase(ByteBuffer bb) {
|
|
return bb.base();
|
|
}
|
|
|
|
@Override
|
|
public long getBufferAddress(ByteBuffer bb) {
|
|
return bb.address;
|
|
}
|
|
|
|
@Override
|
|
public UnmapperProxy unmapper(ByteBuffer bb) {
|
|
if (bb instanceof MappedByteBuffer) {
|
|
return ((MappedByteBuffer)bb).unmapper();
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public MemorySegmentProxy bufferSegment(Buffer buffer) {
|
|
return buffer.segment;
|
|
}
|
|
|
|
@Override
|
|
public Scope.Handle acquireScope(Buffer buffer, boolean async) {
|
|
var scope = buffer.scope();
|
|
if (scope == null) {
|
|
return null;
|
|
}
|
|
if (async && scope.ownerThread() != null) {
|
|
throw new IllegalStateException("Confined scope not supported");
|
|
}
|
|
return scope.acquire();
|
|
}
|
|
|
|
@Override
|
|
public void force(FileDescriptor fd, long address, boolean isSync, long offset, long size) {
|
|
MappedMemoryUtils.force(fd, address, isSync, offset, size);
|
|
}
|
|
|
|
@Override
|
|
public void load(long address, boolean isSync, long size) {
|
|
MappedMemoryUtils.load(address, isSync, size);
|
|
}
|
|
|
|
@Override
|
|
public void unload(long address, boolean isSync, long size) {
|
|
MappedMemoryUtils.unload(address, isSync, size);
|
|
}
|
|
|
|
@Override
|
|
public boolean isLoaded(long address, boolean isSync, long size) {
|
|
return MappedMemoryUtils.isLoaded(address, isSync, size);
|
|
}
|
|
|
|
@Override
|
|
public void reserveMemory(long size, long cap) {
|
|
Bits.reserveMemory(size, cap);
|
|
}
|
|
|
|
@Override
|
|
public void unreserveMemory(long size, long cap) {
|
|
Bits.unreserveMemory(size, cap);
|
|
}
|
|
|
|
@Override
|
|
public int pageSize() {
|
|
return Bits.pageSize();
|
|
}
|
|
});
|
|
}
|
|
*/
|
|
|
|
}
|