/*
 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

// -- This file was mechanically generated: Do not edit! -- //

package java.nio;

import java.io.FileDescriptor;
import sun.misc.Cleaner;
import sun.misc.Unsafe;
import sun.misc.VM;
import sun.nio.ch.DirectBuffer;


class DirectByteBuffer

 extends MappedByteBuffer



 implements DirectBuffer
{



 // Cached unsafe-access object
 protected static final Unsafe unsafe = Bits.unsafe();

 // Cached array base offset
 private static final long arrayBaseOffset = (long)unsafe.arrayBaseOffset(byte[].class);

 // Cached unaligned-access capability
 protected static final boolean unaligned = Bits.unaligned();

 // Base address, used in all indexing calculations
 // NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress
 // protected long address;

 // An object attached to this buffer. If this buffer is a view of another
 // buffer then we use this field to keep a reference to that buffer to
 // ensure that its memory isn't freed before we are done with it.
 private final Object att;

 public Object attachment() {
 return att;
 }



 private static class Deallocator
 implements Runnable
 {

 private static Unsafe unsafe = Unsafe.getUnsafe();

 private long address;
 private long size;
 private int capacity;

 private Deallocator(long address, long size, int capacity) {
 assert (address != 0);
 this.address = address;
 this.size = size;
 this.capacity = capacity;
 }

 public void run() {
 if (address == 0) {
 // Paranoia
 return;
 }
 unsafe.freeMemory(address);
 address = 0;
 Bits.unreserveMemory(size, capacity);
 }

 }

 private final Cleaner cleaner;

 public Cleaner cleaner() { return cleaner; }











 // Primary constructor
 //
 DirectByteBuffer(int cap) { // package-private

 super(-1, 0, cap, cap);
 boolean pa = VM.isDirectMemoryPageAligned();
 int ps = Bits.pageSize();
 long size = Math.max(1L, (long)cap + (pa ? ps : 0));
 Bits.reserveMemory(size, cap);

 long base = 0;
 try {
 base = unsafe.allocateMemory(size);
 } catch (OutOfMemoryError x) {
 Bits.unreserveMemory(size, cap);
 throw x;
 }
 unsafe.setMemory(base, size, (byte) 0);
 if (pa && (base % ps != 0)) {
 // Round up to page boundary
 address = base + ps - (base & (ps - 1));
 } else {
 address = base;
 }
 cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
 att = null;



 }



 // Invoked to construct a direct ByteBuffer referring to the block of
 // memory. A given arbitrary object may also be attached to the buffer.
 //
 DirectByteBuffer(long addr, int cap, Object ob) {
 super(-1, 0, cap, cap);
 address = addr;
 cleaner = null;
 att = ob;
 }


 // Invoked only by JNI: NewDirectByteBuffer(void*, long)
 //
 private DirectByteBuffer(long addr, int cap) {
 super(-1, 0, cap, cap);
 address = addr;
 cleaner = null;
 att = null;
 }



 // For memory-mapped buffers -- invoked by FileChannelImpl via reflection
 //
 protected DirectByteBuffer(int cap, long addr,
 FileDescriptor fd,
 Runnable unmapper)
 {

 super(-1, 0, cap, cap, fd);
 address = addr;
 cleaner = Cleaner.create(this, unmapper);
 att = null;



 }



 // For duplicates and slices
 //
 DirectByteBuffer(DirectBuffer db, // package-private
 int mark, int pos, int lim, int cap,
 int off)
 {

 super(mark, pos, lim, cap);
 address = db.address() + off;

 cleaner = null;

 att = db;



 }

 public ByteBuffer slice() {
 int pos = this.position();
 int lim = this.limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 int off = (pos << 0);
 assert (off >= 0);
 return new DirectByteBuffer(this, -1, 0, rem, rem, off);
 }

 public ByteBuffer duplicate() {
 return new DirectByteBuffer(this,
 this.markValue(),
 this.position(),
 this.limit(),
 this.capacity(),
 0);
 }

 public ByteBuffer asReadOnlyBuffer() {

 return new DirectByteBufferR(this,
 this.markValue(),
 this.position(),
 this.limit(),
 this.capacity(),
 0);



 }



 public long address() {
 return address;
 }

 private long ix(int i) {
 return address + ((long)i << 0);
 }

 public byte get() {
 return ((unsafe.getByte(ix(nextGetIndex()))));
 }

 public byte get(int i) {
 return ((unsafe.getByte(ix(checkIndex(i)))));
 }







 public ByteBuffer get(byte[] dst, int offset, int length) {

 if (((long)length << 0) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
 checkBounds(offset, length, dst.length);
 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 if (length > rem)
 throw new BufferUnderflowException();








 Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
 (long)offset << 0,
 (long)length << 0);
 position(pos + length);
 } else {
 super.get(dst, offset, length);
 }
 return this;



 }



 public ByteBuffer put(byte x) {

 unsafe.putByte(ix(nextPutIndex()), ((x)));
 return this;



 }

 public ByteBuffer put(int i, byte x) {

 unsafe.putByte(ix(checkIndex(i)), ((x)));
 return this;



 }

 public ByteBuffer put(ByteBuffer src) {

 if (src instanceof DirectByteBuffer) {
 if (src == this)
 throw new IllegalArgumentException();
 DirectByteBuffer sb = (DirectByteBuffer)src;

 int spos = sb.position();
 int slim = sb.limit();
 assert (spos <= slim);
 int srem = (spos <= slim ? slim - spos : 0);

 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);

 if (srem > rem)
 throw new BufferOverflowException();
 unsafe.copyMemory(sb.ix(spos), ix(pos), (long)srem << 0);
 sb.position(spos + srem);
 position(pos + srem);
 } else if (src.hb != null) {

 int spos = src.position();
 int slim = src.limit();
 assert (spos <= slim);
 int srem = (spos <= slim ? slim - spos : 0);

 put(src.hb, src.offset + spos, srem);
 src.position(spos + srem);

 } else {
 super.put(src);
 }
 return this;



 }

 public ByteBuffer put(byte[] src, int offset, int length) {

 if (((long)length << 0) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
 checkBounds(offset, length, src.length);
 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);
 if (length > rem)
 throw new BufferOverflowException();









 Bits.copyFromArray(src, arrayBaseOffset,
 (long)offset << 0,
 ix(pos),
 (long)length << 0);
 position(pos + length);
 } else {
 super.put(src, offset, length);
 }
 return this;



 }

 public ByteBuffer compact() {

 int pos = position();
 int lim = limit();
 assert (pos <= lim);
 int rem = (pos <= lim ? lim - pos : 0);

 unsafe.copyMemory(ix(pos), ix(0), (long)rem << 0);
 position(rem);
 limit(capacity());
 discardMark();
 return this;



 }

 public boolean isDirect() {
 return true;
 }

 public boolean isReadOnly() {
 return false;
 }
































































 byte _get(int i) { // package-private
 return unsafe.getByte(address + i);
 }

 void _put(int i, byte b) { // package-private

 unsafe.putByte(address + i, b);



 }




 private char getChar(long a) {
 if (unaligned) {
 char x = unsafe.getChar(a);
 return (nativeByteOrder ? x : Bits.swap(x));
 }
 return Bits.getChar(a, bigEndian);
 }

 public char getChar() {
 return getChar(ix(nextGetIndex((1 << 1))));
 }

 public char getChar(int i) {
 return getChar(ix(checkIndex(i, (1 << 1))));
 }



 private ByteBuffer putChar(long a, char x) {

 if (unaligned) {
 char y = (x);
 unsafe.putChar(a, (nativeByteOrder ? y : Bits.swap(y)));
 } else {
 Bits.putChar(a, x, bigEndian);
 }
 return this;



 }

 public ByteBuffer putChar(char x) {

 putChar(ix(nextPutIndex((1 << 1))), x);
 return this;



 }

 public ByteBuffer putChar(int i, char x) {

 putChar(ix(checkIndex(i, (1 << 1))), x);
 return this;



 }

 public CharBuffer asCharBuffer() {
 int off = this.position();
 int lim = this.limit();
 assert (off <= lim);
 int rem = (off <= lim ? lim - off : 0);

 int size = rem >> 1;
 if (!unaligned && ((address + off) % (1 << 1) != 0)) {
 return (bigEndian
 ? (CharBuffer)(new ByteBufferAsCharBufferB(this,
 -1,
 0,
 size,
 size,
 off))
 : (CharBuffer)(new ByteBufferAsCharBufferL(this,
 -1,
 0,
 size,
 size,
 off)));
 } else {
 return (nativeByteOrder
 ? (CharBuffer)(new DirectCharBufferU(this,
 -1,
 0,
 size,
 size,
 off))
 : (CharBuffer)(new DirectCharBufferS(this,
 -1,
 0,
 size,
 size,
 off)));
 }
 }




 private short getShort(long a) {
 if (unaligned) {
 short x = unsafe.getShort(a);
 return (nativeByteOrder ? x : Bits.swap(x));
 }
 return Bits.getShort(a, bigEndian);
 }

 public short getShort() {
 return getShort(ix(nextGetIndex((1 << 1))));
 }

 public short getShort(int i) {
 return getShort(ix(checkIndex(i, (1 << 1))));
 }



 private ByteBuffer putShort(long a, short x) {

 if (unaligned) {
 short y = (x);
 unsafe.putShort(a, (nativeByteOrder ? y : Bits.swap(y)));
 } else {
 Bits.putShort(a, x, bigEndian);
 }
 return this;



 }

 public ByteBuffer putShort(short x) {

 putShort(ix(nextPutIndex((1 << 1))), x);
 return this;



 }

 public ByteBuffer putShort(int i, short x) {

 putShort(ix(checkIndex(i, (1 << 1))), x);
 return this;



 }

 public ShortBuffer asShortBuffer() {
 int off = this.position();
 int lim = this.limit();
 assert (off <= lim);
 int rem = (off <= lim ? lim - off : 0);

 int size = rem >> 1;
 if (!unaligned && ((address + off) % (1 << 1) != 0)) {
 return (bigEndian
 ? (ShortBuffer)(new ByteBufferAsShortBufferB(this,
 -1,
 0,
 size,
 size,
 off))
 : (ShortBuffer)(new ByteBufferAsShortBufferL(this,
 -1,
 0,
 size,
 size,
 off)));
 } else {
 return (nativeByteOrder
 ? (ShortBuffer)(new DirectShortBufferU(this,
 -1,
 0,
 size,
 size,
 off))
 : (ShortBuffer)(new DirectShortBufferS(this,
 -1,
 0,
 size,
 size,
 off)));
 }
 }




 private int getInt(long a) {
 if (unaligned) {
 int x = unsafe.getInt(a);
 return (nativeByteOrder ? x : Bits.swap(x));
 }
 return Bits.getInt(a, bigEndian);
 }

 public int getInt() {
 return getInt(ix(nextGetIndex((1 << 2))));
 }

 public int getInt(int i) {
 return getInt(ix(checkIndex(i, (1 << 2))));
 }



 private ByteBuffer putInt(long a, int x) {

 if (unaligned) {
 int y = (x);
 unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
 } else {
 Bits.putInt(a, x, bigEndian);
 }
 return this;



 }

 public ByteBuffer putInt(int x) {

 putInt(ix(nextPutIndex((1 << 2))), x);
 return this;



 }

 public ByteBuffer putInt(int i, int x) {

 putInt(ix(checkIndex(i, (1 << 2))), x);
 return this;



 }

 public IntBuffer asIntBuffer() {
 int off = this.position();
 int lim = this.limit();
 assert (off <= lim);
 int rem = (off <= lim ? lim - off : 0);

 int size = rem >> 2;
 if (!unaligned && ((address + off) % (1 << 2) != 0)) {
 return (bigEndian
 ? (IntBuffer)(new ByteBufferAsIntBufferB(this,
 -1,
 0,
 size,
 size,
 off))
 : (IntBuffer)(new ByteBufferAsIntBufferL(this,
 -1,
 0,
 size,
 size,
 off)));
 } else {
 return (nativeByteOrder
 ? (IntBuffer)(new DirectIntBufferU(this,
 -1,
 0,
 size,
 size,
 off))
 : (IntBuffer)(new DirectIntBufferS(this,
 -1,
 0,
 size,
 size,
 off)));
 }
 }




 private long getLong(long a) {
 if (unaligned) {
 long x = unsafe.getLong(a);
 return (nativeByteOrder ? x : Bits.swap(x));
 }
 return Bits.getLong(a, bigEndian);
 }

 public long getLong() {
 return getLong(ix(nextGetIndex((1 << 3))));
 }

 public long getLong(int i) {
 return getLong(ix(checkIndex(i, (1 << 3))));
 }



 private ByteBuffer putLong(long a, long x) {

 if (unaligned) {
 long y = (x);
 unsafe.putLong(a, (nativeByteOrder ? y : Bits.swap(y)));
 } else {
 Bits.putLong(a, x, bigEndian);
 }
 return this;



 }

 public ByteBuffer putLong(long x) {

 putLong(ix(nextPutIndex((1 << 3))), x);
 return this;



 }

 public ByteBuffer putLong(int i, long x) {

 putLong(ix(checkIndex(i, (1 << 3))), x);
 return this;



 }

 public LongBuffer asLongBuffer() {
 int off = this.position();
 int lim = this.limit();
 assert (off <= lim);
 int rem = (off <= lim ? lim - off : 0);

 int size = rem >> 3;
 if (!unaligned && ((address + off) % (1 << 3) != 0)) {
 return (bigEndian
 ? (LongBuffer)(new ByteBufferAsLongBufferB(this,
 -1,
 0,
 size,
 size,
 off))
 : (LongBuffer)(new ByteBufferAsLongBufferL(this,
 -1,
 0,
 size,
 size,
 off)));
 } else {
 return (nativeByteOrder
 ? (LongBuffer)(new DirectLongBufferU(this,
 -1,
 0,
 size,
 size,
 off))
 : (LongBuffer)(new DirectLongBufferS(this,
 -1,
 0,
 size,
 size,
 off)));
 }
 }




 private float getFloat(long a) {
 if (unaligned) {
 int x = unsafe.getInt(a);
 return Float.intBitsToFloat(nativeByteOrder ? x : Bits.swap(x));
 }
 return Bits.getFloat(a, bigEndian);
 }

 public float getFloat() {
 return getFloat(ix(nextGetIndex((1 << 2))));
 }

 public float getFloat(int i) {
 return getFloat(ix(checkIndex(i, (1 << 2))));
 }



 private ByteBuffer putFloat(long a, float x) {

 if (unaligned) {
 int y = Float.floatToRawIntBits(x);
 unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
 } else {
 Bits.putFloat(a, x, bigEndian);
 }
 return this;



 }

 public ByteBuffer putFloat(float x) {

 putFloat(ix(nextPutIndex((1 << 2))), x);
 return this;



 }

 public ByteBuffer putFloat(int i, float x) {

 putFloat(ix(checkIndex(i, (1 << 2))), x);
 return this;



 }

 public FloatBuffer asFloatBuffer() {
 int off = this.position();
 int lim = this.limit();
 assert (off <= lim);
 int rem = (off <= lim ? lim - off : 0);

 int size = rem >> 2;
 if (!unaligned && ((address + off) % (1 << 2) != 0)) {
 return (bigEndian
 ? (FloatBuffer)(new ByteBufferAsFloatBufferB(this,
 -1,
 0,
 size,
 size,
 off))
 : (FloatBuffer)(new ByteBufferAsFloatBufferL(this,
 -1,
 0,
 size,
 size,
 off)));
 } else {
 return (nativeByteOrder
 ? (FloatBuffer)(new DirectFloatBufferU(this,
 -1,
 0,
 size,
 size,
 off))
 : (FloatBuffer)(new DirectFloatBufferS(this,
 -1,
 0,
 size,
 size,
 off)));
 }
 }




 private double getDouble(long a) {
 if (unaligned) {
 long x = unsafe.getLong(a);
 return Double.longBitsToDouble(nativeByteOrder ? x : Bits.swap(x));
 }
 return Bits.getDouble(a, bigEndian);
 }

 public double getDouble() {
 return getDouble(ix(nextGetIndex((1 << 3))));
 }

 public double getDouble(int i) {
 return getDouble(ix(checkIndex(i, (1 << 3))));
 }



 private ByteBuffer putDouble(long a, double x) {

 if (unaligned) {
 long y = Double.doubleToRawLongBits(x);
 unsafe.putLong(a, (nativeByteOrder ? y : Bits.swap(y)));
 } else {
 Bits.putDouble(a, x, bigEndian);
 }
 return this;



 }

 public ByteBuffer putDouble(double x) {

 putDouble(ix(nextPutIndex((1 << 3))), x);
 return this;



 }

 public ByteBuffer putDouble(int i, double x) {

 putDouble(ix(checkIndex(i, (1 << 3))), x);
 return this;



 }

 public DoubleBuffer asDoubleBuffer() {
 int off = this.position();
 int lim = this.limit();
 assert (off <= lim);
 int rem = (off <= lim ? lim - off : 0);

 int size = rem >> 3;
 if (!unaligned && ((address + off) % (1 << 3) != 0)) {
 return (bigEndian
 ? (DoubleBuffer)(new ByteBufferAsDoubleBufferB(this,
 -1,
 0,
 size,
 size,
 off))
 : (DoubleBuffer)(new ByteBufferAsDoubleBufferL(this,
 -1,
 0,
 size,
 size,
 off)));
 } else {
 return (nativeByteOrder
 ? (DoubleBuffer)(new DirectDoubleBufferU(this,
 -1,
 0,
 size,
 size,
 off))
 : (DoubleBuffer)(new DirectDoubleBufferS(this,
 -1,
 0,
 size,
 size,
 off)));
 }
 }

}