Merge "InvalidKeyException for "opaque" keys null getEncoded()"
diff --git a/dalvik/src/main/java/org/apache/harmony/dalvik/NativeTestTarget.java b/dalvik/src/main/java/org/apache/harmony/dalvik/NativeTestTarget.java
index 7b46d2e..5daf6a0 100644
--- a/dalvik/src/main/java/org/apache/harmony/dalvik/NativeTestTarget.java
+++ b/dalvik/src/main/java/org/apache/harmony/dalvik/NativeTestTarget.java
@@ -22,25 +22,20 @@
* and performance of calling native methods.
*/
public final class NativeTestTarget {
- /**
- * This class is uninstantiable.
- */
- private NativeTestTarget() {
- // This space intentionally left blank.
+ public NativeTestTarget() {
}
- /**
- * This is an empty native static method with no args, hooked up using
- * JNI.
- */
+ public static native synchronized void emptyJniStaticSynchronizedMethod0();
+
+ public native synchronized void emptyJniSynchronizedMethod0();
+
public static native void emptyJniStaticMethod0();
- /**
- * This is an empty native static method with six args, hooked up using
- * JNI.
- */
- public static native void emptyJniStaticMethod6(int a, int b, int c,
- int d, int e, int f);
+ public native void emptyJniMethod0();
+
+ public static native void emptyJniStaticMethod6(int a, int b, int c, int d, int e, int f);
+
+ public native void emptyJniMethod6(int a, int b, int c, int d, int e, int f);
/**
* This is an empty native static method with six args, hooked up
@@ -51,18 +46,17 @@
public static native void emptyJniStaticMethod6L(String a, String[] b,
int[][] c, Object d, Object[] e, Object[][][][] f);
+ public native void emptyJniMethod6L(String a, String[] b,
+ int[][] c, Object d, Object[] e, Object[][][][] f);
+
/**
- * This method is intended to be "inlined" by the virtual machine
- * (e.g., given special treatment as an intrinsic).
+ * This is used to benchmark dalvik's inline natives.
*/
public static void emptyInlineMethod() {
- // This space intentionally left blank.
}
/**
- * This method is intended to be defined in native code and hooked
- * up using the virtual machine's special fast-path native linkage
- * (as opposed to being hooked up using JNI).
+ * This is used to benchmark dalvik's inline natives.
*/
public static native void emptyInternalStaticMethod();
}
diff --git a/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp b/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
index 50e2fc2..11735eb 100644
--- a/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
+++ b/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
@@ -14,55 +14,30 @@
* limitations under the License.
*/
+#define LOG_TAG "NativeTestTarget"
+
#include "JNIHelp.h"
+#include "../../../../luni/src/main/native/JniConstants.h"
-/*
- * public static void emptyJniStaticMethod0()
- *
- * For benchmarks, a do-nothing JNI method with no arguments.
- */
-static void emptyJniStaticMethod0(JNIEnv*, jclass)
-{
- // This space intentionally left blank.
-}
-
-/*
- * public static void emptyJniStaticMethod6(int a, int b, int c,
- * int d, int e, int f)
- *
- * For benchmarks, a do-nothing JNI method with six arguments.
- */
-static void emptyJniStaticMethod6(JNIEnv*, jclass,
- int, int, int, int, int, int)
-{
- // This space intentionally left blank.
-}
-
-/*
- * public static void emptyJniStaticMethod6L(String a, String[] b,
- * int[][] c, Object d, Object[] e, Object[][][][] f)
- *
- * For benchmarks, a do-nothing JNI method with six arguments.
- */
-static void emptyJniStaticMethod6L(JNIEnv*, jclass,
- jobject, jarray, jarray, jobject, jarray, jarray)
-{
- // This space intentionally left blank.
-}
+static void NativeTestTarget_emptyJniMethod0(JNIEnv*, jobject) { }
+static void NativeTestTarget_emptyJniMethod6(JNIEnv*, jclass, int, int, int, int, int, int) { }
+static void NativeTestTarget_emptyJniMethod6L(JNIEnv*, jclass, jobject, jarray, jarray, jobject, jarray, jarray) { }
+static void NativeTestTarget_emptyJniStaticMethod0(JNIEnv*, jclass) { }
+static void NativeTestTarget_emptyJniStaticMethod6(JNIEnv*, jclass, int, int, int, int, int, int) { }
+static void NativeTestTarget_emptyJniStaticMethod6L(JNIEnv*, jclass, jobject, jarray, jarray, jobject, jarray, jarray) { }
+static void NativeTestTarget_emptyJniStaticSynchronizedMethod0(JNIEnv*, jclass) { }
+static void NativeTestTarget_emptyJniSynchronizedMethod0(JNIEnv*, jclass) { }
static JNINativeMethod gMethods[] = {
- { "emptyJniStaticMethod0", "()V", (void*)emptyJniStaticMethod0 },
- { "emptyJniStaticMethod6", "(IIIIII)V", (void*)emptyJniStaticMethod6 },
- { "emptyJniStaticMethod6L", "(Ljava/lang/String;[Ljava/lang/String;[[ILjava/lang/Object;[Ljava/lang/Object;[[[[Ljava/lang/Object;)V", (void*)emptyJniStaticMethod6L },
+ NATIVE_METHOD(NativeTestTarget, emptyJniMethod0, "()V"),
+ NATIVE_METHOD(NativeTestTarget, emptyJniMethod6, "(IIIIII)V"),
+ NATIVE_METHOD(NativeTestTarget, emptyJniMethod6L, "(Ljava/lang/String;[Ljava/lang/String;[[ILjava/lang/Object;[Ljava/lang/Object;[[[[Ljava/lang/Object;)V"),
+ NATIVE_METHOD(NativeTestTarget, emptyJniStaticMethod0, "()V"),
+ NATIVE_METHOD(NativeTestTarget, emptyJniStaticMethod6, "(IIIIII)V"),
+ NATIVE_METHOD(NativeTestTarget, emptyJniStaticMethod6L, "(Ljava/lang/String;[Ljava/lang/String;[[ILjava/lang/Object;[Ljava/lang/Object;[[[[Ljava/lang/Object;)V"),
+ NATIVE_METHOD(NativeTestTarget, emptyJniStaticSynchronizedMethod0, "()V"),
+ NATIVE_METHOD(NativeTestTarget, emptyJniSynchronizedMethod0, "()V"),
};
int register_org_apache_harmony_dalvik_NativeTestTarget(JNIEnv* env) {
- int result = jniRegisterNativeMethods(env,
- "org/apache/harmony/dalvik/NativeTestTarget",
- gMethods, NELEM(gMethods));
- if (result != 0) {
- /* print warning, but allow to continue */
- ALOGW("WARNING: NativeTestTarget not registered\n");
- env->ExceptionClear();
- }
- return 0;
+ return jniRegisterNativeMethods(env, "org/apache/harmony/dalvik/NativeTestTarget", gMethods, NELEM(gMethods));
}
diff --git a/luni/src/main/java/java/nio/BaseByteBuffer.java b/luni/src/main/java/java/nio/BaseByteBuffer.java
deleted file mode 100644
index d6cfb93..0000000
--- a/luni/src/main/java/java/nio/BaseByteBuffer.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * Serves as the root of other byte buffer impl classes, implements common
- * methods that can be shared by child classes.
- */
-abstract class BaseByteBuffer extends ByteBuffer {
-
- protected BaseByteBuffer(int capacity, MemoryBlock block) {
- super(capacity, block);
- }
-
- @Override
- public final CharBuffer asCharBuffer() {
- return CharToByteBufferAdapter.asCharBuffer(this);
- }
-
- @Override
- public final DoubleBuffer asDoubleBuffer() {
- return DoubleToByteBufferAdapter.asDoubleBuffer(this);
- }
-
- @Override
- public final FloatBuffer asFloatBuffer() {
- return FloatToByteBufferAdapter.asFloatBuffer(this);
- }
-
- @Override
- public final IntBuffer asIntBuffer() {
- return IntToByteBufferAdapter.asIntBuffer(this);
- }
-
- @Override
- public final LongBuffer asLongBuffer() {
- return LongToByteBufferAdapter.asLongBuffer(this);
- }
-
- @Override
- public final ShortBuffer asShortBuffer() {
- return ShortToByteBufferAdapter.asShortBuffer(this);
- }
-
- @Override
- public char getChar() {
- return (char) getShort();
- }
-
- @Override
- public char getChar(int index) {
- return (char) getShort(index);
- }
-
- @Override
- public ByteBuffer putChar(char value) {
- return putShort((short) value);
- }
-
- @Override
- public ByteBuffer putChar(int index, char value) {
- return putShort(index, (short) value);
- }
-}
diff --git a/luni/src/main/java/java/nio/Buffer.java b/luni/src/main/java/java/nio/Buffer.java
index b90744b..3ba2503 100644
--- a/luni/src/main/java/java/nio/Buffer.java
+++ b/luni/src/main/java/java/nio/Buffer.java
@@ -300,14 +300,6 @@
* if <code>newLimit</code> is invalid.
*/
public final Buffer limit(int newLimit) {
- limitImpl(newLimit);
- return this;
- }
-
- /**
- * Subverts the fact that limit(int) is final, for the benefit of MappedByteBufferAdapter.
- */
- void limitImpl(int newLimit) {
if (newLimit < 0 || newLimit > capacity) {
throw new IllegalArgumentException("Bad limit (capacity " + capacity + "): " + newLimit);
}
@@ -319,6 +311,7 @@
if ((mark != UNSET_MARK) && (mark > newLimit)) {
mark = UNSET_MARK;
}
+ return this;
}
/**
@@ -409,15 +402,11 @@
return this;
}
+ /**
+ * Returns a string describing this buffer.
+ */
@Override public String toString() {
- StringBuilder buf = new StringBuilder();
- buf.append(getClass().getName());
- buf.append(", status: capacity=");
- buf.append(capacity);
- buf.append(" position=");
- buf.append(position);
- buf.append(" limit=");
- buf.append(limit);
- return buf.toString();
+ return getClass().getName() +
+ "[position=" + position + ",limit=" + limit + ",capacity=" + capacity + "]";
}
}
diff --git a/luni/src/main/java/java/nio/ByteArrayBuffer.java b/luni/src/main/java/java/nio/ByteArrayBuffer.java
new file mode 100644
index 0000000..e8d7ecc
--- /dev/null
+++ b/luni/src/main/java/java/nio/ByteArrayBuffer.java
@@ -0,0 +1,435 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package java.nio;
+
+import libcore.io.SizeOf;
+import libcore.io.Memory;
+
+/**
+ * ByteArrayBuffer implements byte[]-backed ByteBuffers.
+ */
+final class ByteArrayBuffer extends ByteBuffer {
+
+ /**
+ * These fields are non-private for NioUtils.unsafeArray.
+ */
+ final byte[] backingArray;
+ final int arrayOffset;
+
+ private final boolean isReadOnly;
+
+ ByteArrayBuffer(byte[] backingArray) {
+ this(backingArray.length, backingArray, 0, false);
+ }
+
+ private ByteArrayBuffer(int capacity, byte[] backingArray, int arrayOffset, boolean isReadOnly) {
+ super(capacity, null);
+ this.backingArray = backingArray;
+ this.arrayOffset = arrayOffset;
+ this.isReadOnly = isReadOnly;
+ if (arrayOffset + capacity > backingArray.length) {
+ throw new IndexOutOfBoundsException("backingArray.length=" + backingArray.length +
+ ", capacity=" + capacity + ", arrayOffset=" + arrayOffset);
+ }
+ }
+
+ private static ByteArrayBuffer copy(ByteArrayBuffer other, int markOfOther, boolean isReadOnly) {
+ ByteArrayBuffer buf = new ByteArrayBuffer(other.capacity(), other.backingArray, other.arrayOffset, isReadOnly);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
+
+ @Override public ByteBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
+
+ @Override public ByteBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ System.arraycopy(backingArray, position + arrayOffset, backingArray, arrayOffset, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
+
+ @Override public ByteBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
+
+ @Override public ByteBuffer slice() {
+ return new ByteArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly);
+ }
+
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
+
+ @Override byte[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ return backingArray;
+ }
+
+ @Override int protectedArrayOffset() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ return arrayOffset;
+ }
+
+ @Override boolean protectedHasArray() {
+ if (isReadOnly) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override public final ByteBuffer get(byte[] dst, int dstOffset, int byteCount) {
+ checkGetBounds(1, dst.length, dstOffset, byteCount);
+ System.arraycopy(backingArray, arrayOffset + position, dst, dstOffset, byteCount);
+ position += byteCount;
+ return this;
+ }
+
+ final void get(char[] dst, int dstOffset, int charCount) {
+ int byteCount = checkGetBounds(SizeOf.CHAR, dst.length, dstOffset, charCount);
+ Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.CHAR, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void get(double[] dst, int dstOffset, int doubleCount) {
+ int byteCount = checkGetBounds(SizeOf.DOUBLE, dst.length, dstOffset, doubleCount);
+ Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.DOUBLE, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void get(float[] dst, int dstOffset, int floatCount) {
+ int byteCount = checkGetBounds(SizeOf.FLOAT, dst.length, dstOffset, floatCount);
+ Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.FLOAT, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void get(int[] dst, int dstOffset, int intCount) {
+ int byteCount = checkGetBounds(SizeOf.INT, dst.length, dstOffset, intCount);
+ Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.INT, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void get(long[] dst, int dstOffset, int longCount) {
+ int byteCount = checkGetBounds(SizeOf.LONG, dst.length, dstOffset, longCount);
+ Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.LONG, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void get(short[] dst, int dstOffset, int shortCount) {
+ int byteCount = checkGetBounds(SizeOf.SHORT, dst.length, dstOffset, shortCount);
+ Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, arrayOffset + position, SizeOf.SHORT, order.needsSwap);
+ position += byteCount;
+ }
+
+ @Override public final byte get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
+ }
+ return backingArray[arrayOffset + position++];
+ }
+
+ @Override public final byte get(int index) {
+ checkIndex(index);
+ return backingArray[arrayOffset + index];
+ }
+
+ @Override public final char getChar() {
+ int newPosition = position + SizeOf.CHAR;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
+ }
+ char result = (char) Memory.peekShort(backingArray, arrayOffset + position, order);
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final char getChar(int index) {
+ checkIndex(index, SizeOf.CHAR);
+ return (char) Memory.peekShort(backingArray, arrayOffset + index, order);
+ }
+
+ @Override public final double getDouble() {
+ return Double.longBitsToDouble(getLong());
+ }
+
+ @Override public final double getDouble(int index) {
+ return Double.longBitsToDouble(getLong(index));
+ }
+
+ @Override public final float getFloat() {
+ return Float.intBitsToFloat(getInt());
+ }
+
+ @Override public final float getFloat(int index) {
+ return Float.intBitsToFloat(getInt(index));
+ }
+
+ @Override public final int getInt() {
+ int newPosition = position + SizeOf.INT;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
+ }
+ int result = Memory.peekInt(backingArray, arrayOffset + position, order);
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final int getInt(int index) {
+ checkIndex(index, SizeOf.INT);
+ return Memory.peekInt(backingArray, arrayOffset + index, order);
+ }
+
+ @Override public final long getLong() {
+ int newPosition = position + SizeOf.LONG;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
+ }
+ long result = Memory.peekLong(backingArray, arrayOffset + position, order);
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final long getLong(int index) {
+ checkIndex(index, SizeOf.LONG);
+ return Memory.peekLong(backingArray, arrayOffset + index, order);
+ }
+
+ @Override public final short getShort() {
+ int newPosition = position + SizeOf.SHORT;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
+ }
+ short result = Memory.peekShort(backingArray, arrayOffset + position, order);
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final short getShort(int index) {
+ checkIndex(index, SizeOf.SHORT);
+ return Memory.peekShort(backingArray, arrayOffset + index, order);
+ }
+
+ @Override public final boolean isDirect() {
+ return false;
+ }
+
+ @Override public ByteBuffer put(byte b) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (position == limit) {
+ throw new BufferOverflowException();
+ }
+ backingArray[arrayOffset + position++] = b;
+ return this;
+ }
+
+ @Override public ByteBuffer put(int index, byte b) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ backingArray[arrayOffset + index] = b;
+ return this;
+ }
+
+ @Override public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkPutBounds(1, src.length, srcOffset, byteCount);
+ System.arraycopy(src, srcOffset, backingArray, arrayOffset + position, byteCount);
+ position += byteCount;
+ return this;
+ }
+
+ final void put(char[] src, int srcOffset, int charCount) {
+ int byteCount = checkPutBounds(SizeOf.CHAR, src.length, srcOffset, charCount);
+ Memory.unsafeBulkPut(backingArray, arrayOffset + position, byteCount, src, srcOffset, SizeOf.CHAR, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(double[] src, int srcOffset, int doubleCount) {
+ int byteCount = checkPutBounds(SizeOf.DOUBLE, src.length, srcOffset, doubleCount);
+ Memory.unsafeBulkPut(backingArray, arrayOffset + position, byteCount, src, srcOffset, SizeOf.DOUBLE, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(float[] src, int srcOffset, int floatCount) {
+ int byteCount = checkPutBounds(SizeOf.FLOAT, src.length, srcOffset, floatCount);
+ Memory.unsafeBulkPut(backingArray, arrayOffset + position, byteCount, src, srcOffset, SizeOf.FLOAT, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(int[] src, int srcOffset, int intCount) {
+ int byteCount = checkPutBounds(SizeOf.INT, src.length, srcOffset, intCount);
+ Memory.unsafeBulkPut(backingArray, arrayOffset + position, byteCount, src, srcOffset, SizeOf.INT, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(long[] src, int srcOffset, int longCount) {
+ int byteCount = checkPutBounds(SizeOf.LONG, src.length, srcOffset, longCount);
+ Memory.unsafeBulkPut(backingArray, arrayOffset + position, byteCount, src, srcOffset, SizeOf.LONG, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(short[] src, int srcOffset, int shortCount) {
+ int byteCount = checkPutBounds(SizeOf.SHORT, src.length, srcOffset, shortCount);
+ Memory.unsafeBulkPut(backingArray, arrayOffset + position, byteCount, src, srcOffset, SizeOf.SHORT, order.needsSwap);
+ position += byteCount;
+ }
+
+ @Override public ByteBuffer putChar(int index, char value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.CHAR);
+ Memory.pokeShort(backingArray, arrayOffset + index, (short) value, order);
+ return this;
+ }
+
+ @Override public ByteBuffer putChar(char value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.CHAR;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ Memory.pokeShort(backingArray, arrayOffset + position, (short) value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putDouble(double value) {
+ return putLong(Double.doubleToRawLongBits(value));
+ }
+
+ @Override public ByteBuffer putDouble(int index, double value) {
+ return putLong(index, Double.doubleToRawLongBits(value));
+ }
+
+ @Override public ByteBuffer putFloat(float value) {
+ return putInt(Float.floatToRawIntBits(value));
+ }
+
+ @Override public ByteBuffer putFloat(int index, float value) {
+ return putInt(index, Float.floatToRawIntBits(value));
+ }
+
+ @Override public ByteBuffer putInt(int value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.INT;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ Memory.pokeInt(backingArray, arrayOffset + position, value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putInt(int index, int value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.INT);
+ Memory.pokeInt(backingArray, arrayOffset + index, value, order);
+ return this;
+ }
+
+ @Override public ByteBuffer putLong(int index, long value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.LONG);
+ Memory.pokeLong(backingArray, arrayOffset + index, value, order);
+ return this;
+ }
+
+ @Override public ByteBuffer putLong(long value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.LONG;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ Memory.pokeLong(backingArray, arrayOffset + position, value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putShort(int index, short value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.SHORT);
+ Memory.pokeShort(backingArray, arrayOffset + index, value, order);
+ return this;
+ }
+
+ @Override public ByteBuffer putShort(short value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.SHORT;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ Memory.pokeShort(backingArray, arrayOffset + position, value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public final CharBuffer asCharBuffer() {
+ return ByteBufferAsCharBuffer.asCharBuffer(this);
+ }
+
+ @Override public final DoubleBuffer asDoubleBuffer() {
+ return ByteBufferAsDoubleBuffer.asDoubleBuffer(this);
+ }
+
+ @Override public final FloatBuffer asFloatBuffer() {
+ return ByteBufferAsFloatBuffer.asFloatBuffer(this);
+ }
+
+ @Override public final IntBuffer asIntBuffer() {
+ return ByteBufferAsIntBuffer.asIntBuffer(this);
+ }
+
+ @Override public final LongBuffer asLongBuffer() {
+ return ByteBufferAsLongBuffer.asLongBuffer(this);
+ }
+
+ @Override public final ShortBuffer asShortBuffer() {
+ return ByteBufferAsShortBuffer.asShortBuffer(this);
+ }
+}
diff --git a/luni/src/main/java/java/nio/ByteBuffer.java b/luni/src/main/java/java/nio/ByteBuffer.java
index 6a3624a..cd39a53 100644
--- a/luni/src/main/java/java/nio/ByteBuffer.java
+++ b/luni/src/main/java/java/nio/ByteBuffer.java
@@ -35,6 +35,10 @@
*
*/
public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer> {
+ /**
+ * The byte order of this buffer, default is {@code BIG_ENDIAN}.
+ */
+ ByteOrder order = ByteOrder.BIG_ENDIAN;
/**
* Creates a byte buffer based on a newly allocated byte array.
@@ -49,7 +53,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteHeapByteBuffer(capacity);
+ return new ByteArrayBuffer(new byte[capacity]);
}
/**
@@ -65,7 +69,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteDirectByteBuffer(capacity);
+ return new DirectByteBuffer(MemoryBlock.allocate(capacity), capacity, 0, false, null);
}
/**
@@ -79,7 +83,7 @@
* @return the created byte buffer.
*/
public static ByteBuffer wrap(byte[] array) {
- return new ReadWriteHeapByteBuffer(array);
+ return new ByteArrayBuffer(array);
}
/**
@@ -102,17 +106,12 @@
*/
public static ByteBuffer wrap(byte[] array, int start, int byteCount) {
Arrays.checkOffsetAndCount(array.length, start, byteCount);
- ByteBuffer buf = new ReadWriteHeapByteBuffer(array);
+ ByteBuffer buf = new ByteArrayBuffer(array);
buf.position = start;
buf.limit = start + byteCount;
return buf;
}
- /**
- * The byte order of this buffer, default is {@code BIG_ENDIAN}.
- */
- ByteOrder order = ByteOrder.BIG_ENDIAN;
-
ByteBuffer(int capacity, MemoryBlock block) {
super(0, capacity, block);
}
@@ -644,18 +643,11 @@
* @see ByteOrder
*/
public final ByteBuffer order(ByteOrder byteOrder) {
- orderImpl(byteOrder);
- return this;
- }
-
- /**
- * Subverts the fact that order(ByteOrder) is final, for the benefit of MappedByteBufferAdapter.
- */
- void orderImpl(ByteOrder byteOrder) {
if (byteOrder == null) {
byteOrder = ByteOrder.LITTLE_ENDIAN;
}
order = byteOrder;
+ return this;
}
/**
@@ -761,6 +753,9 @@
* if no changes may be made to the contents of this buffer.
*/
public ByteBuffer put(ByteBuffer src) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (src == this) {
throw new IllegalArgumentException("src == this");
}
diff --git a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java b/luni/src/main/java/java/nio/ByteBufferAsCharBuffer.java
similarity index 87%
rename from luni/src/main/java/java/nio/CharToByteBufferAdapter.java
rename to luni/src/main/java/java/nio/ByteBufferAsCharBuffer.java
index b9100a2..ef5c52d 100644
--- a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ByteBufferAsCharBuffer.java
@@ -31,17 +31,17 @@
* </p>
*
*/
-final class CharToByteBufferAdapter extends CharBuffer {
+final class ByteBufferAsCharBuffer extends CharBuffer {
private final ByteBuffer byteBuffer;
static CharBuffer asCharBuffer(ByteBuffer byteBuffer) {
ByteBuffer slice = byteBuffer.slice();
slice.order(byteBuffer.order());
- return new CharToByteBufferAdapter(slice);
+ return new ByteBufferAsCharBuffer(slice);
}
- private CharToByteBufferAdapter(ByteBuffer byteBuffer) {
+ private ByteBufferAsCharBuffer(ByteBuffer byteBuffer) {
super(byteBuffer.capacity() / SizeOf.CHAR);
this.byteBuffer = byteBuffer;
this.byteBuffer.clear();
@@ -50,7 +50,7 @@
@Override
public CharBuffer asReadOnlyBuffer() {
- CharToByteBufferAdapter buf = new CharToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());
+ ByteBufferAsCharBuffer buf = new ByteBufferAsCharBuffer(byteBuffer.asReadOnlyBuffer());
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -76,7 +76,7 @@
@Override
public CharBuffer duplicate() {
ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
- CharToByteBufferAdapter buf = new CharToByteBufferAdapter(bb);
+ ByteBufferAsCharBuffer buf = new ByteBufferAsCharBuffer(bb);
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -104,7 +104,7 @@
if (byteBuffer instanceof DirectByteBuffer) {
((DirectByteBuffer) byteBuffer).get(dst, dstOffset, charCount);
} else {
- ((HeapByteBuffer) byteBuffer).get(dst, dstOffset, charCount);
+ ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, charCount);
}
this.position += charCount;
return this;
@@ -157,10 +157,10 @@
public CharBuffer put(char[] src, int srcOffset, int charCount) {
byteBuffer.limit(limit * SizeOf.CHAR);
byteBuffer.position(position * SizeOf.CHAR);
- if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
- ((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, charCount);
+ if (byteBuffer instanceof DirectByteBuffer) {
+ ((DirectByteBuffer) byteBuffer).put(src, srcOffset, charCount);
} else {
- ((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, charCount);
+ ((ByteArrayBuffer) byteBuffer).put(src, srcOffset, charCount);
}
this.position += charCount;
return this;
@@ -171,7 +171,7 @@
byteBuffer.limit(limit * SizeOf.CHAR);
byteBuffer.position(position * SizeOf.CHAR);
ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
- CharBuffer result = new CharToByteBufferAdapter(bb);
+ CharBuffer result = new ByteBufferAsCharBuffer(bb);
byteBuffer.clear();
return result;
}
diff --git a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java b/luni/src/main/java/java/nio/ByteBufferAsDoubleBuffer.java
similarity index 86%
rename from luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
rename to luni/src/main/java/java/nio/ByteBufferAsDoubleBuffer.java
index 8b1e084..044bf59 100644
--- a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ByteBufferAsDoubleBuffer.java
@@ -31,17 +31,17 @@
* </p>
*
*/
-final class DoubleToByteBufferAdapter extends DoubleBuffer {
+final class ByteBufferAsDoubleBuffer extends DoubleBuffer {
private final ByteBuffer byteBuffer;
static DoubleBuffer asDoubleBuffer(ByteBuffer byteBuffer) {
ByteBuffer slice = byteBuffer.slice();
slice.order(byteBuffer.order());
- return new DoubleToByteBufferAdapter(slice);
+ return new ByteBufferAsDoubleBuffer(slice);
}
- private DoubleToByteBufferAdapter(ByteBuffer byteBuffer) {
+ private ByteBufferAsDoubleBuffer(ByteBuffer byteBuffer) {
super(byteBuffer.capacity() / SizeOf.DOUBLE);
this.byteBuffer = byteBuffer;
this.byteBuffer.clear();
@@ -50,7 +50,7 @@
@Override
public DoubleBuffer asReadOnlyBuffer() {
- DoubleToByteBufferAdapter buf = new DoubleToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());
+ ByteBufferAsDoubleBuffer buf = new ByteBufferAsDoubleBuffer(byteBuffer.asReadOnlyBuffer());
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -76,7 +76,7 @@
@Override
public DoubleBuffer duplicate() {
ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
- DoubleToByteBufferAdapter buf = new DoubleToByteBufferAdapter(bb);
+ ByteBufferAsDoubleBuffer buf = new ByteBufferAsDoubleBuffer(bb);
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -104,7 +104,7 @@
if (byteBuffer instanceof DirectByteBuffer) {
((DirectByteBuffer) byteBuffer).get(dst, dstOffset, doubleCount);
} else {
- ((HeapByteBuffer) byteBuffer).get(dst, dstOffset, doubleCount);
+ ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, doubleCount);
}
this.position += doubleCount;
return this;
@@ -157,10 +157,10 @@
public DoubleBuffer put(double[] src, int srcOffset, int doubleCount) {
byteBuffer.limit(limit * SizeOf.DOUBLE);
byteBuffer.position(position * SizeOf.DOUBLE);
- if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
- ((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, doubleCount);
+ if (byteBuffer instanceof DirectByteBuffer) {
+ ((DirectByteBuffer) byteBuffer).put(src, srcOffset, doubleCount);
} else {
- ((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, doubleCount);
+ ((ByteArrayBuffer) byteBuffer).put(src, srcOffset, doubleCount);
}
this.position += doubleCount;
return this;
@@ -171,7 +171,7 @@
byteBuffer.limit(limit * SizeOf.DOUBLE);
byteBuffer.position(position * SizeOf.DOUBLE);
ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
- DoubleBuffer result = new DoubleToByteBufferAdapter(bb);
+ DoubleBuffer result = new ByteBufferAsDoubleBuffer(bb);
byteBuffer.clear();
return result;
}
diff --git a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java b/luni/src/main/java/java/nio/ByteBufferAsFloatBuffer.java
similarity index 86%
rename from luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
rename to luni/src/main/java/java/nio/ByteBufferAsFloatBuffer.java
index 0ed944b..a67affe 100644
--- a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ByteBufferAsFloatBuffer.java
@@ -30,17 +30,17 @@
* </ul>
* </p>
*/
-final class FloatToByteBufferAdapter extends FloatBuffer {
+final class ByteBufferAsFloatBuffer extends FloatBuffer {
private final ByteBuffer byteBuffer;
static FloatBuffer asFloatBuffer(ByteBuffer byteBuffer) {
ByteBuffer slice = byteBuffer.slice();
slice.order(byteBuffer.order());
- return new FloatToByteBufferAdapter(slice);
+ return new ByteBufferAsFloatBuffer(slice);
}
- FloatToByteBufferAdapter(ByteBuffer byteBuffer) {
+ ByteBufferAsFloatBuffer(ByteBuffer byteBuffer) {
super(byteBuffer.capacity() / SizeOf.FLOAT);
this.byteBuffer = byteBuffer;
this.byteBuffer.clear();
@@ -49,7 +49,7 @@
@Override
public FloatBuffer asReadOnlyBuffer() {
- FloatToByteBufferAdapter buf = new FloatToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());
+ ByteBufferAsFloatBuffer buf = new ByteBufferAsFloatBuffer(byteBuffer.asReadOnlyBuffer());
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -75,7 +75,7 @@
@Override
public FloatBuffer duplicate() {
ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
- FloatToByteBufferAdapter buf = new FloatToByteBufferAdapter(bb);
+ ByteBufferAsFloatBuffer buf = new ByteBufferAsFloatBuffer(bb);
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -103,7 +103,7 @@
if (byteBuffer instanceof DirectByteBuffer) {
((DirectByteBuffer) byteBuffer).get(dst, dstOffset, floatCount);
} else {
- ((HeapByteBuffer) byteBuffer).get(dst, dstOffset, floatCount);
+ ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, floatCount);
}
this.position += floatCount;
return this;
@@ -156,10 +156,10 @@
public FloatBuffer put(float[] src, int srcOffset, int floatCount) {
byteBuffer.limit(limit * SizeOf.FLOAT);
byteBuffer.position(position * SizeOf.FLOAT);
- if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
- ((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, floatCount);
+ if (byteBuffer instanceof DirectByteBuffer) {
+ ((DirectByteBuffer) byteBuffer).put(src, srcOffset, floatCount);
} else {
- ((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, floatCount);
+ ((ByteArrayBuffer) byteBuffer).put(src, srcOffset, floatCount);
}
this.position += floatCount;
return this;
@@ -170,7 +170,7 @@
byteBuffer.limit(limit * SizeOf.FLOAT);
byteBuffer.position(position * SizeOf.FLOAT);
ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
- FloatBuffer result = new FloatToByteBufferAdapter(bb);
+ FloatBuffer result = new ByteBufferAsFloatBuffer(bb);
byteBuffer.clear();
return result;
}
diff --git a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java b/luni/src/main/java/java/nio/ByteBufferAsIntBuffer.java
similarity index 87%
rename from luni/src/main/java/java/nio/IntToByteBufferAdapter.java
rename to luni/src/main/java/java/nio/ByteBufferAsIntBuffer.java
index 1af5f86..a3211b8 100644
--- a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ByteBufferAsIntBuffer.java
@@ -31,17 +31,17 @@
* </p>
*
*/
-final class IntToByteBufferAdapter extends IntBuffer {
+final class ByteBufferAsIntBuffer extends IntBuffer {
private final ByteBuffer byteBuffer;
static IntBuffer asIntBuffer(ByteBuffer byteBuffer) {
ByteBuffer slice = byteBuffer.slice();
slice.order(byteBuffer.order());
- return new IntToByteBufferAdapter(slice);
+ return new ByteBufferAsIntBuffer(slice);
}
- private IntToByteBufferAdapter(ByteBuffer byteBuffer) {
+ private ByteBufferAsIntBuffer(ByteBuffer byteBuffer) {
super(byteBuffer.capacity() / SizeOf.INT);
this.byteBuffer = byteBuffer;
this.byteBuffer.clear();
@@ -50,7 +50,7 @@
@Override
public IntBuffer asReadOnlyBuffer() {
- IntToByteBufferAdapter buf = new IntToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());
+ ByteBufferAsIntBuffer buf = new ByteBufferAsIntBuffer(byteBuffer.asReadOnlyBuffer());
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -76,7 +76,7 @@
@Override
public IntBuffer duplicate() {
ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
- IntToByteBufferAdapter buf = new IntToByteBufferAdapter(bb);
+ ByteBufferAsIntBuffer buf = new ByteBufferAsIntBuffer(bb);
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -104,7 +104,7 @@
if (byteBuffer instanceof DirectByteBuffer) {
((DirectByteBuffer) byteBuffer).get(dst, dstOffset, intCount);
} else {
- ((HeapByteBuffer) byteBuffer).get(dst, dstOffset, intCount);
+ ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, intCount);
}
this.position += intCount;
return this;
@@ -157,10 +157,10 @@
public IntBuffer put(int[] src, int srcOffset, int intCount) {
byteBuffer.limit(limit * SizeOf.INT);
byteBuffer.position(position * SizeOf.INT);
- if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
- ((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, intCount);
+ if (byteBuffer instanceof DirectByteBuffer) {
+ ((DirectByteBuffer) byteBuffer).put(src, srcOffset, intCount);
} else {
- ((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, intCount);
+ ((ByteArrayBuffer) byteBuffer).put(src, srcOffset, intCount);
}
this.position += intCount;
return this;
@@ -171,7 +171,7 @@
byteBuffer.limit(limit * SizeOf.INT);
byteBuffer.position(position * SizeOf.INT);
ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
- IntBuffer result = new IntToByteBufferAdapter(bb);
+ IntBuffer result = new ByteBufferAsIntBuffer(bb);
byteBuffer.clear();
return result;
}
diff --git a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java b/luni/src/main/java/java/nio/ByteBufferAsLongBuffer.java
similarity index 86%
rename from luni/src/main/java/java/nio/LongToByteBufferAdapter.java
rename to luni/src/main/java/java/nio/ByteBufferAsLongBuffer.java
index e8bf8df..550c675 100644
--- a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ByteBufferAsLongBuffer.java
@@ -31,17 +31,17 @@
* </p>
*
*/
-final class LongToByteBufferAdapter extends LongBuffer {
+final class ByteBufferAsLongBuffer extends LongBuffer {
private final ByteBuffer byteBuffer;
static LongBuffer asLongBuffer(ByteBuffer byteBuffer) {
ByteBuffer slice = byteBuffer.slice();
slice.order(byteBuffer.order());
- return new LongToByteBufferAdapter(slice);
+ return new ByteBufferAsLongBuffer(slice);
}
- private LongToByteBufferAdapter(ByteBuffer byteBuffer) {
+ private ByteBufferAsLongBuffer(ByteBuffer byteBuffer) {
super(byteBuffer.capacity() / SizeOf.LONG);
this.byteBuffer = byteBuffer;
this.byteBuffer.clear();
@@ -50,7 +50,7 @@
@Override
public LongBuffer asReadOnlyBuffer() {
- LongToByteBufferAdapter buf = new LongToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());
+ ByteBufferAsLongBuffer buf = new ByteBufferAsLongBuffer(byteBuffer.asReadOnlyBuffer());
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -76,7 +76,7 @@
@Override
public LongBuffer duplicate() {
ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
- LongToByteBufferAdapter buf = new LongToByteBufferAdapter(bb);
+ ByteBufferAsLongBuffer buf = new ByteBufferAsLongBuffer(bb);
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -104,7 +104,7 @@
if (byteBuffer instanceof DirectByteBuffer) {
((DirectByteBuffer) byteBuffer).get(dst, dstOffset, longCount);
} else {
- ((HeapByteBuffer) byteBuffer).get(dst, dstOffset, longCount);
+ ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, longCount);
}
this.position += longCount;
return this;
@@ -157,10 +157,10 @@
public LongBuffer put(long[] src, int srcOffset, int longCount) {
byteBuffer.limit(limit * SizeOf.LONG);
byteBuffer.position(position * SizeOf.LONG);
- if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
- ((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, longCount);
+ if (byteBuffer instanceof DirectByteBuffer) {
+ ((DirectByteBuffer) byteBuffer).put(src, srcOffset, longCount);
} else {
- ((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, longCount);
+ ((ByteArrayBuffer) byteBuffer).put(src, srcOffset, longCount);
}
this.position += longCount;
return this;
@@ -171,7 +171,7 @@
byteBuffer.limit(limit * SizeOf.LONG);
byteBuffer.position(position * SizeOf.LONG);
ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
- LongBuffer result = new LongToByteBufferAdapter(bb);
+ LongBuffer result = new ByteBufferAsLongBuffer(bb);
byteBuffer.clear();
return result;
}
diff --git a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java b/luni/src/main/java/java/nio/ByteBufferAsShortBuffer.java
similarity index 86%
rename from luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
rename to luni/src/main/java/java/nio/ByteBufferAsShortBuffer.java
index ee36709..ff81409 100644
--- a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ByteBufferAsShortBuffer.java
@@ -30,17 +30,17 @@
* </ul>
* </p>
*/
-final class ShortToByteBufferAdapter extends ShortBuffer {
+final class ByteBufferAsShortBuffer extends ShortBuffer {
private final ByteBuffer byteBuffer;
static ShortBuffer asShortBuffer(ByteBuffer byteBuffer) {
ByteBuffer slice = byteBuffer.slice();
slice.order(byteBuffer.order());
- return new ShortToByteBufferAdapter(slice);
+ return new ByteBufferAsShortBuffer(slice);
}
- private ShortToByteBufferAdapter(ByteBuffer byteBuffer) {
+ private ByteBufferAsShortBuffer(ByteBuffer byteBuffer) {
super(byteBuffer.capacity() / SizeOf.SHORT);
this.byteBuffer = byteBuffer;
this.byteBuffer.clear();
@@ -49,7 +49,7 @@
@Override
public ShortBuffer asReadOnlyBuffer() {
- ShortToByteBufferAdapter buf = new ShortToByteBufferAdapter(byteBuffer.asReadOnlyBuffer());
+ ByteBufferAsShortBuffer buf = new ByteBufferAsShortBuffer(byteBuffer.asReadOnlyBuffer());
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -75,7 +75,7 @@
@Override
public ShortBuffer duplicate() {
ByteBuffer bb = byteBuffer.duplicate().order(byteBuffer.order());
- ShortToByteBufferAdapter buf = new ShortToByteBufferAdapter(bb);
+ ByteBufferAsShortBuffer buf = new ByteBufferAsShortBuffer(bb);
buf.limit = limit;
buf.position = position;
buf.mark = mark;
@@ -103,7 +103,7 @@
if (byteBuffer instanceof DirectByteBuffer) {
((DirectByteBuffer) byteBuffer).get(dst, dstOffset, shortCount);
} else {
- ((HeapByteBuffer) byteBuffer).get(dst, dstOffset, shortCount);
+ ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, shortCount);
}
this.position += shortCount;
return this;
@@ -156,10 +156,10 @@
public ShortBuffer put(short[] src, int srcOffset, int shortCount) {
byteBuffer.limit(limit * SizeOf.SHORT);
byteBuffer.position(position * SizeOf.SHORT);
- if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
- ((ReadWriteDirectByteBuffer) byteBuffer).put(src, srcOffset, shortCount);
+ if (byteBuffer instanceof DirectByteBuffer) {
+ ((DirectByteBuffer) byteBuffer).put(src, srcOffset, shortCount);
} else {
- ((ReadWriteHeapByteBuffer) byteBuffer).put(src, srcOffset, shortCount);
+ ((ByteArrayBuffer) byteBuffer).put(src, srcOffset, shortCount);
}
this.position += shortCount;
return this;
@@ -170,7 +170,7 @@
byteBuffer.limit(limit * SizeOf.SHORT);
byteBuffer.position(position * SizeOf.SHORT);
ByteBuffer bb = byteBuffer.slice().order(byteBuffer.order());
- ShortBuffer result = new ShortToByteBufferAdapter(bb);
+ ShortBuffer result = new ByteBufferAsShortBuffer(bb);
byteBuffer.clear();
return result;
}
diff --git a/luni/src/main/java/java/nio/CharArrayBuffer.java b/luni/src/main/java/java/nio/CharArrayBuffer.java
index 53d7fb6..43a75a6 100644
--- a/luni/src/main/java/java/nio/CharArrayBuffer.java
+++ b/luni/src/main/java/java/nio/CharArrayBuffer.java
@@ -18,82 +18,153 @@
package java.nio;
/**
- * CharArrayBuffer, ReadWriteCharArrayBuffer and ReadOnlyCharArrayBuffer compose
- * the implementation of array based char buffers.
- * <p>
- * CharArrayBuffer implements all the shared readonly methods and is extended by
- * the other two classes.
- * </p>
- * <p>
- * All methods are marked final for runtime performance.
- * </p>
- *
+ * CharArrayBuffer implements char[]-based CharBuffers.
*/
-abstract class CharArrayBuffer extends CharBuffer {
+final class CharArrayBuffer extends CharBuffer {
- protected final char[] backingArray;
+ private final char[] backingArray;
- protected final int offset;
+ private final int arrayOffset;
- CharArrayBuffer(char[] array) {
- this(array.length, array, 0);
+ private final boolean isReadOnly;
+
+ CharArrayBuffer(char[] array) {
+ this(array.length, array, 0, false);
+ }
+
+ private CharArrayBuffer(int capacity, char[] backingArray, int arrayOffset, boolean isReadOnly) {
+ super(capacity);
+ this.backingArray = backingArray;
+ this.arrayOffset = arrayOffset;
+ this.isReadOnly = isReadOnly;
+ }
+
+ private static CharArrayBuffer copy(CharArrayBuffer other, int markOfOther, boolean isReadOnly) {
+ CharArrayBuffer buf = new CharArrayBuffer(other.capacity(), other.backingArray, other.arrayOffset, isReadOnly);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
+
+ @Override public CharBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
+
+ @Override public CharBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ System.arraycopy(backingArray, position + arrayOffset, backingArray, arrayOffset, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
- CharArrayBuffer(int capacity) {
- this(capacity, new char[capacity], 0);
- }
+ @Override public CharBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
- CharArrayBuffer(int capacity, char[] backingArray, int offset) {
- super(capacity);
- this.backingArray = backingArray;
- this.offset = offset;
- }
+ @Override public CharBuffer slice() {
+ return new CharArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly);
+ }
- @Override
- public final char get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return backingArray[offset + position++];
- }
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
- @Override
- public final char get(int index) {
- checkIndex(index);
- return backingArray[offset + index];
+ @Override char[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return backingArray;
+ }
- @Override
- public final CharBuffer get(char[] dst, int srcOffset, int charCount) {
- if (charCount > remaining()) {
- throw new BufferUnderflowException();
- }
- System.arraycopy(backingArray, offset + position, dst, srcOffset, charCount);
- position += charCount;
- return this;
+ @Override int protectedArrayOffset() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return arrayOffset;
+ }
- @Override
- public final boolean isDirect() {
- return false;
+ @Override boolean protectedHasArray() {
+ if (isReadOnly) {
+ return false;
}
+ return true;
+ }
- @Override
- public final ByteOrder order() {
- return ByteOrder.nativeOrder();
+ @Override public final char get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
}
+ return backingArray[arrayOffset + position++];
+ }
- @Override
- public final CharSequence subSequence(int start, int end) {
- checkStartEndRemaining(start, end);
- CharBuffer result = duplicate();
- result.limit(position + end);
- result.position(position + start);
- return result;
- }
+ @Override public final char get(int index) {
+ checkIndex(index);
+ return backingArray[arrayOffset + index];
+ }
- @Override
- public final String toString() {
- return String.copyValueOf(backingArray, offset + position, remaining());
+ @Override public final CharBuffer get(char[] dst, int srcOffset, int charCount) {
+ if (charCount > remaining()) {
+ throw new BufferUnderflowException();
}
+ System.arraycopy(backingArray, arrayOffset + position, dst, srcOffset, charCount);
+ position += charCount;
+ return this;
+ }
+
+ @Override public final boolean isDirect() {
+ return false;
+ }
+
+ @Override public final ByteOrder order() {
+ return ByteOrder.nativeOrder();
+ }
+
+ @Override public final CharSequence subSequence(int start, int end) {
+ checkStartEndRemaining(start, end);
+ CharBuffer result = duplicate();
+ result.limit(position + end);
+ result.position(position + start);
+ return result;
+ }
+
+ @Override public CharBuffer put(char c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (position == limit) {
+ throw new BufferOverflowException();
+ }
+ backingArray[arrayOffset + position++] = c;
+ return this;
+ }
+
+ @Override public CharBuffer put(int index, char c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ backingArray[arrayOffset + index] = c;
+ return this;
+ }
+
+ @Override public CharBuffer put(char[] src, int srcOffset, int charCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (charCount > remaining()) {
+ throw new BufferOverflowException();
+ }
+ System.arraycopy(src, srcOffset, backingArray, arrayOffset + position, charCount);
+ position += charCount;
+ return this;
+ }
+
+ @Override public final String toString() {
+ return String.copyValueOf(backingArray, arrayOffset + position, remaining());
+ }
}
diff --git a/luni/src/main/java/java/nio/CharBuffer.java b/luni/src/main/java/java/nio/CharBuffer.java
index 6429ae2..5c6f0fc 100644
--- a/luni/src/main/java/java/nio/CharBuffer.java
+++ b/luni/src/main/java/java/nio/CharBuffer.java
@@ -51,7 +51,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteCharArrayBuffer(capacity);
+ return new CharArrayBuffer(new char[capacity]);
}
/**
@@ -88,7 +88,7 @@
*/
public static CharBuffer wrap(char[] array, int start, int charCount) {
Arrays.checkOffsetAndCount(array.length, start, charCount);
- CharBuffer buf = new ReadWriteCharArrayBuffer(array);
+ CharBuffer buf = new CharArrayBuffer(array);
buf.position = start;
buf.limit = start + charCount;
return buf;
@@ -499,6 +499,9 @@
* if no changes may be made to the contents of this buffer.
*/
public CharBuffer put(CharBuffer src) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (src == this) {
throw new IllegalArgumentException("src == this");
}
@@ -568,6 +571,9 @@
* if no changes may be made to the contents of this buffer.
*/
public CharBuffer put(String str, int start, int end) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (start < 0 || end < start || end > str.length()) {
throw new IndexOutOfBoundsException("str.length()=" + str.length() +
", start=" + start + ", end=" + end);
diff --git a/luni/src/main/java/java/nio/DirectByteBuffer.java b/luni/src/main/java/java/nio/DirectByteBuffer.java
index 0ddef14..b624a41 100644
--- a/luni/src/main/java/java/nio/DirectByteBuffer.java
+++ b/luni/src/main/java/java/nio/DirectByteBuffer.java
@@ -17,208 +17,464 @@
package java.nio;
+import java.nio.channels.FileChannel.MapMode;
+
+import libcore.io.Memory;
import libcore.io.SizeOf;
-abstract class DirectByteBuffer extends BaseByteBuffer {
- // This is the offset into {@code Buffer.block} at which this buffer logically starts.
- // TODO: rewrite this so we set 'block' to an OffsetMemoryBlock?
- protected final int offset;
+class DirectByteBuffer extends MappedByteBuffer {
+ // This is the offset into {@code Buffer.block} at which this buffer logically starts.
+ // TODO: rewrite this so we set 'block' to an OffsetMemoryBlock?
+ protected final int offset;
- protected DirectByteBuffer(MemoryBlock block, int capacity, int offset) {
- super(capacity, block);
+ private final boolean isReadOnly;
- long baseSize = block.getSize();
- if (baseSize >= 0 && (capacity + offset) > baseSize) {
- throw new IllegalArgumentException("capacity + offset > baseSize");
- }
+ protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) {
+ super(block, capacity, mapMode);
- this.offset = offset;
- this.effectiveDirectAddress = block.toInt() + offset;
+ long baseSize = block.getSize();
+ if (baseSize >= 0 && (capacity + offset) > baseSize) {
+ throw new IllegalArgumentException("capacity + offset > baseSize");
}
- @Override
- public final ByteBuffer get(byte[] dst, int dstOffset, int byteCount) {
- checkGetBounds(1, dst.length, dstOffset, byteCount);
- this.block.peekByteArray(offset + position, dst, dstOffset, byteCount);
- position += byteCount;
- return this;
- }
+ this.effectiveDirectAddress = block.toInt() + offset;
- final void get(char[] dst, int dstOffset, int charCount) {
- int byteCount = checkGetBounds(SizeOf.CHAR, dst.length, dstOffset, charCount);
- this.block.peekCharArray(offset + position, dst, dstOffset, charCount, order.needsSwap);
- position += byteCount;
- }
+ this.offset = offset;
+ this.isReadOnly = isReadOnly;
+ }
- final void get(double[] dst, int dstOffset, int doubleCount) {
- int byteCount = checkGetBounds(SizeOf.DOUBLE, dst.length, dstOffset, doubleCount);
- this.block.peekDoubleArray(offset + position, dst, dstOffset, doubleCount, order.needsSwap);
- position += byteCount;
- }
+ // Used by the JNI NewDirectByteBuffer function.
+ DirectByteBuffer(int address, int capacity) {
+ this(MemoryBlock.wrapFromJni(address, capacity), capacity, 0, false, null);
+ }
- final void get(float[] dst, int dstOffset, int floatCount) {
- int byteCount = checkGetBounds(SizeOf.FLOAT, dst.length, dstOffset, floatCount);
- this.block.peekFloatArray(offset + position, dst, dstOffset, floatCount, order.needsSwap);
- position += byteCount;
- }
+ private static DirectByteBuffer copy(DirectByteBuffer other, int markOfOther, boolean isReadOnly) {
+ DirectByteBuffer buf = new DirectByteBuffer(other.block, other.capacity(), other.offset, isReadOnly, other.mapMode);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
- final void get(int[] dst, int dstOffset, int intCount) {
- int byteCount = checkGetBounds(SizeOf.INT, dst.length, dstOffset, intCount);
- this.block.peekIntArray(offset + position, dst, dstOffset, intCount, order.needsSwap);
- position += byteCount;
- }
+ @Override public ByteBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
- final void get(long[] dst, int dstOffset, int longCount) {
- int byteCount = checkGetBounds(SizeOf.LONG, dst.length, dstOffset, longCount);
- this.block.peekLongArray(offset + position, dst, dstOffset, longCount, order.needsSwap);
- position += byteCount;
+ @Override public ByteBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ Memory.memmove(this, 0, this, position, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
- final void get(short[] dst, int dstOffset, int shortCount) {
- int byteCount = checkGetBounds(SizeOf.SHORT, dst.length, dstOffset, shortCount);
- this.block.peekShortArray(offset + position, dst, dstOffset, shortCount, order.needsSwap);
- position += byteCount;
- }
+ @Override public ByteBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
- @Override
- public final byte get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return this.block.peekByte(offset + position++);
- }
+ @Override public ByteBuffer slice() {
+ return new DirectByteBuffer(block, remaining(), offset + position, isReadOnly, mapMode);
+ }
- @Override
- public final byte get(int index) {
- checkIndex(index);
- return this.block.peekByte(offset + index);
- }
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
- @Override
- public final char getChar() {
- int newPosition = position + SizeOf.CHAR;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- char result = (char) this.block.peekShort(offset + position, order);
- position = newPosition;
- return result;
+ @Override byte[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ byte[] array = this.block.array();
+ if (array == null) {
+ throw new UnsupportedOperationException();
+ }
+ return array;
+ }
- @Override
- public final char getChar(int index) {
- checkIndex(index, SizeOf.CHAR);
- return (char) this.block.peekShort(offset + index, order);
- }
+ @Override int protectedArrayOffset() {
+ protectedArray(); // Throw if we don't have an array or are read-only.
+ return offset;
+ }
- @Override
- public final double getDouble() {
- int newPosition = position + SizeOf.DOUBLE;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- double result = Double.longBitsToDouble(this.block.peekLong(offset + position, order));
- position = newPosition;
- return result;
- }
+ @Override boolean protectedHasArray() {
+ return !isReadOnly && (block.array() != null);
+ }
- @Override
- public final double getDouble(int index) {
- checkIndex(index, SizeOf.DOUBLE);
- return Double.longBitsToDouble(this.block.peekLong(offset + index, order));
- }
+ @Override public final ByteBuffer get(byte[] dst, int dstOffset, int byteCount) {
+ checkGetBounds(1, dst.length, dstOffset, byteCount);
+ this.block.peekByteArray(offset + position, dst, dstOffset, byteCount);
+ position += byteCount;
+ return this;
+ }
- @Override
- public final float getFloat() {
- int newPosition = position + SizeOf.FLOAT;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- float result = Float.intBitsToFloat(this.block.peekInt(offset + position, order));
- position = newPosition;
- return result;
- }
+ final void get(char[] dst, int dstOffset, int charCount) {
+ int byteCount = checkGetBounds(SizeOf.CHAR, dst.length, dstOffset, charCount);
+ this.block.peekCharArray(offset + position, dst, dstOffset, charCount, order.needsSwap);
+ position += byteCount;
+ }
- @Override
- public final float getFloat(int index) {
- checkIndex(index, SizeOf.FLOAT);
- return Float.intBitsToFloat(this.block.peekInt(offset + index, order));
- }
+ final void get(double[] dst, int dstOffset, int doubleCount) {
+ int byteCount = checkGetBounds(SizeOf.DOUBLE, dst.length, dstOffset, doubleCount);
+ this.block.peekDoubleArray(offset + position, dst, dstOffset, doubleCount, order.needsSwap);
+ position += byteCount;
+ }
- @Override
- public final int getInt() {
- int newPosition = position + SizeOf.INT;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- int result = this.block.peekInt(offset + position, order);
- position = newPosition;
- return result;
- }
+ final void get(float[] dst, int dstOffset, int floatCount) {
+ int byteCount = checkGetBounds(SizeOf.FLOAT, dst.length, dstOffset, floatCount);
+ this.block.peekFloatArray(offset + position, dst, dstOffset, floatCount, order.needsSwap);
+ position += byteCount;
+ }
- @Override
- public final int getInt(int index) {
- checkIndex(index, SizeOf.INT);
- return this.block.peekInt(offset + index, order);
- }
+ final void get(int[] dst, int dstOffset, int intCount) {
+ int byteCount = checkGetBounds(SizeOf.INT, dst.length, dstOffset, intCount);
+ this.block.peekIntArray(offset + position, dst, dstOffset, intCount, order.needsSwap);
+ position += byteCount;
+ }
- @Override
- public final long getLong() {
- int newPosition = position + SizeOf.LONG;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- long result = this.block.peekLong(offset + position, order);
- position = newPosition;
- return result;
- }
+ final void get(long[] dst, int dstOffset, int longCount) {
+ int byteCount = checkGetBounds(SizeOf.LONG, dst.length, dstOffset, longCount);
+ this.block.peekLongArray(offset + position, dst, dstOffset, longCount, order.needsSwap);
+ position += byteCount;
+ }
- @Override
- public final long getLong(int index) {
- checkIndex(index, SizeOf.LONG);
- return this.block.peekLong(offset + index, order);
- }
+ final void get(short[] dst, int dstOffset, int shortCount) {
+ int byteCount = checkGetBounds(SizeOf.SHORT, dst.length, dstOffset, shortCount);
+ this.block.peekShortArray(offset + position, dst, dstOffset, shortCount, order.needsSwap);
+ position += byteCount;
+ }
- @Override
- public final short getShort() {
- int newPosition = position + SizeOf.SHORT;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- short result = this.block.peekShort(offset + position, order);
- position = newPosition;
- return result;
+ @Override public final byte get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
}
+ return this.block.peekByte(offset + position++);
+ }
- @Override
- public final short getShort(int index) {
- checkIndex(index, SizeOf.SHORT);
- return this.block.peekShort(offset + index, order);
- }
+ @Override public final byte get(int index) {
+ checkIndex(index);
+ return this.block.peekByte(offset + index);
+ }
- @Override
- public final boolean isDirect() {
- return true;
+ @Override public final char getChar() {
+ int newPosition = position + SizeOf.CHAR;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
}
+ char result = (char) this.block.peekShort(offset + position, order);
+ position = newPosition;
+ return result;
+ }
- public final void free() {
- block.free();
- }
+ @Override public final char getChar(int index) {
+ checkIndex(index, SizeOf.CHAR);
+ return (char) this.block.peekShort(offset + index, order);
+ }
- @Override byte[] protectedArray() {
- byte[] array = this.block.array();
- if (array == null) {
- throw new UnsupportedOperationException();
- }
- return array;
+ @Override public final double getDouble() {
+ int newPosition = position + SizeOf.DOUBLE;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
}
+ double result = Double.longBitsToDouble(this.block.peekLong(offset + position, order));
+ position = newPosition;
+ return result;
+ }
- @Override int protectedArrayOffset() {
- protectedArray(); // Throw if we don't have an array.
- return offset;
- }
+ @Override public final double getDouble(int index) {
+ checkIndex(index, SizeOf.DOUBLE);
+ return Double.longBitsToDouble(this.block.peekLong(offset + index, order));
+ }
- @Override boolean protectedHasArray() {
- return this.block.array() != null;
+ @Override public final float getFloat() {
+ int newPosition = position + SizeOf.FLOAT;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
}
+ float result = Float.intBitsToFloat(this.block.peekInt(offset + position, order));
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final float getFloat(int index) {
+ checkIndex(index, SizeOf.FLOAT);
+ return Float.intBitsToFloat(this.block.peekInt(offset + index, order));
+ }
+
+ @Override public final int getInt() {
+ int newPosition = position + SizeOf.INT;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
+ }
+ int result = this.block.peekInt(offset + position, order);
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final int getInt(int index) {
+ checkIndex(index, SizeOf.INT);
+ return this.block.peekInt(offset + index, order);
+ }
+
+ @Override public final long getLong() {
+ int newPosition = position + SizeOf.LONG;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
+ }
+ long result = this.block.peekLong(offset + position, order);
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final long getLong(int index) {
+ checkIndex(index, SizeOf.LONG);
+ return this.block.peekLong(offset + index, order);
+ }
+
+ @Override public final short getShort() {
+ int newPosition = position + SizeOf.SHORT;
+ if (newPosition > limit) {
+ throw new BufferUnderflowException();
+ }
+ short result = this.block.peekShort(offset + position, order);
+ position = newPosition;
+ return result;
+ }
+
+ @Override public final short getShort(int index) {
+ checkIndex(index, SizeOf.SHORT);
+ return this.block.peekShort(offset + index, order);
+ }
+
+ @Override public final boolean isDirect() {
+ return true;
+ }
+
+ public final void free() {
+ block.free();
+ }
+
+ @Override public final CharBuffer asCharBuffer() {
+ return ByteBufferAsCharBuffer.asCharBuffer(this);
+ }
+
+ @Override public final DoubleBuffer asDoubleBuffer() {
+ return ByteBufferAsDoubleBuffer.asDoubleBuffer(this);
+ }
+
+ @Override public final FloatBuffer asFloatBuffer() {
+ return ByteBufferAsFloatBuffer.asFloatBuffer(this);
+ }
+
+ @Override public final IntBuffer asIntBuffer() {
+ return ByteBufferAsIntBuffer.asIntBuffer(this);
+ }
+
+ @Override public final LongBuffer asLongBuffer() {
+ return ByteBufferAsLongBuffer.asLongBuffer(this);
+ }
+
+ @Override public final ShortBuffer asShortBuffer() {
+ return ByteBufferAsShortBuffer.asShortBuffer(this);
+ }
+
+ @Override public ByteBuffer put(byte value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (position == limit) {
+ throw new BufferOverflowException();
+ }
+ this.block.pokeByte(offset + position++, value);
+ return this;
+ }
+
+ @Override public ByteBuffer put(int index, byte value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ this.block.pokeByte(offset + index, value);
+ return this;
+ }
+
+ @Override public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkPutBounds(1, src.length, srcOffset, byteCount);
+ this.block.pokeByteArray(offset + position, src, srcOffset, byteCount);
+ position += byteCount;
+ return this;
+ }
+
+ final void put(char[] src, int srcOffset, int charCount) {
+ int byteCount = checkPutBounds(SizeOf.CHAR, src.length, srcOffset, charCount);
+ this.block.pokeCharArray(offset + position, src, srcOffset, charCount, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(double[] src, int srcOffset, int doubleCount) {
+ int byteCount = checkPutBounds(SizeOf.DOUBLE, src.length, srcOffset, doubleCount);
+ this.block.pokeDoubleArray(offset + position, src, srcOffset, doubleCount, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(float[] src, int srcOffset, int floatCount) {
+ int byteCount = checkPutBounds(SizeOf.FLOAT, src.length, srcOffset, floatCount);
+ this.block.pokeFloatArray(offset + position, src, srcOffset, floatCount, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(int[] src, int srcOffset, int intCount) {
+ int byteCount = checkPutBounds(SizeOf.INT, src.length, srcOffset, intCount);
+ this.block.pokeIntArray(offset + position, src, srcOffset, intCount, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(long[] src, int srcOffset, int longCount) {
+ int byteCount = checkPutBounds(SizeOf.LONG, src.length, srcOffset, longCount);
+ this.block.pokeLongArray(offset + position, src, srcOffset, longCount, order.needsSwap);
+ position += byteCount;
+ }
+
+ final void put(short[] src, int srcOffset, int shortCount) {
+ int byteCount = checkPutBounds(SizeOf.SHORT, src.length, srcOffset, shortCount);
+ this.block.pokeShortArray(offset + position, src, srcOffset, shortCount, order.needsSwap);
+ position += byteCount;
+ }
+
+ @Override public ByteBuffer putChar(char value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.CHAR;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ this.block.pokeShort(offset + position, (short) value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putChar(int index, char value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.CHAR);
+ this.block.pokeShort(offset + index, (short) value, order);
+ return this;
+ }
+
+ @Override public ByteBuffer putDouble(double value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.DOUBLE;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ this.block.pokeLong(offset + position, Double.doubleToRawLongBits(value), order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putDouble(int index, double value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.DOUBLE);
+ this.block.pokeLong(offset + index, Double.doubleToRawLongBits(value), order);
+ return this;
+ }
+
+ @Override public ByteBuffer putFloat(float value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.FLOAT;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ this.block.pokeInt(offset + position, Float.floatToRawIntBits(value), order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putFloat(int index, float value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.FLOAT);
+ this.block.pokeInt(offset + index, Float.floatToRawIntBits(value), order);
+ return this;
+ }
+
+ @Override public ByteBuffer putInt(int value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.INT;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ this.block.pokeInt(offset + position, value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putInt(int index, int value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.INT);
+ this.block.pokeInt(offset + index, value, order);
+ return this;
+ }
+
+ @Override public ByteBuffer putLong(long value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.LONG;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ this.block.pokeLong(offset + position, value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putLong(int index, long value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.LONG);
+ this.block.pokeLong(offset + index, value, order);
+ return this;
+ }
+
+ @Override public ByteBuffer putShort(short value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ int newPosition = position + SizeOf.SHORT;
+ if (newPosition > limit) {
+ throw new BufferOverflowException();
+ }
+ this.block.pokeShort(offset + position, value, order);
+ position = newPosition;
+ return this;
+ }
+
+ @Override public ByteBuffer putShort(int index, short value) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index, SizeOf.SHORT);
+ this.block.pokeShort(offset + index, value, order);
+ return this;
+ }
}
diff --git a/luni/src/main/java/java/nio/DoubleArrayBuffer.java b/luni/src/main/java/java/nio/DoubleArrayBuffer.java
index ec32a80..f8e4e59 100644
--- a/luni/src/main/java/java/nio/DoubleArrayBuffer.java
+++ b/luni/src/main/java/java/nio/DoubleArrayBuffer.java
@@ -18,69 +18,141 @@
package java.nio;
/**
- * DoubleArrayBuffer, ReadWriteDoubleArrayBuffer and ReadOnlyDoubleArrayBuffer
- * compose the implementation of array based double buffers.
- * <p>
- * DoubleArrayBuffer implements all the shared readonly methods and is extended
- * by the other two classes.
- * </p>
- * <p>
- * All methods are marked final for runtime performance.
- * </p>
- *
+ * DoubleArrayBuffer implements double[]-based DoubleBuffers.
*/
-abstract class DoubleArrayBuffer extends DoubleBuffer {
+final class DoubleArrayBuffer extends DoubleBuffer {
- protected final double[] backingArray;
+ private final double[] backingArray;
- protected final int offset;
+ private final int arrayOffset;
- DoubleArrayBuffer(double[] array) {
- this(array.length, array, 0);
+ private final boolean isReadOnly;
+
+ DoubleArrayBuffer(double[] array) {
+ this(array.length, array, 0, false);
+ }
+
+ private DoubleArrayBuffer(int capacity, double[] backingArray, int arrayOffset, boolean isReadOnly) {
+ super(capacity);
+ this.backingArray = backingArray;
+ this.arrayOffset = arrayOffset;
+ this.isReadOnly = isReadOnly;
+ }
+
+ private static DoubleArrayBuffer copy(DoubleArrayBuffer other, int markOfOther, boolean isReadOnly) {
+ DoubleArrayBuffer buf = new DoubleArrayBuffer(other.capacity(), other.backingArray, other.arrayOffset, isReadOnly);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
+
+ @Override public DoubleBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
+
+ @Override public DoubleBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ System.arraycopy(backingArray, position + arrayOffset, backingArray, arrayOffset, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
- DoubleArrayBuffer(int capacity) {
- this(capacity, new double[capacity], 0);
+ @Override public DoubleBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
+
+ @Override public DoubleBuffer slice() {
+ return new DoubleArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly);
+ }
+
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
+
+ @Override double[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return backingArray;
+ }
- DoubleArrayBuffer(int capacity, double[] backingArray, int offset) {
- super(capacity);
- this.backingArray = backingArray;
- this.offset = offset;
+ @Override int protectedArrayOffset() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return arrayOffset;
+ }
- @Override
- public final double get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return backingArray[offset + position++];
+ @Override boolean protectedHasArray() {
+ if (isReadOnly) {
+ return false;
}
+ return true;
+ }
- @Override
- public final double get(int index) {
- checkIndex(index);
- return backingArray[offset + index];
+ @Override public final double get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
}
+ return backingArray[arrayOffset + position++];
+ }
- @Override
- public final DoubleBuffer get(double[] dst, int dstOffset, int doubleCount) {
- if (doubleCount > remaining()) {
- throw new BufferUnderflowException();
- }
- System.arraycopy(backingArray, offset + position, dst, dstOffset, doubleCount);
- position += doubleCount;
- return this;
+ @Override public final double get(int index) {
+ checkIndex(index);
+ return backingArray[arrayOffset + index];
+ }
+
+ @Override public final DoubleBuffer get(double[] dst, int dstOffset, int doubleCount) {
+ if (doubleCount > remaining()) {
+ throw new BufferUnderflowException();
}
+ System.arraycopy(backingArray, arrayOffset + position, dst, dstOffset, doubleCount);
+ position += doubleCount;
+ return this;
+ }
- @Override
- public final boolean isDirect() {
- return false;
+ @Override public final boolean isDirect() {
+ return false;
+ }
+
+ @Override public final ByteOrder order() {
+ return ByteOrder.nativeOrder();
+ }
+
+ @Override public DoubleBuffer put(double c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
-
- @Override
- public final ByteOrder order() {
- return ByteOrder.nativeOrder();
+ if (position == limit) {
+ throw new BufferOverflowException();
}
+ backingArray[arrayOffset + position++] = c;
+ return this;
+ }
+ @Override public DoubleBuffer put(int index, double c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ backingArray[arrayOffset + index] = c;
+ return this;
+ }
+
+ @Override public DoubleBuffer put(double[] src, int srcOffset, int doubleCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (doubleCount > remaining()) {
+ throw new BufferOverflowException();
+ }
+ System.arraycopy(src, srcOffset, backingArray, arrayOffset + position, doubleCount);
+ position += doubleCount;
+ return this;
+ }
}
diff --git a/luni/src/main/java/java/nio/DoubleBuffer.java b/luni/src/main/java/java/nio/DoubleBuffer.java
index 8d90f89..401536d 100644
--- a/luni/src/main/java/java/nio/DoubleBuffer.java
+++ b/luni/src/main/java/java/nio/DoubleBuffer.java
@@ -49,7 +49,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteDoubleArrayBuffer(capacity);
+ return new DoubleArrayBuffer(new double[capacity]);
}
/**
@@ -86,7 +86,7 @@
*/
public static DoubleBuffer wrap(double[] array, int start, int doubleCount) {
Arrays.checkOffsetAndCount(array.length, start, doubleCount);
- DoubleBuffer buf = new ReadWriteDoubleArrayBuffer(array);
+ DoubleBuffer buf = new DoubleArrayBuffer(array);
buf.position = start;
buf.limit = start + doubleCount;
return buf;
@@ -437,6 +437,9 @@
* if no changes may be made to the contents of this buffer.
*/
public DoubleBuffer put(DoubleBuffer src) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (src == this) {
throw new IllegalArgumentException("src == this");
}
diff --git a/luni/src/main/java/java/nio/FileChannelImpl.java b/luni/src/main/java/java/nio/FileChannelImpl.java
index 98be748..14e06b7 100644
--- a/luni/src/main/java/java/nio/FileChannelImpl.java
+++ b/luni/src/main/java/java/nio/FileChannelImpl.java
@@ -247,7 +247,7 @@
long alignment = position - position % Libcore.os.sysconf(_SC_PAGE_SIZE);
int offset = (int) (position - alignment);
MemoryBlock block = MemoryBlock.mmap(fd, alignment, size + offset, mapMode);
- return new MappedByteBufferAdapter(block, (int) size, offset, mapMode);
+ return new DirectByteBuffer(block, (int) size, offset, (mapMode == MapMode.READ_ONLY), mapMode);
}
public long position() throws IOException {
diff --git a/luni/src/main/java/java/nio/FloatArrayBuffer.java b/luni/src/main/java/java/nio/FloatArrayBuffer.java
index c47ee21..698174c 100644
--- a/luni/src/main/java/java/nio/FloatArrayBuffer.java
+++ b/luni/src/main/java/java/nio/FloatArrayBuffer.java
@@ -18,69 +18,142 @@
package java.nio;
/**
- * FloatArrayBuffer, ReadWriteFloatArrayBuffer and ReadOnlyFloatArrayBuffer
- * compose the implementation of array based float buffers.
- * <p>
- * FloatArrayBuffer implements all the shared readonly methods and is extended
- * by the other two classes.
- * </p>
- * <p>
- * All methods are marked final for runtime performance.
- * </p>
- *
+ * FloatArrayBuffer implements float[]-based FloatBuffers.
*/
-abstract class FloatArrayBuffer extends FloatBuffer {
+final class FloatArrayBuffer extends FloatBuffer {
- protected final float[] backingArray;
+ private final float[] backingArray;
- protected final int offset;
+ private final int arrayOffset;
- FloatArrayBuffer(float[] array) {
- this(array.length, array, 0);
+ private final boolean isReadOnly;
+
+ FloatArrayBuffer(float[] array) {
+ this(array.length, array, 0, false);
+ }
+
+ private FloatArrayBuffer(int capacity, float[] backingArray, int arrayOffset, boolean isReadOnly) {
+ super(capacity);
+ this.backingArray = backingArray;
+ this.arrayOffset = arrayOffset;
+ this.isReadOnly = isReadOnly;
+ }
+
+ private static FloatArrayBuffer copy(FloatArrayBuffer other, int markOfOther, boolean isReadOnly) {
+ FloatArrayBuffer buf = new FloatArrayBuffer(other.capacity(), other.backingArray, other.arrayOffset, isReadOnly);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
+
+ @Override public FloatBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
+
+
+ @Override public FloatBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ System.arraycopy(backingArray, position + arrayOffset, backingArray, arrayOffset, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
- FloatArrayBuffer(int capacity) {
- this(capacity, new float[capacity], 0);
+ @Override public FloatBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
+
+ @Override public FloatBuffer slice() {
+ return new FloatArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly);
+ }
+
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
+
+ @Override float[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return backingArray;
+ }
- FloatArrayBuffer(int capacity, float[] backingArray, int offset) {
- super(capacity);
- this.backingArray = backingArray;
- this.offset = offset;
+ @Override int protectedArrayOffset() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return arrayOffset;
+ }
- @Override
- public final float get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return backingArray[offset + position++];
+ @Override boolean protectedHasArray() {
+ if (isReadOnly) {
+ return false;
}
+ return true;
+ }
- @Override
- public final float get(int index) {
- checkIndex(index);
- return backingArray[offset + index];
+ @Override public final float get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
}
+ return backingArray[arrayOffset + position++];
+ }
- @Override
- public final FloatBuffer get(float[] dst, int dstOffset, int floatCount) {
- if (floatCount > remaining()) {
- throw new BufferUnderflowException();
- }
- System.arraycopy(backingArray, offset + position, dst, dstOffset, floatCount);
- position += floatCount;
- return this;
+ @Override public final float get(int index) {
+ checkIndex(index);
+ return backingArray[arrayOffset + index];
+ }
+
+ @Override public final FloatBuffer get(float[] dst, int dstOffset, int floatCount) {
+ if (floatCount > remaining()) {
+ throw new BufferUnderflowException();
}
+ System.arraycopy(backingArray, arrayOffset + position, dst, dstOffset, floatCount);
+ position += floatCount;
+ return this;
+ }
- @Override
- public final boolean isDirect() {
- return false;
+ @Override public final boolean isDirect() {
+ return false;
+ }
+
+ @Override public final ByteOrder order() {
+ return ByteOrder.nativeOrder();
+ }
+
+ @Override public FloatBuffer put(float c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
-
- @Override
- public final ByteOrder order() {
- return ByteOrder.nativeOrder();
+ if (position == limit) {
+ throw new BufferOverflowException();
}
+ backingArray[arrayOffset + position++] = c;
+ return this;
+ }
+ @Override public FloatBuffer put(int index, float c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ backingArray[arrayOffset + index] = c;
+ return this;
+ }
+
+ @Override public FloatBuffer put(float[] src, int srcOffset, int floatCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (floatCount > remaining()) {
+ throw new BufferOverflowException();
+ }
+ System.arraycopy(src, srcOffset, backingArray, arrayOffset + position, floatCount);
+ position += floatCount;
+ return this;
+ }
}
diff --git a/luni/src/main/java/java/nio/FloatBuffer.java b/luni/src/main/java/java/nio/FloatBuffer.java
index 814eb53..ac5e572 100644
--- a/luni/src/main/java/java/nio/FloatBuffer.java
+++ b/luni/src/main/java/java/nio/FloatBuffer.java
@@ -48,7 +48,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteFloatArrayBuffer(capacity);
+ return new FloatArrayBuffer(new float[capacity]);
}
/**
@@ -87,7 +87,7 @@
*/
public static FloatBuffer wrap(float[] array, int start, int floatCount) {
Arrays.checkOffsetAndCount(array.length, start, floatCount);
- FloatBuffer buf = new ReadWriteFloatArrayBuffer(array);
+ FloatBuffer buf = new FloatArrayBuffer(array);
buf.position = start;
buf.limit = start + floatCount;
return buf;
@@ -436,6 +436,9 @@
* if no changes may be made to the contents of this buffer.
*/
public FloatBuffer put(FloatBuffer src) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (src == this) {
throw new IllegalArgumentException("src == this");
}
diff --git a/luni/src/main/java/java/nio/HeapByteBuffer.java b/luni/src/main/java/java/nio/HeapByteBuffer.java
deleted file mode 100644
index 6b65ec1..0000000
--- a/luni/src/main/java/java/nio/HeapByteBuffer.java
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-import libcore.io.SizeOf;
-import libcore.io.Memory;
-
-/**
- * HeapByteBuffer, ReadWriteHeapByteBuffer and ReadOnlyHeapByteBuffer compose
- * the implementation of array based byte buffers.
- * <p>
- * HeapByteBuffer implements all the shared readonly methods and is extended by
- * the other two classes.
- * </p>
- * <p>
- * All methods are marked final for runtime performance.
- * </p>
- *
- */
-abstract class HeapByteBuffer extends BaseByteBuffer {
-
- /**
- * These fields are non-private for NioUtils.unsafeArray.
- */
- final byte[] backingArray;
- final int offset;
-
- HeapByteBuffer(byte[] backingArray) {
- this(backingArray, backingArray.length, 0);
- }
-
- HeapByteBuffer(int capacity) {
- this(new byte[capacity], capacity, 0);
- }
-
- HeapByteBuffer(byte[] backingArray, int capacity, int offset) {
- super(capacity, null);
- this.backingArray = backingArray;
- this.offset = offset;
- if (offset + capacity > backingArray.length) {
- throw new IndexOutOfBoundsException("backingArray.length=" + backingArray.length +
- ", capacity=" + capacity + ", offset=" + offset);
- }
- }
-
- @Override
- public final ByteBuffer get(byte[] dst, int dstOffset, int byteCount) {
- checkGetBounds(1, dst.length, dstOffset, byteCount);
- System.arraycopy(backingArray, offset + position, dst, dstOffset, byteCount);
- position += byteCount;
- return this;
- }
-
- final void get(char[] dst, int dstOffset, int charCount) {
- int byteCount = checkGetBounds(SizeOf.CHAR, dst.length, dstOffset, charCount);
- Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.CHAR, order.needsSwap);
- position += byteCount;
- }
-
- final void get(double[] dst, int dstOffset, int doubleCount) {
- int byteCount = checkGetBounds(SizeOf.DOUBLE, dst.length, dstOffset, doubleCount);
- Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.DOUBLE, order.needsSwap);
- position += byteCount;
- }
-
- final void get(float[] dst, int dstOffset, int floatCount) {
- int byteCount = checkGetBounds(SizeOf.FLOAT, dst.length, dstOffset, floatCount);
- Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.FLOAT, order.needsSwap);
- position += byteCount;
- }
-
- final void get(int[] dst, int dstOffset, int intCount) {
- int byteCount = checkGetBounds(SizeOf.INT, dst.length, dstOffset, intCount);
- Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.INT, order.needsSwap);
- position += byteCount;
- }
-
- final void get(long[] dst, int dstOffset, int longCount) {
- int byteCount = checkGetBounds(SizeOf.LONG, dst.length, dstOffset, longCount);
- Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.LONG, order.needsSwap);
- position += byteCount;
- }
-
- final void get(short[] dst, int dstOffset, int shortCount) {
- int byteCount = checkGetBounds(SizeOf.SHORT, dst.length, dstOffset, shortCount);
- Memory.unsafeBulkGet(dst, dstOffset, byteCount, backingArray, offset + position, SizeOf.SHORT, order.needsSwap);
- position += byteCount;
- }
-
- @Override
- public final byte get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return backingArray[offset + position++];
- }
-
- @Override
- public final byte get(int index) {
- checkIndex(index);
- return backingArray[offset + index];
- }
-
- @Override
- public final char getChar() {
- int newPosition = position + SizeOf.CHAR;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- char result = (char) Memory.peekShort(backingArray, offset + position, order);
- position = newPosition;
- return result;
- }
-
- @Override
- public final char getChar(int index) {
- checkIndex(index, SizeOf.CHAR);
- return (char) Memory.peekShort(backingArray, offset + index, order);
- }
-
- @Override
- public final double getDouble() {
- return Double.longBitsToDouble(getLong());
- }
-
- @Override
- public final double getDouble(int index) {
- return Double.longBitsToDouble(getLong(index));
- }
-
- @Override
- public final float getFloat() {
- return Float.intBitsToFloat(getInt());
- }
-
- @Override
- public final float getFloat(int index) {
- return Float.intBitsToFloat(getInt(index));
- }
-
- @Override
- public final int getInt() {
- int newPosition = position + SizeOf.INT;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- int result = Memory.peekInt(backingArray, offset + position, order);
- position = newPosition;
- return result;
- }
-
- @Override
- public final int getInt(int index) {
- checkIndex(index, SizeOf.INT);
- return Memory.peekInt(backingArray, offset + index, order);
- }
-
- @Override
- public final long getLong() {
- int newPosition = position + SizeOf.LONG;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- long result = Memory.peekLong(backingArray, offset + position, order);
- position = newPosition;
- return result;
- }
-
- @Override
- public final long getLong(int index) {
- checkIndex(index, SizeOf.LONG);
- return Memory.peekLong(backingArray, offset + index, order);
- }
-
- @Override
- public final short getShort() {
- int newPosition = position + SizeOf.SHORT;
- if (newPosition > limit) {
- throw new BufferUnderflowException();
- }
- short result = Memory.peekShort(backingArray, offset + position, order);
- position = newPosition;
- return result;
- }
-
- @Override
- public final short getShort(int index) {
- checkIndex(index, SizeOf.SHORT);
- return Memory.peekShort(backingArray, offset + index, order);
- }
-
- @Override
- public final boolean isDirect() {
- return false;
- }
-}
diff --git a/luni/src/main/java/java/nio/IntArrayBuffer.java b/luni/src/main/java/java/nio/IntArrayBuffer.java
index d031415..a5f9f39 100644
--- a/luni/src/main/java/java/nio/IntArrayBuffer.java
+++ b/luni/src/main/java/java/nio/IntArrayBuffer.java
@@ -18,69 +18,141 @@
package java.nio;
/**
- * IntArrayBuffer, ReadWriteIntArrayBuffer and ReadOnlyIntArrayBuffer compose
- * the implementation of array based int buffers.
- * <p>
- * IntArrayBuffer implements all the shared readonly methods and is extended by
- * the other two classes.
- * </p>
- * <p>
- * All methods are marked final for runtime performance.
- * </p>
- *
+ * IntArrayBuffer implements int[]-based IntBuffers.
*/
-abstract class IntArrayBuffer extends IntBuffer {
+final class IntArrayBuffer extends IntBuffer {
- protected final int[] backingArray;
+ private final int[] backingArray;
- protected final int offset;
+ private final int arrayOffset;
- IntArrayBuffer(int[] array) {
- this(array.length, array, 0);
+ private final boolean isReadOnly;
+
+ IntArrayBuffer(int[] array) {
+ this(array.length, array, 0, false);
+ }
+
+ private IntArrayBuffer(int capacity, int[] backingArray, int arrayOffset, boolean isReadOnly) {
+ super(capacity);
+ this.backingArray = backingArray;
+ this.arrayOffset = arrayOffset;
+ this.isReadOnly = isReadOnly;
+ }
+
+ private static IntArrayBuffer copy(IntArrayBuffer other, int markOfOther, boolean isReadOnly) {
+ IntArrayBuffer buf = new IntArrayBuffer(other.capacity(), other.backingArray, other.arrayOffset, isReadOnly);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
+
+ @Override public IntBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
+
+ @Override public IntBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ System.arraycopy(backingArray, position + arrayOffset, backingArray, arrayOffset, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
- IntArrayBuffer(int capacity) {
- this(capacity, new int[capacity], 0);
+ @Override public IntBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
+
+ @Override public IntBuffer slice() {
+ return new IntArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly);
+ }
+
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
+
+ @Override int[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return backingArray;
+ }
- IntArrayBuffer(int capacity, int[] backingArray, int offset) {
- super(capacity);
- this.backingArray = backingArray;
- this.offset = offset;
+ @Override int protectedArrayOffset() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return arrayOffset;
+ }
- @Override
- public final int get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return backingArray[offset + position++];
+ @Override boolean protectedHasArray() {
+ if (isReadOnly) {
+ return false;
}
+ return true;
+ }
- @Override
- public final int get(int index) {
- checkIndex(index);
- return backingArray[offset + index];
+ @Override public final int get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
}
+ return backingArray[arrayOffset + position++];
+ }
- @Override
- public final IntBuffer get(int[] dst, int dstOffset, int intCount) {
- if (intCount > remaining()) {
- throw new BufferUnderflowException();
- }
- System.arraycopy(backingArray, offset + position, dst, dstOffset, intCount);
- position += intCount;
- return this;
+ @Override public final int get(int index) {
+ checkIndex(index);
+ return backingArray[arrayOffset + index];
+ }
+
+ @Override public final IntBuffer get(int[] dst, int dstOffset, int intCount) {
+ if (intCount > remaining()) {
+ throw new BufferUnderflowException();
}
+ System.arraycopy(backingArray, arrayOffset + position, dst, dstOffset, intCount);
+ position += intCount;
+ return this;
+ }
- @Override
- public final boolean isDirect() {
- return false;
+ @Override public final boolean isDirect() {
+ return false;
+ }
+
+ @Override public final ByteOrder order() {
+ return ByteOrder.nativeOrder();
+ }
+
+ @Override public IntBuffer put(int c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
-
- @Override
- public final ByteOrder order() {
- return ByteOrder.nativeOrder();
+ if (position == limit) {
+ throw new BufferOverflowException();
}
+ backingArray[arrayOffset + position++] = c;
+ return this;
+ }
+ @Override public IntBuffer put(int index, int c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ backingArray[arrayOffset + index] = c;
+ return this;
+ }
+
+ @Override public IntBuffer put(int[] src, int srcOffset, int intCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (intCount > remaining()) {
+ throw new BufferOverflowException();
+ }
+ System.arraycopy(src, srcOffset, backingArray, arrayOffset + position, intCount);
+ position += intCount;
+ return this;
+ }
}
diff --git a/luni/src/main/java/java/nio/IntBuffer.java b/luni/src/main/java/java/nio/IntBuffer.java
index 0ff758a..bbcc2e3 100644
--- a/luni/src/main/java/java/nio/IntBuffer.java
+++ b/luni/src/main/java/java/nio/IntBuffer.java
@@ -46,7 +46,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteIntArrayBuffer(capacity);
+ return new IntArrayBuffer(new int[capacity]);
}
/**
@@ -83,7 +83,7 @@
*/
public static IntBuffer wrap(int[] array, int start, int intCount) {
Arrays.checkOffsetAndCount(array.length, start, intCount);
- IntBuffer buf = new ReadWriteIntArrayBuffer(array);
+ IntBuffer buf = new IntArrayBuffer(array);
buf.position = start;
buf.limit = start + intCount;
return buf;
@@ -395,6 +395,9 @@
* if no changes may be made to the contents of this buffer.
*/
public IntBuffer put(int[] src, int srcOffset, int intCount) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
Arrays.checkOffsetAndCount(src.length, srcOffset, intCount);
if (intCount > remaining()) {
throw new BufferOverflowException();
@@ -422,6 +425,9 @@
* if no changes may be made to the contents of this buffer.
*/
public IntBuffer put(IntBuffer src) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (src == this) {
throw new IllegalArgumentException("src == this");
}
diff --git a/luni/src/main/java/java/nio/LongArrayBuffer.java b/luni/src/main/java/java/nio/LongArrayBuffer.java
index 8dd0cfb..6419d73 100644
--- a/luni/src/main/java/java/nio/LongArrayBuffer.java
+++ b/luni/src/main/java/java/nio/LongArrayBuffer.java
@@ -18,69 +18,142 @@
package java.nio;
/**
- * LongArrayBuffer, ReadWriteLongArrayBuffer and ReadOnlyLongArrayBuffer compose
- * the implementation of array based long buffers.
- * <p>
- * LongArrayBuffer implements all the shared readonly methods and is extended by
- * the other two classes.
- * </p>
- * <p>
- * All methods are marked final for runtime performance.
- * </p>
- *
+ * LongArrayBuffer implements long[]-based LongBuffers.
*/
-abstract class LongArrayBuffer extends LongBuffer {
+final class LongArrayBuffer extends LongBuffer {
- protected final long[] backingArray;
+ private final long[] backingArray;
- protected final int offset;
+ private final int arrayOffset;
- LongArrayBuffer(long[] array) {
- this(array.length, array, 0);
+ private final boolean isReadOnly;
+
+ LongArrayBuffer(long[] array) {
+ this(array.length, array, 0, false);
+ }
+
+ private LongArrayBuffer(int capacity, long[] backingArray, int arrayOffset, boolean isReadOnly) {
+ super(capacity);
+ this.backingArray = backingArray;
+ this.arrayOffset = arrayOffset;
+ this.isReadOnly = isReadOnly;
+ }
+
+ private static LongArrayBuffer copy(LongArrayBuffer other, int markOfOther, boolean isReadOnly) {
+ LongArrayBuffer buf = new LongArrayBuffer(other.capacity(), other.backingArray, other.arrayOffset, isReadOnly);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
+
+ @Override public LongBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
+
+ @Override public LongBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ System.arraycopy(backingArray, position + arrayOffset, backingArray, arrayOffset, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
- LongArrayBuffer(int capacity) {
- this(capacity, new long[capacity], 0);
- }
+ @Override public LongBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
- LongArrayBuffer(int capacity, long[] backingArray, int offset) {
- super(capacity);
- this.backingArray = backingArray;
- this.offset = offset;
- }
+ @Override public LongBuffer slice() {
+ return new LongArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly);
+ }
- @Override
- public final long get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return backingArray[offset + position++];
- }
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
- @Override
- public final long get(int index) {
- checkIndex(index);
- return backingArray[offset + index];
+ @Override long[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return backingArray;
+ }
- @Override
- public final LongBuffer get(long[] dst, int dstOffset, int longCount) {
- if (longCount > remaining()) {
- throw new BufferUnderflowException();
- }
- System.arraycopy(backingArray, offset + position, dst, dstOffset, longCount);
- position += longCount;
- return this;
+ @Override int protectedArrayOffset() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return arrayOffset;
+ }
- @Override
- public final boolean isDirect() {
- return false;
+ @Override boolean protectedHasArray() {
+ if (isReadOnly) {
+ return false;
}
+ return true;
+ }
- @Override
- public final ByteOrder order() {
- return ByteOrder.nativeOrder();
+ @Override public final long get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
}
+ return backingArray[arrayOffset + position++];
+ }
+
+ @Override public final long get(int index) {
+ checkIndex(index);
+ return backingArray[arrayOffset + index];
+ }
+
+ @Override public final LongBuffer get(long[] dst, int dstOffset, int longCount) {
+ if (longCount > remaining()) {
+ throw new BufferUnderflowException();
+ }
+ System.arraycopy(backingArray, arrayOffset + position, dst, dstOffset, longCount);
+ position += longCount;
+ return this;
+ }
+
+ @Override public final boolean isDirect() {
+ return false;
+ }
+
+ @Override public final ByteOrder order() {
+ return ByteOrder.nativeOrder();
+ }
+
+ @Override public LongBuffer put(long c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (position == limit) {
+ throw new BufferOverflowException();
+ }
+ backingArray[arrayOffset + position++] = c;
+ return this;
+ }
+
+ @Override public LongBuffer put(int index, long c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ backingArray[arrayOffset + index] = c;
+ return this;
+ }
+
+ @Override public LongBuffer put(long[] src, int srcOffset, int longCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (longCount > remaining()) {
+ throw new BufferOverflowException();
+ }
+ System.arraycopy(src, srcOffset, backingArray, arrayOffset + position, longCount);
+ position += longCount;
+ return this;
+ }
}
diff --git a/luni/src/main/java/java/nio/LongBuffer.java b/luni/src/main/java/java/nio/LongBuffer.java
index 1254ddb..58d7518 100644
--- a/luni/src/main/java/java/nio/LongBuffer.java
+++ b/luni/src/main/java/java/nio/LongBuffer.java
@@ -48,7 +48,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteLongArrayBuffer(capacity);
+ return new LongArrayBuffer(new long[capacity]);
}
/**
@@ -85,7 +85,7 @@
*/
public static LongBuffer wrap(long[] array, int start, int longCount) {
Arrays.checkOffsetAndCount(array.length, start, longCount);
- LongBuffer buf = new ReadWriteLongArrayBuffer(array);
+ LongBuffer buf = new LongArrayBuffer(array);
buf.position = start;
buf.limit = start + longCount;
return buf;
@@ -426,6 +426,9 @@
* if no changes may be made to the contents of this buffer.
*/
public LongBuffer put(LongBuffer src) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (src == this) {
throw new IllegalArgumentException("src == this");
}
diff --git a/luni/src/main/java/java/nio/MappedByteBuffer.java b/luni/src/main/java/java/nio/MappedByteBuffer.java
index 0e8bf09..2ba9258 100644
--- a/luni/src/main/java/java/nio/MappedByteBuffer.java
+++ b/luni/src/main/java/java/nio/MappedByteBuffer.java
@@ -37,92 +37,89 @@
* {@code MappedByteBuffer} is undefined.
*/
public abstract class MappedByteBuffer extends ByteBuffer {
+ final MapMode mapMode;
- final DirectByteBuffer wrapped;
+ MappedByteBuffer(MemoryBlock block, int capacity, MapMode mapMode) {
+ super(capacity, block);
+ this.mapMode = mapMode;
+ }
- private final MapMode mapMode;
+ /**
+ * Returns true if there is a high probability that every page of this buffer is currently
+ * loaded in RAM, meaning that accesses will not cause a page fault. It is impossible to give
+ * a strong guarantee since this is only a snapshot of a dynamic situation.
+ */
+ public final boolean isLoaded() {
+ checkIsMapped();
- MappedByteBuffer(ByteBuffer directBuffer) {
- super(directBuffer.capacity, directBuffer.block);
- if (!directBuffer.isDirect()) {
- throw new IllegalArgumentException("directBuffer is not a direct buffer: " + directBuffer);
- }
- this.wrapped = (DirectByteBuffer) directBuffer;
- this.mapMode = null;
+ long address = block.toInt();
+ long size = block.getSize();
+ if (size == 0) {
+ return true;
}
- MappedByteBuffer(MemoryBlock block, int capacity, int offset, MapMode mapMode) {
- super(capacity, block);
- this.mapMode = mapMode;
- if (mapMode == MapMode.READ_ONLY) {
- wrapped = new ReadOnlyDirectByteBuffer(block, capacity, offset);
- } else {
- wrapped = new ReadWriteDirectByteBuffer(block, capacity, offset);
+ try {
+ int pageSize = (int) Libcore.os.sysconf(_SC_PAGE_SIZE);
+ int pageOffset = (int) (address % pageSize);
+ address -= pageOffset;
+ size += pageOffset;
+ int pageCount = (int) ((size + pageSize - 1) / pageSize);
+ byte[] vector = new byte[pageCount];
+ Libcore.os.mincore(address, size, vector);
+ for (int i = 0; i < vector.length; ++i) {
+ if ((vector[i] & 1) != 1) {
+ return false;
}
+ }
+ return true;
+ } catch (ErrnoException errnoException) {
+ return false;
}
+ }
- /**
- * Returns true if there is a high probability that every page of this buffer is currently
- * loaded in RAM, meaning that accesses will not cause a page fault. It is impossible to give
- * a strong guarantee since this is only a snapshot of a dynamic situation.
- */
- public final boolean isLoaded() {
- long address = block.toInt();
- long size = block.getSize();
- if (size == 0) {
- return true;
- }
+ /**
+ * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}.
+ * @return this buffer.
+ */
+ public final MappedByteBuffer load() {
+ checkIsMapped();
- try {
- int pageSize = (int) Libcore.os.sysconf(_SC_PAGE_SIZE);
- int pageOffset = (int) (address % pageSize);
- address -= pageOffset;
- size += pageOffset;
- int pageCount = (int) ((size + pageSize - 1) / pageSize);
- byte[] vector = new byte[pageCount];
- Libcore.os.mincore(address, size, vector);
- for (int i = 0; i < vector.length; ++i) {
- if ((vector[i] & 1) != 1) {
- return false;
- }
- }
- return true;
- } catch (ErrnoException errnoException) {
- return false;
- }
+ try {
+ Libcore.os.mlock(block.toInt(), block.getSize());
+ Libcore.os.munlock(block.toInt(), block.getSize());
+ } catch (ErrnoException ignored) {
}
+ return this;
+ }
- /**
- * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}.
- * @return this buffer.
- */
- public final MappedByteBuffer load() {
- try {
- Libcore.os.mlock(block.toInt(), block.getSize());
- Libcore.os.munlock(block.toInt(), block.getSize());
- } catch (ErrnoException ignored) {
- }
- return this;
- }
+ /**
+ * Writes all changes of the buffer to the mapped file. If the mapped file
+ * is stored on a local device, it is guaranteed that the changes are
+ * written to the file. No such guarantee is given if the file is located on
+ * a remote device.
+ *
+ * @return this buffer.
+ */
+ public final MappedByteBuffer force() {
+ checkIsMapped();
- /**
- * Writes all changes of the buffer to the mapped file. If the mapped file
- * is stored on a local device, it is guaranteed that the changes are
- * written to the file. No such guarantee is given if the file is located on
- * a remote device.
- *
- * @return this buffer.
- */
- public final MappedByteBuffer force() {
- if (mapMode == MapMode.READ_WRITE) {
- try {
- Libcore.os.msync(block.toInt(), block.getSize(), MS_SYNC);
- } catch (ErrnoException errnoException) {
- // The RI doesn't throw, presumably on the assumption that you can't get into
- // a state where msync(2) could return an error.
- throw new AssertionError(errnoException);
- }
- }
- return this;
+ if (mapMode == MapMode.READ_WRITE) {
+ try {
+ Libcore.os.msync(block.toInt(), block.getSize(), MS_SYNC);
+ } catch (ErrnoException errnoException) {
+ // The RI doesn't throw, presumably on the assumption that you can't get into
+ // a state where msync(2) could return an error.
+ throw new AssertionError(errnoException);
+ }
}
+ return this;
+ }
+
+ // DirectByteBuffer is a subclass of MappedByteBuffer, but not all DirectByteBuffers
+ // actually correspond to an mmap(2)ed region.
+ private void checkIsMapped() {
+ if (mapMode == null) {
+ throw new UnsupportedOperationException();
+ }
+ }
}
diff --git a/luni/src/main/java/java/nio/MappedByteBufferAdapter.java b/luni/src/main/java/java/nio/MappedByteBufferAdapter.java
deleted file mode 100644
index 59cfe8e..0000000
--- a/luni/src/main/java/java/nio/MappedByteBufferAdapter.java
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-import java.nio.channels.FileChannel.MapMode;
-import libcore.io.SizeOf;
-
-/**
- * Rather than duplicate all the code from ReadOnlyDirectByteBuffer and
- * ReadWriteDirectByteBuffer (and their superclasses), we delegate to one or the other.
- * The tricky part is that we need to keep our fields in sync with our delegate's fields.
- * There are lots of methods that access the fields directly.
- *
- * The main consequences of this implementation are:
- *
- * 1. we need to explicitly call wrapped.position(int) before any operation on our delegate
- * that makes use of the implicit position.
- *
- * 2. we need to explicitly update position after any operation on our delegate that makes
- * use of the implicit position.
- *
- * This means that, even more than usual, the implicit iteration
- * operations are more expensive than the indexed operations.
- *
- * But we save a ton of code, for classes that no-one really uses because the API's broken
- * by design (disallowing munmap(2) calls). Internally, we can use libcore.io.MemoryMappedFile
- * as a high-performance and more usable replacement for MappedByteBuffer.
- *
- * FIXME: harmony changed their implementation after we diverged, switching to a scheme
- * where DirectByteBuffer extends MappedByteBuffer and this class doesn't exist. That's
- * much better than their original implementation, fossilized here.
- */
-final class MappedByteBufferAdapter extends MappedByteBuffer {
- private MappedByteBufferAdapter(ByteBuffer buffer) {
- super(buffer);
- effectiveDirectAddress = wrapped.effectiveDirectAddress;
- }
-
- public MappedByteBufferAdapter(MemoryBlock block, int capacity, int offset, MapMode mode) {
- super(block, capacity, offset, mode);
- effectiveDirectAddress = wrapped.effectiveDirectAddress;
- }
-
- @Override void limitImpl(int newLimit) {
- super.limitImpl(newLimit);
- wrapped.limit(newLimit);
- }
-
- @Override void positionImpl(int newPosition) {
- super.positionImpl(newPosition);
- wrapped.position(newPosition);
- }
-
- @Override
- public CharBuffer asCharBuffer() {
- return wrapped.asCharBuffer();
- }
-
- @Override
- public DoubleBuffer asDoubleBuffer() {
- return wrapped.asDoubleBuffer();
- }
-
- @Override
- public FloatBuffer asFloatBuffer() {
- return wrapped.asFloatBuffer();
- }
-
- @Override
- public IntBuffer asIntBuffer() {
- return wrapped.asIntBuffer();
- }
-
- @Override
- public LongBuffer asLongBuffer() {
- return wrapped.asLongBuffer();
- }
-
- @Override
- public ByteBuffer asReadOnlyBuffer() {
- MappedByteBufferAdapter result = new MappedByteBufferAdapter(wrapped.asReadOnlyBuffer());
- result.limit(limit);
- result.position(position);
- result.mark = mark;
- return result;
- }
-
- @Override
- public ShortBuffer asShortBuffer() {
- return wrapped.asShortBuffer();
- }
-
- @Override
- public ByteBuffer compact() {
- if (wrapped.isReadOnly()) {
- throw new ReadOnlyBufferException();
- }
- wrapped.compact();
- limit(capacity);
- position(wrapped.position());
- this.mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public ByteBuffer duplicate() {
- MappedByteBufferAdapter result = new MappedByteBufferAdapter(wrapped.duplicate());
- result.limit(limit);
- result.position(position);
- result.mark = mark;
- return result;
- }
-
- @Override
- public byte get() {
- wrapped.position(position);
- byte result = wrapped.get();
- ++position;
- return result;
- }
-
- @Override
- public byte get(int index) {
- return wrapped.get(index);
- }
-
- @Override
- public ByteBuffer get(byte[] dst, int dstOffset, int byteCount) {
- ByteBuffer result = wrapped.get(dst, dstOffset, byteCount);
- position += byteCount;
- return result;
- }
-
- @Override
- public char getChar() {
- wrapped.position(position);
- char result = wrapped.getChar();
- position += SizeOf.CHAR;
- return result;
- }
-
- @Override
- public char getChar(int index) {
- return wrapped.getChar(index);
- }
-
- @Override
- public double getDouble() {
- wrapped.position(position);
- double result = wrapped.getDouble();
- position += SizeOf.DOUBLE;
- return result;
- }
-
- @Override
- public double getDouble(int index) {
- return wrapped.getDouble(index);
- }
-
- @Override
- public float getFloat() {
- wrapped.position(position);
- float result = wrapped.getFloat();
- position += SizeOf.FLOAT;
- return result;
- }
-
- @Override
- public float getFloat(int index) {
- return wrapped.getFloat(index);
- }
-
- @Override
- public int getInt() {
- wrapped.position(position);
- int result = wrapped.getInt();
- position += SizeOf.INT;
- return result;
- }
-
- @Override
- public int getInt(int index) {
- return wrapped.getInt(index);
- }
-
- @Override
- public long getLong() {
- wrapped.position(position);
- long result = wrapped.getLong();
- position += SizeOf.LONG;
- return result;
- }
-
- @Override
- public long getLong(int index) {
- return wrapped.getLong(index);
- }
-
- @Override
- public short getShort() {
- wrapped.position(position);
- short result = wrapped.getShort();
- position += SizeOf.SHORT;
- return result;
- }
-
- @Override
- public short getShort(int index) {
- return wrapped.getShort(index);
- }
-
- @Override
- public boolean isDirect() {
- return true;
- }
-
- @Override
- public boolean isReadOnly() {
- return wrapped.isReadOnly();
- }
-
- @Override void orderImpl(ByteOrder byteOrder) {
- super.orderImpl(byteOrder);
- wrapped.order(byteOrder);
- }
-
- @Override
- public ByteBuffer put(byte b) {
- wrapped.position(this.position);
- wrapped.put(b);
- this.position++;
- return this;
- }
-
- @Override
- public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {
- wrapped.position(this.position);
- wrapped.put(src, srcOffset, byteCount);
- this.position += byteCount;
- return this;
- }
-
- @Override
- public ByteBuffer put(int index, byte b) {
- wrapped.position(this.position);
- wrapped.put(index, b);
- return this;
- }
-
- @Override
- public ByteBuffer putChar(char value) {
- wrapped.position(this.position);
- wrapped.putChar(value);
- this.position += SizeOf.CHAR;
- return this;
- }
-
- @Override
- public ByteBuffer putChar(int index, char value) {
- wrapped.position(this.position);
- wrapped.putChar(index, value);
- return this;
- }
-
- @Override
- public ByteBuffer putDouble(double value) {
- wrapped.position(this.position);
- wrapped.putDouble(value);
- this.position += SizeOf.DOUBLE;
- return this;
- }
-
- @Override
- public ByteBuffer putDouble(int index, double value) {
- wrapped.position(this.position);
- wrapped.putDouble(index, value);
- return this;
- }
-
- @Override
- public ByteBuffer putFloat(float value) {
- wrapped.position(this.position);
- wrapped.putFloat(value);
- this.position += SizeOf.FLOAT;
- return this;
- }
-
- @Override
- public ByteBuffer putFloat(int index, float value) {
- wrapped.position(this.position);
- wrapped.putFloat(index, value);
- return this;
- }
-
- @Override
- public ByteBuffer putInt(int index, int value) {
- wrapped.position(this.position);
- wrapped.putInt(index, value);
- return this;
- }
-
- @Override
- public ByteBuffer putInt(int value) {
- wrapped.position(this.position);
- wrapped.putInt(value);
- this.position += SizeOf.INT;
- return this;
- }
-
- @Override
- public ByteBuffer putLong(int index, long value) {
- wrapped.position(this.position);
- wrapped.putLong(index, value);
- return this;
- }
-
- @Override
- public ByteBuffer putLong(long value) {
- wrapped.position(this.position);
- wrapped.putLong(value);
- this.position += SizeOf.LONG;
- return this;
- }
-
- @Override
- public ByteBuffer putShort(int index, short value) {
- wrapped.position(this.position);
- wrapped.putShort(index, value);
- return this;
- }
-
- @Override
- public ByteBuffer putShort(short value) {
- wrapped.position(this.position);
- wrapped.putShort(value);
- this.position += SizeOf.SHORT;
- return this;
- }
-
- @Override
- public ByteBuffer slice() {
- wrapped.position(this.position);
- MappedByteBufferAdapter result = new MappedByteBufferAdapter(wrapped.slice());
- wrapped.clear();
- return result;
- }
-
- @Override byte[] protectedArray() {
- return wrapped.protectedArray();
- }
-
- @Override int protectedArrayOffset() {
- return wrapped.protectedArrayOffset();
- }
-
- @Override boolean protectedHasArray() {
- return wrapped.protectedHasArray();
- }
-
- public final void free() {
- wrapped.free();
- }
-}
diff --git a/luni/src/main/java/java/nio/NioUtils.java b/luni/src/main/java/java/nio/NioUtils.java
index 56b8b8b..7c51da1 100644
--- a/luni/src/main/java/java/nio/NioUtils.java
+++ b/luni/src/main/java/java/nio/NioUtils.java
@@ -49,13 +49,7 @@
if (buffer == null) {
return;
}
- if (buffer instanceof DirectByteBuffer) {
- ((DirectByteBuffer) buffer).free();
- } else if (buffer instanceof MappedByteBuffer) {
- ((MappedByteBufferAdapter) buffer).free();
- } else {
- throw new AssertionError();
- }
+ ((DirectByteBuffer) buffer).free();
}
/**
@@ -77,7 +71,7 @@
* Normally, attempting to access the array backing a read-only buffer throws.
*/
public static byte[] unsafeArray(ByteBuffer b) {
- return ((HeapByteBuffer) b).backingArray;
+ return ((ByteArrayBuffer) b).backingArray;
}
/**
@@ -85,6 +79,6 @@
* even if the ByteBuffer is read-only.
*/
public static int unsafeArrayOffset(ByteBuffer b) {
- return ((HeapByteBuffer) b).offset;
+ return ((ByteArrayBuffer) b).arrayOffset;
}
}
diff --git a/luni/src/main/java/java/nio/ReadOnlyCharArrayBuffer.java b/luni/src/main/java/java/nio/ReadOnlyCharArrayBuffer.java
deleted file mode 100644
index 75e7b9b..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyCharArrayBuffer.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * CharArrayBuffer, ReadWriteCharArrayBuffer and ReadOnlyCharArrayBuffer compose
- * the implementation of array based char buffers.
- * <p>
- * ReadOnlyCharArrayBuffer extends CharArrayBuffer with all the write methods
- * throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadOnlyCharArrayBuffer extends CharArrayBuffer {
-
- static ReadOnlyCharArrayBuffer copy(CharArrayBuffer other, int markOfOther) {
- ReadOnlyCharArrayBuffer buf =
- new ReadOnlyCharArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadOnlyCharArrayBuffer(int capacity, char[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public CharBuffer asReadOnlyBuffer() {
- return duplicate();
- }
-
- @Override
- public CharBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public CharBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override char[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override boolean protectedHasArray() {
- return false;
- }
-
- @Override
- public CharBuffer put(char c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public CharBuffer put(int index, char c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final CharBuffer put(char[] src, int srcOffset, int charCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final CharBuffer put(CharBuffer src) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public CharBuffer put(String src, int start, int end) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public CharBuffer slice() {
- return new ReadOnlyCharArrayBuffer(remaining(), backingArray, offset + position);
- }
-}
diff --git a/luni/src/main/java/java/nio/ReadOnlyDirectByteBuffer.java b/luni/src/main/java/java/nio/ReadOnlyDirectByteBuffer.java
deleted file mode 100644
index 0d61797..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyDirectByteBuffer.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * DirectByteBuffer, ReadWriteDirectByteBuffer and ReadOnlyDirectByteBuffer
- * compose the implementation of platform memory based byte buffers.
- * <p>
- * ReadOnlyDirectByteBuffer extends DirectByteBuffer with all the write methods
- * throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- */
-final class ReadOnlyDirectByteBuffer extends DirectByteBuffer {
- static ReadOnlyDirectByteBuffer copy(DirectByteBuffer other, int markOfOther) {
- ReadOnlyDirectByteBuffer buf = new ReadOnlyDirectByteBuffer(other.block, other.capacity(), other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- protected ReadOnlyDirectByteBuffer(MemoryBlock block, int capacity, int offset) {
- super(block, capacity, offset);
- }
-
- @Override
- public ByteBuffer asReadOnlyBuffer() {
- return copy(this, mark);
- }
-
- @Override
- public ByteBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override
- public ByteBuffer put(byte value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer put(int index, byte value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putDouble(double value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putDouble(int index, double value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putFloat(float value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putFloat(int index, float value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putInt(int value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putInt(int index, int value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putLong(int index, long value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putLong(long value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putShort(int index, short value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putShort(short value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer put(ByteBuffer buf) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer slice() {
- return new ReadOnlyDirectByteBuffer(block, remaining(), offset + position);
- }
-
- @Override protected byte[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override protected int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override protected boolean protectedHasArray() {
- return false;
- }
-}
diff --git a/luni/src/main/java/java/nio/ReadOnlyDoubleArrayBuffer.java b/luni/src/main/java/java/nio/ReadOnlyDoubleArrayBuffer.java
deleted file mode 100644
index 9812789..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyDoubleArrayBuffer.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * DoubleArrayBuffer, ReadWriteDoubleArrayBuffer and ReadOnlyDoubleArrayBuffer
- * compose the implementation of array based double buffers.
- * <p>
- * ReadOnlyDoubleArrayBuffer extends DoubleArrayBuffer with all the write
- * methods throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadOnlyDoubleArrayBuffer extends DoubleArrayBuffer {
-
- static ReadOnlyDoubleArrayBuffer copy(DoubleArrayBuffer other, int markOfOther) {
- ReadOnlyDoubleArrayBuffer buf =
- new ReadOnlyDoubleArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadOnlyDoubleArrayBuffer(int capacity, double[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public DoubleBuffer asReadOnlyBuffer() {
- return duplicate();
- }
-
- @Override
- public DoubleBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public DoubleBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override double[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override boolean protectedHasArray() {
- return false;
- }
-
- @Override
- public DoubleBuffer put(double c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public DoubleBuffer put(int index, double c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final DoubleBuffer put(double[] src, int srcOffset, int byteCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final DoubleBuffer put(DoubleBuffer buf) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public DoubleBuffer slice() {
- return new ReadOnlyDoubleArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadOnlyFloatArrayBuffer.java b/luni/src/main/java/java/nio/ReadOnlyFloatArrayBuffer.java
deleted file mode 100644
index 3c74966..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyFloatArrayBuffer.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * FloatArrayBuffer, ReadWriteFloatArrayBuffer and ReadOnlyFloatArrayBuffer
- * compose the implementation of array based float buffers.
- * <p>
- * ReadOnlyFloatArrayBuffer extends FloatArrayBuffer with all the write methods
- * throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadOnlyFloatArrayBuffer extends FloatArrayBuffer {
-
- static ReadOnlyFloatArrayBuffer copy(FloatArrayBuffer other, int markOfOther) {
- ReadOnlyFloatArrayBuffer buf =
- new ReadOnlyFloatArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadOnlyFloatArrayBuffer(int capacity, float[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public FloatBuffer asReadOnlyBuffer() {
- return duplicate();
- }
-
- @Override
- public FloatBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public FloatBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override float[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override boolean protectedHasArray() {
- return false;
- }
-
- @Override
- public FloatBuffer put(float c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public FloatBuffer put(int index, float c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public FloatBuffer put(FloatBuffer buf) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final FloatBuffer put(float[] src, int srcOffset, int byteCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public FloatBuffer slice() {
- return new ReadOnlyFloatArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadOnlyHeapByteBuffer.java b/luni/src/main/java/java/nio/ReadOnlyHeapByteBuffer.java
deleted file mode 100644
index c5073b0..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyHeapByteBuffer.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * HeapByteBuffer, ReadWriteHeapByteBuffer and ReadOnlyHeapByteBuffer compose
- * the implementation of array based byte buffers.
- * <p>
- * ReadOnlyHeapByteBuffer extends HeapByteBuffer with all the write methods
- * throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadOnlyHeapByteBuffer extends HeapByteBuffer {
-
- static ReadOnlyHeapByteBuffer copy(HeapByteBuffer other, int markOfOther) {
- ReadOnlyHeapByteBuffer buf =
- new ReadOnlyHeapByteBuffer(other.backingArray, other.capacity(), other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadOnlyHeapByteBuffer(byte[] backingArray, int capacity, int arrayOffset) {
- super(backingArray, capacity, arrayOffset);
- }
-
- @Override
- public ByteBuffer asReadOnlyBuffer() {
- return ReadOnlyHeapByteBuffer.copy(this, mark);
- }
-
- @Override
- public ByteBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override byte[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override boolean protectedHasArray() {
- return false;
- }
-
- @Override
- public ByteBuffer put(byte b) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer put(int index, byte b) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putDouble(double value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putDouble(int index, double value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putFloat(float value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putFloat(int index, float value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putInt(int value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putInt(int index, int value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putLong(int index, long value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putLong(long value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putShort(int index, short value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer putShort(short value) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer put(ByteBuffer buf) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ByteBuffer slice() {
- return new ReadOnlyHeapByteBuffer(backingArray, remaining(), offset + position);
- }
-}
diff --git a/luni/src/main/java/java/nio/ReadOnlyIntArrayBuffer.java b/luni/src/main/java/java/nio/ReadOnlyIntArrayBuffer.java
deleted file mode 100644
index ef73251..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyIntArrayBuffer.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * IntArrayBuffer, ReadWriteIntArrayBuffer and ReadOnlyIntArrayBuffer compose
- * the implementation of array based int buffers.
- * <p>
- * ReadOnlyIntArrayBuffer extends IntArrayBuffer with all the write methods
- * throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadOnlyIntArrayBuffer extends IntArrayBuffer {
-
- static ReadOnlyIntArrayBuffer copy(IntArrayBuffer other, int markOfOther) {
- ReadOnlyIntArrayBuffer buf =
- new ReadOnlyIntArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadOnlyIntArrayBuffer(int capacity, int[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public IntBuffer asReadOnlyBuffer() {
- return duplicate();
- }
-
- @Override
- public IntBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public IntBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override int[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override boolean protectedHasArray() {
- return false;
- }
-
- @Override
- public IntBuffer put(int c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public IntBuffer put(int index, int c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public IntBuffer put(IntBuffer buf) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final IntBuffer put(int[] src, int srcOffset, int intCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public IntBuffer slice() {
- return new ReadOnlyIntArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadOnlyLongArrayBuffer.java b/luni/src/main/java/java/nio/ReadOnlyLongArrayBuffer.java
deleted file mode 100644
index a28815d..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyLongArrayBuffer.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * LongArrayBuffer, ReadWriteLongArrayBuffer and ReadOnlyLongArrayBuffer compose
- * the implementation of array based long buffers.
- * <p>
- * ReadOnlyLongArrayBuffer extends LongArrayBuffer with all the write methods
- * throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadOnlyLongArrayBuffer extends LongArrayBuffer {
-
- static ReadOnlyLongArrayBuffer copy(LongArrayBuffer other, int markOfOther) {
- ReadOnlyLongArrayBuffer buf =
- new ReadOnlyLongArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadOnlyLongArrayBuffer(int capacity, long[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public LongBuffer asReadOnlyBuffer() {
- return duplicate();
- }
-
- @Override
- public LongBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public LongBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override long[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override boolean protectedHasArray() {
- return false;
- }
-
- @Override
- public LongBuffer put(long c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public LongBuffer put(int index, long c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public LongBuffer put(LongBuffer buf) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final LongBuffer put(long[] src, int srcOffset, int longCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public LongBuffer slice() {
- return new ReadOnlyLongArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadOnlyShortArrayBuffer.java b/luni/src/main/java/java/nio/ReadOnlyShortArrayBuffer.java
deleted file mode 100644
index 075ff38..0000000
--- a/luni/src/main/java/java/nio/ReadOnlyShortArrayBuffer.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * ShortArrayBuffer, ReadWriteShortArrayBuffer and ReadOnlyShortArrayBuffer
- * compose the implementation of array based short buffers.
- * <p>
- * ReadOnlyShortArrayBuffer extends ShortArrayBuffer with all the write methods
- * throwing read only exception.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadOnlyShortArrayBuffer extends ShortArrayBuffer {
-
- static ReadOnlyShortArrayBuffer copy(ShortArrayBuffer other, int markOfOther) {
- ReadOnlyShortArrayBuffer buf =
- new ReadOnlyShortArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadOnlyShortArrayBuffer(int capacity, short[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public ShortBuffer asReadOnlyBuffer() {
- return duplicate();
- }
-
- @Override
- public ShortBuffer compact() {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ShortBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return true;
- }
-
- @Override short[] protectedArray() {
- throw new ReadOnlyBufferException();
- }
-
- @Override int protectedArrayOffset() {
- throw new ReadOnlyBufferException();
- }
-
- @Override boolean protectedHasArray() {
- return false;
- }
-
- @Override
- public ShortBuffer put(ShortBuffer buf) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ShortBuffer put(short c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ShortBuffer put(int index, short c) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public final ShortBuffer put(short[] src, int srcOffset, int shortCount) {
- throw new ReadOnlyBufferException();
- }
-
- @Override
- public ShortBuffer slice() {
- return new ReadOnlyShortArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteCharArrayBuffer.java b/luni/src/main/java/java/nio/ReadWriteCharArrayBuffer.java
deleted file mode 100644
index 58fc5ae..0000000
--- a/luni/src/main/java/java/nio/ReadWriteCharArrayBuffer.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * CharArrayBuffer, ReadWriteCharArrayBuffer and ReadOnlyCharArrayBuffer compose
- * the implementation of array based char buffers.
- * <p>
- * ReadWriteCharArrayBuffer extends CharArrayBuffer with all the write methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadWriteCharArrayBuffer extends CharArrayBuffer {
-
- static ReadWriteCharArrayBuffer copy(CharArrayBuffer other, int markOfOther) {
- ReadWriteCharArrayBuffer buf =
- new ReadWriteCharArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadWriteCharArrayBuffer(char[] array) {
- super(array);
- }
-
- ReadWriteCharArrayBuffer(int capacity) {
- super(capacity);
- }
-
- ReadWriteCharArrayBuffer(int capacity, char[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public CharBuffer asReadOnlyBuffer() {
- return ReadOnlyCharArrayBuffer.copy(this, mark);
- }
-
- @Override
- public CharBuffer compact() {
- System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public CharBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override char[] protectedArray() {
- return backingArray;
- }
-
- @Override int protectedArrayOffset() {
- return offset;
- }
-
- @Override boolean protectedHasArray() {
- return true;
- }
-
- @Override
- public CharBuffer put(char c) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- backingArray[offset + position++] = c;
- return this;
- }
-
- @Override
- public CharBuffer put(int index, char c) {
- checkIndex(index);
- backingArray[offset + index] = c;
- return this;
- }
-
- @Override
- public CharBuffer put(char[] src, int srcOffset, int charCount) {
- if (charCount > remaining()) {
- throw new BufferOverflowException();
- }
- System.arraycopy(src, srcOffset, backingArray, offset + position, charCount);
- position += charCount;
- return this;
- }
-
- @Override
- public CharBuffer slice() {
- return new ReadWriteCharArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteDirectByteBuffer.java b/luni/src/main/java/java/nio/ReadWriteDirectByteBuffer.java
deleted file mode 100644
index 5edce30..0000000
--- a/luni/src/main/java/java/nio/ReadWriteDirectByteBuffer.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-import libcore.io.SizeOf;
-import libcore.io.Memory;
-
-/**
- * DirectByteBuffer, ReadWriteDirectByteBuffer and ReadOnlyDirectByteBuffer
- * compose the implementation of platform memory based byte buffers.
- * <p>
- * ReadWriteDirectByteBuffer extends DirectByteBuffer with all the write
- * methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- */
-final class ReadWriteDirectByteBuffer extends DirectByteBuffer {
- static ReadWriteDirectByteBuffer copy(DirectByteBuffer other, int markOfOther) {
- ReadWriteDirectByteBuffer buf =
- new ReadWriteDirectByteBuffer(other.block, other.capacity(), other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- // Used by ByteBuffer.allocateDirect.
- ReadWriteDirectByteBuffer(int capacity) {
- super(MemoryBlock.allocate(capacity), capacity, 0);
- }
-
- // Used by the JNI NewDirectByteBuffer function.
- ReadWriteDirectByteBuffer(int address, int capacity) {
- super(MemoryBlock.wrapFromJni(address, capacity), capacity, 0);
- }
-
- ReadWriteDirectByteBuffer(MemoryBlock block, int capacity, int offset) {
- super(block, capacity, offset);
- }
-
- @Override
- public ByteBuffer asReadOnlyBuffer() {
- return ReadOnlyDirectByteBuffer.copy(this, mark);
- }
-
- @Override
- public ByteBuffer compact() {
- Memory.memmove(this, 0, this, position, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public ByteBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override
- public ByteBuffer put(byte value) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- this.block.pokeByte(offset + position++, value);
- return this;
- }
-
- @Override
- public ByteBuffer put(int index, byte value) {
- checkIndex(index);
- this.block.pokeByte(offset + index, value);
- return this;
- }
-
- @Override
- public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {
- checkPutBounds(1, src.length, srcOffset, byteCount);
- this.block.pokeByteArray(offset + position, src, srcOffset, byteCount);
- position += byteCount;
- return this;
- }
-
- final void put(char[] src, int srcOffset, int charCount) {
- int byteCount = checkPutBounds(SizeOf.CHAR, src.length, srcOffset, charCount);
- this.block.pokeCharArray(offset + position, src, srcOffset, charCount, order.needsSwap);
- position += byteCount;
- }
-
- final void put(double[] src, int srcOffset, int doubleCount) {
- int byteCount = checkPutBounds(SizeOf.DOUBLE, src.length, srcOffset, doubleCount);
- this.block.pokeDoubleArray(offset + position, src, srcOffset, doubleCount, order.needsSwap);
- position += byteCount;
- }
-
- final void put(float[] src, int srcOffset, int floatCount) {
- int byteCount = checkPutBounds(SizeOf.FLOAT, src.length, srcOffset, floatCount);
- this.block.pokeFloatArray(offset + position, src, srcOffset, floatCount, order.needsSwap);
- position += byteCount;
- }
-
- final void put(int[] src, int srcOffset, int intCount) {
- int byteCount = checkPutBounds(SizeOf.INT, src.length, srcOffset, intCount);
- this.block.pokeIntArray(offset + position, src, srcOffset, intCount, order.needsSwap);
- position += byteCount;
- }
-
- final void put(long[] src, int srcOffset, int longCount) {
- int byteCount = checkPutBounds(SizeOf.LONG, src.length, srcOffset, longCount);
- this.block.pokeLongArray(offset + position, src, srcOffset, longCount, order.needsSwap);
- position += byteCount;
- }
-
- final void put(short[] src, int srcOffset, int shortCount) {
- int byteCount = checkPutBounds(SizeOf.SHORT, src.length, srcOffset, shortCount);
- this.block.pokeShortArray(offset + position, src, srcOffset, shortCount, order.needsSwap);
- position += byteCount;
- }
-
- @Override
- public ByteBuffer putChar(char value) {
- int newPosition = position + SizeOf.CHAR;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- this.block.pokeShort(offset + position, (short) value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putChar(int index, char value) {
- checkIndex(index, SizeOf.CHAR);
- this.block.pokeShort(offset + index, (short) value, order);
- return this;
- }
-
- @Override
- public ByteBuffer putDouble(double value) {
- int newPosition = position + SizeOf.DOUBLE;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- this.block.pokeLong(offset + position, Double.doubleToRawLongBits(value), order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putDouble(int index, double value) {
- checkIndex(index, SizeOf.DOUBLE);
- this.block.pokeLong(offset + index, Double.doubleToRawLongBits(value), order);
- return this;
- }
-
- @Override
- public ByteBuffer putFloat(float value) {
- int newPosition = position + SizeOf.FLOAT;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- this.block.pokeInt(offset + position, Float.floatToRawIntBits(value), order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putFloat(int index, float value) {
- checkIndex(index, SizeOf.FLOAT);
- this.block.pokeInt(offset + index, Float.floatToRawIntBits(value), order);
- return this;
- }
-
- @Override
- public ByteBuffer putInt(int value) {
- int newPosition = position + SizeOf.INT;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- this.block.pokeInt(offset + position, value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putInt(int index, int value) {
- checkIndex(index, SizeOf.INT);
- this.block.pokeInt(offset + index, value, order);
- return this;
- }
-
- @Override
- public ByteBuffer putLong(long value) {
- int newPosition = position + SizeOf.LONG;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- this.block.pokeLong(offset + position, value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putLong(int index, long value) {
- checkIndex(index, SizeOf.LONG);
- this.block.pokeLong(offset + index, value, order);
- return this;
- }
-
- @Override
- public ByteBuffer putShort(short value) {
- int newPosition = position + SizeOf.SHORT;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- this.block.pokeShort(offset + position, value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putShort(int index, short value) {
- checkIndex(index, SizeOf.SHORT);
- this.block.pokeShort(offset + index, value, order);
- return this;
- }
-
- @Override
- public ByteBuffer slice() {
- return new ReadWriteDirectByteBuffer(block, remaining(), offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteDoubleArrayBuffer.java b/luni/src/main/java/java/nio/ReadWriteDoubleArrayBuffer.java
deleted file mode 100644
index f9328d6..0000000
--- a/luni/src/main/java/java/nio/ReadWriteDoubleArrayBuffer.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * DoubleArrayBuffer, ReadWriteDoubleArrayBuffer and ReadOnlyDoubleArrayBuffer
- * compose the implementation of array based double buffers.
- * <p>
- * ReadWriteDoubleArrayBuffer extends DoubleArrayBuffer with all the write
- * methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadWriteDoubleArrayBuffer extends DoubleArrayBuffer {
-
- static ReadWriteDoubleArrayBuffer copy(DoubleArrayBuffer other, int markOfOther) {
- ReadWriteDoubleArrayBuffer buf =
- new ReadWriteDoubleArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadWriteDoubleArrayBuffer(double[] array) {
- super(array);
- }
-
- ReadWriteDoubleArrayBuffer(int capacity) {
- super(capacity);
- }
-
- ReadWriteDoubleArrayBuffer(int capacity, double[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public DoubleBuffer asReadOnlyBuffer() {
- return ReadOnlyDoubleArrayBuffer.copy(this, mark);
- }
-
- @Override
- public DoubleBuffer compact() {
- System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public DoubleBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override double[] protectedArray() {
- return backingArray;
- }
-
- @Override int protectedArrayOffset() {
- return offset;
- }
-
- @Override boolean protectedHasArray() {
- return true;
- }
-
- @Override
- public DoubleBuffer put(double c) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- backingArray[offset + position++] = c;
- return this;
- }
-
- @Override
- public DoubleBuffer put(int index, double c) {
- checkIndex(index);
- backingArray[offset + index] = c;
- return this;
- }
-
- @Override
- public DoubleBuffer put(double[] src, int srcOffset, int doubleCount) {
- if (doubleCount > remaining()) {
- throw new BufferOverflowException();
- }
- System.arraycopy(src, srcOffset, backingArray, offset + position, doubleCount);
- position += doubleCount;
- return this;
- }
-
- @Override
- public DoubleBuffer slice() {
- return new ReadWriteDoubleArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteFloatArrayBuffer.java b/luni/src/main/java/java/nio/ReadWriteFloatArrayBuffer.java
deleted file mode 100644
index eee3aa7..0000000
--- a/luni/src/main/java/java/nio/ReadWriteFloatArrayBuffer.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * FloatArrayBuffer, ReadWriteFloatArrayBuffer and ReadOnlyFloatArrayBuffer
- * compose the implementation of array based float buffers.
- * <p>
- * ReadWriteFloatArrayBuffer extends FloatArrayBuffer with all the write
- * methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadWriteFloatArrayBuffer extends FloatArrayBuffer {
-
- static ReadWriteFloatArrayBuffer copy(FloatArrayBuffer other, int markOfOther) {
- ReadWriteFloatArrayBuffer buf =
- new ReadWriteFloatArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadWriteFloatArrayBuffer(float[] array) {
- super(array);
- }
-
- ReadWriteFloatArrayBuffer(int capacity) {
- super(capacity);
- }
-
- ReadWriteFloatArrayBuffer(int capacity, float[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public FloatBuffer asReadOnlyBuffer() {
- return ReadOnlyFloatArrayBuffer.copy(this, mark);
- }
-
- @Override
- public FloatBuffer compact() {
- System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public FloatBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override float[] protectedArray() {
- return backingArray;
- }
-
- @Override int protectedArrayOffset() {
- return offset;
- }
-
- @Override boolean protectedHasArray() {
- return true;
- }
-
- @Override
- public FloatBuffer put(float c) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- backingArray[offset + position++] = c;
- return this;
- }
-
- @Override
- public FloatBuffer put(int index, float c) {
- checkIndex(index);
- backingArray[offset + index] = c;
- return this;
- }
-
- @Override
- public FloatBuffer put(float[] src, int srcOffset, int floatCount) {
- if (floatCount > remaining()) {
- throw new BufferOverflowException();
- }
- System.arraycopy(src, srcOffset, backingArray, offset + position, floatCount);
- position += floatCount;
- return this;
- }
-
- @Override
- public FloatBuffer slice() {
- return new ReadWriteFloatArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteHeapByteBuffer.java b/luni/src/main/java/java/nio/ReadWriteHeapByteBuffer.java
deleted file mode 100644
index 02296c6..0000000
--- a/luni/src/main/java/java/nio/ReadWriteHeapByteBuffer.java
+++ /dev/null
@@ -1,248 +0,0 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-import libcore.io.Memory;
-import libcore.io.SizeOf;
-
-/**
- * HeapByteBuffer, ReadWriteHeapByteBuffer and ReadOnlyHeapByteBuffer compose
- * the implementation of array based byte buffers.
- * <p>
- * ReadWriteHeapByteBuffer extends HeapByteBuffer with all the write methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadWriteHeapByteBuffer extends HeapByteBuffer {
-
- static ReadWriteHeapByteBuffer copy(HeapByteBuffer other, int markOfOther) {
- ReadWriteHeapByteBuffer buf =
- new ReadWriteHeapByteBuffer(other.backingArray, other.capacity(), other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadWriteHeapByteBuffer(byte[] backingArray) {
- super(backingArray);
- }
-
- ReadWriteHeapByteBuffer(int capacity) {
- super(capacity);
- }
-
- ReadWriteHeapByteBuffer(byte[] backingArray, int capacity, int arrayOffset) {
- super(backingArray, capacity, arrayOffset);
- }
-
- @Override
- public ByteBuffer asReadOnlyBuffer() {
- return ReadOnlyHeapByteBuffer.copy(this, mark);
- }
-
- @Override
- public ByteBuffer compact() {
- System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public ByteBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override byte[] protectedArray() {
- return backingArray;
- }
-
- @Override int protectedArrayOffset() {
- return offset;
- }
-
- @Override boolean protectedHasArray() {
- return true;
- }
-
- @Override
- public ByteBuffer put(byte b) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- backingArray[offset + position++] = b;
- return this;
- }
-
- @Override
- public ByteBuffer put(int index, byte b) {
- checkIndex(index);
- backingArray[offset + index] = b;
- return this;
- }
-
- @Override
- public ByteBuffer put(byte[] src, int srcOffset, int byteCount) {
- checkPutBounds(1, src.length, srcOffset, byteCount);
- System.arraycopy(src, srcOffset, backingArray, offset + position, byteCount);
- position += byteCount;
- return this;
- }
-
- final void put(char[] src, int srcOffset, int charCount) {
- int byteCount = checkPutBounds(SizeOf.CHAR, src.length, srcOffset, charCount);
- Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.CHAR, order.needsSwap);
- position += byteCount;
- }
-
- final void put(double[] src, int srcOffset, int doubleCount) {
- int byteCount = checkPutBounds(SizeOf.DOUBLE, src.length, srcOffset, doubleCount);
- Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.DOUBLE, order.needsSwap);
- position += byteCount;
- }
-
- final void put(float[] src, int srcOffset, int floatCount) {
- int byteCount = checkPutBounds(SizeOf.FLOAT, src.length, srcOffset, floatCount);
- Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.FLOAT, order.needsSwap);
- position += byteCount;
- }
-
- final void put(int[] src, int srcOffset, int intCount) {
- int byteCount = checkPutBounds(SizeOf.INT, src.length, srcOffset, intCount);
- Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.INT, order.needsSwap);
- position += byteCount;
- }
-
- final void put(long[] src, int srcOffset, int longCount) {
- int byteCount = checkPutBounds(SizeOf.LONG, src.length, srcOffset, longCount);
- Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.LONG, order.needsSwap);
- position += byteCount;
- }
-
- final void put(short[] src, int srcOffset, int shortCount) {
- int byteCount = checkPutBounds(SizeOf.SHORT, src.length, srcOffset, shortCount);
- Memory.unsafeBulkPut(backingArray, offset + position, byteCount, src, srcOffset, SizeOf.SHORT, order.needsSwap);
- position += byteCount;
- }
-
- @Override
- public ByteBuffer putChar(int index, char value) {
- checkIndex(index, SizeOf.CHAR);
- Memory.pokeShort(backingArray, offset + index, (short) value, order);
- return this;
- }
-
- @Override
- public ByteBuffer putChar(char value) {
- int newPosition = position + SizeOf.CHAR;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- Memory.pokeShort(backingArray, offset + position, (short) value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putDouble(double value) {
- return putLong(Double.doubleToRawLongBits(value));
- }
-
- @Override
- public ByteBuffer putDouble(int index, double value) {
- return putLong(index, Double.doubleToRawLongBits(value));
- }
-
- @Override
- public ByteBuffer putFloat(float value) {
- return putInt(Float.floatToRawIntBits(value));
- }
-
- @Override
- public ByteBuffer putFloat(int index, float value) {
- return putInt(index, Float.floatToRawIntBits(value));
- }
-
- @Override
- public ByteBuffer putInt(int value) {
- int newPosition = position + SizeOf.INT;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- Memory.pokeInt(backingArray, offset + position, value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putInt(int index, int value) {
- checkIndex(index, SizeOf.INT);
- Memory.pokeInt(backingArray, offset + index, value, order);
- return this;
- }
-
- @Override
- public ByteBuffer putLong(int index, long value) {
- checkIndex(index, SizeOf.LONG);
- Memory.pokeLong(backingArray, offset + index, value, order);
- return this;
- }
-
- @Override
- public ByteBuffer putLong(long value) {
- int newPosition = position + SizeOf.LONG;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- Memory.pokeLong(backingArray, offset + position, value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer putShort(int index, short value) {
- checkIndex(index, SizeOf.SHORT);
- Memory.pokeShort(backingArray, offset + index, value, order);
- return this;
- }
-
- @Override
- public ByteBuffer putShort(short value) {
- int newPosition = position + SizeOf.SHORT;
- if (newPosition > limit) {
- throw new BufferOverflowException();
- }
- Memory.pokeShort(backingArray, offset + position, value, order);
- position = newPosition;
- return this;
- }
-
- @Override
- public ByteBuffer slice() {
- return new ReadWriteHeapByteBuffer(backingArray, remaining(), offset + position);
- }
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteIntArrayBuffer.java b/luni/src/main/java/java/nio/ReadWriteIntArrayBuffer.java
deleted file mode 100644
index e8e67c2..0000000
--- a/luni/src/main/java/java/nio/ReadWriteIntArrayBuffer.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * IntArrayBuffer, ReadWriteIntArrayBuffer and ReadOnlyIntArrayBuffer compose
- * the implementation of array based int buffers.
- * <p>
- * ReadWriteIntArrayBuffer extends IntArrayBuffer with all the write methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadWriteIntArrayBuffer extends IntArrayBuffer {
-
- static ReadWriteIntArrayBuffer copy(IntArrayBuffer other, int markOfOther) {
- ReadWriteIntArrayBuffer buf =
- new ReadWriteIntArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadWriteIntArrayBuffer(int[] array) {
- super(array);
- }
-
- ReadWriteIntArrayBuffer(int capacity) {
- super(capacity);
- }
-
- ReadWriteIntArrayBuffer(int capacity, int[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public IntBuffer asReadOnlyBuffer() {
- return ReadOnlyIntArrayBuffer.copy(this, mark);
- }
-
- @Override
- public IntBuffer compact() {
- System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public IntBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override int[] protectedArray() {
- return backingArray;
- }
-
- @Override int protectedArrayOffset() {
- return offset;
- }
-
- @Override boolean protectedHasArray() {
- return true;
- }
-
- @Override
- public IntBuffer put(int c) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- backingArray[offset + position++] = c;
- return this;
- }
-
- @Override
- public IntBuffer put(int index, int c) {
- checkIndex(index);
- backingArray[offset + index] = c;
- return this;
- }
-
- @Override
- public IntBuffer put(int[] src, int srcOffset, int intCount) {
- if (intCount > remaining()) {
- throw new BufferOverflowException();
- }
- System.arraycopy(src, srcOffset, backingArray, offset + position, intCount);
- position += intCount;
- return this;
- }
-
- @Override
- public IntBuffer slice() {
- return new ReadWriteIntArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteLongArrayBuffer.java b/luni/src/main/java/java/nio/ReadWriteLongArrayBuffer.java
deleted file mode 100644
index df5f09f..0000000
--- a/luni/src/main/java/java/nio/ReadWriteLongArrayBuffer.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * LongArrayBuffer, ReadWriteLongArrayBuffer and ReadOnlyLongArrayBuffer compose
- * the implementation of array based long buffers.
- * <p>
- * ReadWriteLongArrayBuffer extends LongArrayBuffer with all the write methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadWriteLongArrayBuffer extends LongArrayBuffer {
-
- static ReadWriteLongArrayBuffer copy(LongArrayBuffer other, int markOfOther) {
- ReadWriteLongArrayBuffer buf =
- new ReadWriteLongArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadWriteLongArrayBuffer(long[] array) {
- super(array);
- }
-
- ReadWriteLongArrayBuffer(int capacity) {
- super(capacity);
- }
-
- ReadWriteLongArrayBuffer(int capacity, long[] backingArray, int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public LongBuffer asReadOnlyBuffer() {
- return ReadOnlyLongArrayBuffer.copy(this, mark);
- }
-
- @Override
- public LongBuffer compact() {
- System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public LongBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override long[] protectedArray() {
- return backingArray;
- }
-
- @Override int protectedArrayOffset() {
- return offset;
- }
-
- @Override boolean protectedHasArray() {
- return true;
- }
-
- @Override
- public LongBuffer put(long c) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- backingArray[offset + position++] = c;
- return this;
- }
-
- @Override
- public LongBuffer put(int index, long c) {
- checkIndex(index);
- backingArray[offset + index] = c;
- return this;
- }
-
- @Override
- public LongBuffer put(long[] src, int srcOffset, int longCount) {
- if (longCount > remaining()) {
- throw new BufferOverflowException();
- }
- System.arraycopy(src, srcOffset, backingArray, offset + position, longCount);
- position += longCount;
- return this;
- }
-
- @Override
- public LongBuffer slice() {
- return new ReadWriteLongArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ReadWriteShortArrayBuffer.java b/luni/src/main/java/java/nio/ReadWriteShortArrayBuffer.java
deleted file mode 100644
index 2a43e91..0000000
--- a/luni/src/main/java/java/nio/ReadWriteShortArrayBuffer.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package java.nio;
-
-/**
- * ShortArrayBuffer, ReadWriteShortArrayBuffer and ReadOnlyShortArrayBuffer
- * compose the implementation of array based short buffers.
- * <p>
- * ReadWriteShortArrayBuffer extends ShortArrayBuffer with all the write
- * methods.
- * </p>
- * <p>
- * This class is marked final for runtime performance.
- * </p>
- *
- */
-final class ReadWriteShortArrayBuffer extends ShortArrayBuffer {
-
- static ReadWriteShortArrayBuffer copy(ShortArrayBuffer other, int markOfOther) {
- ReadWriteShortArrayBuffer buf =
- new ReadWriteShortArrayBuffer(other.capacity(), other.backingArray, other.offset);
- buf.limit = other.limit;
- buf.position = other.position();
- buf.mark = markOfOther;
- return buf;
- }
-
- ReadWriteShortArrayBuffer(short[] array) {
- super(array);
- }
-
- ReadWriteShortArrayBuffer(int capacity) {
- super(capacity);
- }
-
- ReadWriteShortArrayBuffer(int capacity, short[] backingArray,
- int arrayOffset) {
- super(capacity, backingArray, arrayOffset);
- }
-
- @Override
- public ShortBuffer asReadOnlyBuffer() {
- return ReadOnlyShortArrayBuffer.copy(this, mark);
- }
-
- @Override
- public ShortBuffer compact() {
- System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());
- position = limit - position;
- limit = capacity;
- mark = UNSET_MARK;
- return this;
- }
-
- @Override
- public ShortBuffer duplicate() {
- return copy(this, mark);
- }
-
- @Override
- public boolean isReadOnly() {
- return false;
- }
-
- @Override short[] protectedArray() {
- return backingArray;
- }
-
- @Override int protectedArrayOffset() {
- return offset;
- }
-
- @Override boolean protectedHasArray() {
- return true;
- }
-
- @Override
- public ShortBuffer put(short c) {
- if (position == limit) {
- throw new BufferOverflowException();
- }
- backingArray[offset + position++] = c;
- return this;
- }
-
- @Override
- public ShortBuffer put(int index, short c) {
- checkIndex(index);
- backingArray[offset + index] = c;
- return this;
- }
-
- @Override
- public ShortBuffer put(short[] src, int srcOffset, int shortCount) {
- if (shortCount > remaining()) {
- throw new BufferOverflowException();
- }
- System.arraycopy(src, srcOffset, backingArray, offset + position, shortCount);
- position += shortCount;
- return this;
- }
-
- @Override
- public ShortBuffer slice() {
- return new ReadWriteShortArrayBuffer(remaining(), backingArray, offset + position);
- }
-
-}
diff --git a/luni/src/main/java/java/nio/ShortArrayBuffer.java b/luni/src/main/java/java/nio/ShortArrayBuffer.java
index bf6f752..a092cb0 100644
--- a/luni/src/main/java/java/nio/ShortArrayBuffer.java
+++ b/luni/src/main/java/java/nio/ShortArrayBuffer.java
@@ -18,69 +18,141 @@
package java.nio;
/**
- * ShortArrayBuffer, ReadWriteShortArrayBuffer and ReadOnlyShortArrayBuffer
- * compose the implementation of array based short buffers.
- * <p>
- * ShortArrayBuffer implements all the shared readonly methods and is extended
- * by the other two classes.
- * </p>
- * <p>
- * All methods are marked final for runtime performance.
- * </p>
- *
+ * ShortArrayBuffer implements short[]-based ShortBuffers.
*/
-abstract class ShortArrayBuffer extends ShortBuffer {
+final class ShortArrayBuffer extends ShortBuffer {
- protected final short[] backingArray;
+ private final short[] backingArray;
- protected final int offset;
+ private final int arrayOffset;
- ShortArrayBuffer(short[] array) {
- this(array.length, array, 0);
+ private final boolean isReadOnly;
+
+ ShortArrayBuffer(short[] array) {
+ this(array.length, array, 0, false);
+ }
+
+ private ShortArrayBuffer(int capacity, short[] backingArray, int arrayOffset, boolean isReadOnly) {
+ super(capacity);
+ this.backingArray = backingArray;
+ this.arrayOffset = arrayOffset;
+ this.isReadOnly = isReadOnly;
+ }
+
+ private static ShortArrayBuffer copy(ShortArrayBuffer other, int markOfOther, boolean isReadOnly) {
+ ShortArrayBuffer buf = new ShortArrayBuffer(other.capacity(), other.backingArray, other.arrayOffset, isReadOnly);
+ buf.limit = other.limit;
+ buf.position = other.position();
+ buf.mark = markOfOther;
+ return buf;
+ }
+
+ @Override public ShortBuffer asReadOnlyBuffer() {
+ return copy(this, mark, true);
+ }
+
+ @Override public ShortBuffer compact() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ System.arraycopy(backingArray, position + arrayOffset, backingArray, arrayOffset, remaining());
+ position = limit - position;
+ limit = capacity;
+ mark = UNSET_MARK;
+ return this;
+ }
- ShortArrayBuffer(int capacity) {
- this(capacity, new short[capacity], 0);
+ @Override public ShortBuffer duplicate() {
+ return copy(this, mark, isReadOnly);
+ }
+
+ @Override public ShortBuffer slice() {
+ return new ShortArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly);
+ }
+
+ @Override public boolean isReadOnly() {
+ return isReadOnly;
+ }
+
+ @Override short[] protectedArray() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return backingArray;
+ }
- ShortArrayBuffer(int capacity, short[] backingArray, int offset) {
- super(capacity);
- this.backingArray = backingArray;
- this.offset = offset;
+ @Override int protectedArrayOffset() {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
+ return arrayOffset;
+ }
- @Override
- public final short get() {
- if (position == limit) {
- throw new BufferUnderflowException();
- }
- return backingArray[offset + position++];
+ @Override boolean protectedHasArray() {
+ if (isReadOnly) {
+ return false;
}
+ return true;
+ }
- @Override
- public final short get(int index) {
- checkIndex(index);
- return backingArray[offset + index];
+ @Override public final short get() {
+ if (position == limit) {
+ throw new BufferUnderflowException();
}
+ return backingArray[arrayOffset + position++];
+ }
- @Override
- public final ShortBuffer get(short[] dst, int dstOffset, int shortCount) {
- if (shortCount > remaining()) {
- throw new BufferUnderflowException();
- }
- System.arraycopy(backingArray, offset + position, dst, dstOffset, shortCount);
- position += shortCount;
- return this;
+ @Override public final short get(int index) {
+ checkIndex(index);
+ return backingArray[arrayOffset + index];
+ }
+
+ @Override public final ShortBuffer get(short[] dst, int dstOffset, int shortCount) {
+ if (shortCount > remaining()) {
+ throw new BufferUnderflowException();
}
+ System.arraycopy(backingArray, arrayOffset + position, dst, dstOffset, shortCount);
+ position += shortCount;
+ return this;
+ }
- @Override
- public final boolean isDirect() {
- return false;
+ @Override public final boolean isDirect() {
+ return false;
+ }
+
+ @Override public final ByteOrder order() {
+ return ByteOrder.nativeOrder();
+ }
+
+ @Override public ShortBuffer put(short c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
}
-
- @Override
- public final ByteOrder order() {
- return ByteOrder.nativeOrder();
+ if (position == limit) {
+ throw new BufferOverflowException();
}
+ backingArray[arrayOffset + position++] = c;
+ return this;
+ }
+ @Override public ShortBuffer put(int index, short c) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ checkIndex(index);
+ backingArray[arrayOffset + index] = c;
+ return this;
+ }
+
+ @Override public ShortBuffer put(short[] src, int srcOffset, int shortCount) {
+ if (isReadOnly) {
+ throw new ReadOnlyBufferException();
+ }
+ if (shortCount > remaining()) {
+ throw new BufferOverflowException();
+ }
+ System.arraycopy(src, srcOffset, backingArray, arrayOffset + position, shortCount);
+ position += shortCount;
+ return this;
+ }
}
diff --git a/luni/src/main/java/java/nio/ShortBuffer.java b/luni/src/main/java/java/nio/ShortBuffer.java
index d12a49e..ea20bed 100644
--- a/luni/src/main/java/java/nio/ShortBuffer.java
+++ b/luni/src/main/java/java/nio/ShortBuffer.java
@@ -48,7 +48,7 @@
if (capacity < 0) {
throw new IllegalArgumentException("capacity < 0: " + capacity);
}
- return new ReadWriteShortArrayBuffer(capacity);
+ return new ShortArrayBuffer(new short[capacity]);
}
/**
@@ -85,7 +85,7 @@
*/
public static ShortBuffer wrap(short[] array, int start, int shortCount) {
Arrays.checkOffsetAndCount(array.length, start, shortCount);
- ShortBuffer buf = new ReadWriteShortArrayBuffer(array);
+ ShortBuffer buf = new ShortArrayBuffer(array);
buf.position = start;
buf.limit = start + shortCount;
return buf;
@@ -425,6 +425,9 @@
* if no changes may be made to the contents of this buffer.
*/
public ShortBuffer put(ShortBuffer src) {
+ if (isReadOnly()) {
+ throw new ReadOnlyBufferException();
+ }
if (src == this) {
throw new IllegalArgumentException("src == this");
}
diff --git a/luni/src/test/java/libcore/java/nio/BufferTest.java b/luni/src/test/java/libcore/java/nio/BufferTest.java
index 4c500a5..a4e5eaf 100644
--- a/luni/src/test/java/libcore/java/nio/BufferTest.java
+++ b/luni/src/test/java/libcore/java/nio/BufferTest.java
@@ -714,7 +714,7 @@
public void testHasArrayOnJniDirectByteBuffer() throws Exception {
// Simulate a call to JNI's NewDirectByteBuffer.
- Class<?> c = Class.forName("java.nio.ReadWriteDirectByteBuffer");
+ Class<?> c = Class.forName("java.nio.DirectByteBuffer");
Constructor<?> ctor = c.getDeclaredConstructor(int.class, int.class);
ctor.setAccessible(true);
ByteBuffer bb = (ByteBuffer) ctor.newInstance(0, 0);
@@ -807,4 +807,52 @@
assertTrue(expected.getMessage().contains("limit=0"));
}
}
+
+ public void testUsingDirectBufferAsMappedBuffer() throws Exception {
+ MappedByteBuffer notMapped = (MappedByteBuffer) ByteBuffer.allocateDirect(1);
+ try {
+ notMapped.force();
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ try {
+ notMapped.isLoaded();
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ try {
+ notMapped.load();
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ MappedByteBuffer mapped = (MappedByteBuffer) allocateMapped(1);
+ mapped.force();
+ mapped.isLoaded();
+ mapped.load();
+ }
+
+ // https://code.google.com/p/android/issues/detail?id=53637
+ public void testBug53637() throws Exception {
+ MappedByteBuffer mapped = (MappedByteBuffer) allocateMapped(1);
+ mapped.get();
+ mapped.rewind();
+ mapped.get();
+
+ mapped.rewind();
+ mapped.mark();
+ mapped.get();
+ mapped.reset();
+ mapped.get();
+
+ mapped.rewind();
+ mapped.get();
+ mapped.clear();
+ mapped.get();
+
+ mapped.rewind();
+ mapped.get();
+ mapped.flip();
+ mapped.get();
+ }
}
