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 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; }
@Override public final byte get(int index) { checkIndex(index); return backingArray[arrayOffset + index]; }
@Override public ByteBuffer slice() { return new ByteArrayBuffer(remaining(), backingArray, arrayOffset + position, isReadOnly); }
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; }
@Override public DoubleBuffer get(double[] dst, int dstOffset, int doubleCount) { byteBuffer.limit(limit * SizeOf.DOUBLE); byteBuffer.position(position * SizeOf.DOUBLE); if (byteBuffer instanceof DirectByteBuffer) { ((DirectByteBuffer) byteBuffer).get(dst, dstOffset, doubleCount); } else { ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, doubleCount); } this.position += doubleCount; return this; }
@Override public final double getDouble() { return Double.longBitsToDouble(getLong()); }
@Override public ByteBuffer asReadOnlyBuffer() { return copy(this, mark, true); }
@Override public final float getFloat(int index) { return Float.intBitsToFloat(getInt(index)); }
/** * Creates a new byte buffer by wrapping the given byte array. * <p> * Calling this method has the same effect as * {@code wrap(array, 0, array.length)}. * * @param array * the byte array which the new buffer will be based on * @return the created byte buffer. */ public static ByteBuffer wrap(byte[] array) { return new ByteArrayBuffer(array); }
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; }
@Override public IntBuffer get(int[] dst, int dstOffset, int intCount) { byteBuffer.limit(limit * SizeOf.INT); byteBuffer.position(position * SizeOf.INT); if (byteBuffer instanceof DirectByteBuffer) { ((DirectByteBuffer) byteBuffer).get(dst, dstOffset, intCount); } else { ((ByteArrayBuffer) byteBuffer).get(dst, dstOffset, intCount); } this.position += intCount; return this; }
@Override public final double getDouble(int index) { return Double.longBitsToDouble(getLong(index)); }
@Override public ByteBuffer duplicate() { return copy(this, mark, isReadOnly); }
@Override public final float getFloat() { return Float.intBitsToFloat(getInt()); }
/** * Creates a byte buffer based on a newly allocated byte array. * * @param capacity * the capacity of the new buffer * @return the created byte buffer. * @throws IllegalArgumentException * if {@code capacity < 0}. */ public static ByteBuffer allocate(int capacity) { if (capacity < 0) { throw new IllegalArgumentException("capacity < 0: " + capacity); } return new ByteArrayBuffer(new byte[capacity]); }
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; }
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; }
@Override public ByteBuffer put(int index, byte b) { if (isReadOnly) { throw new ReadOnlyBufferException(); } checkIndex(index); backingArray[arrayOffset + index] = b; return this; }
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; }