public MappedByteBufferImpl(Pointer address,
    int size,
    boolean readOnly) throws IOException 
{
    super(size, size, 0, -1);
    this.address = address;
    this.readOnly = readOnly;
}

 public CharBuffer asCharBuffer() 
{
    return new CharViewBufferImpl(this, remaining()  > > 1);
}

 public DoubleBuffer asDoubleBuffer() 
{
    return new DoubleViewBufferImpl(this, remaining()  > > 3);
}

 public FloatBuffer asFloatBuffer() 
{
    return new FloatViewBufferImpl(this, remaining()  > > 2);
}

 public IntBuffer asIntBuffer() 
{
    return new IntViewBufferImpl(this, remaining()  > > 2);
}

 public LongBuffer asLongBuffer() 
{
    return new LongViewBufferImpl(this, remaining()  > > 3);
}

 public ByteBuffer asReadOnlyBuffer() 
{
    return duplicate(true);
}

 public ShortBuffer asShortBuffer() 
{
    return new ShortViewBufferImpl(this, remaining()  > > 1);
}

 public ByteBuffer compact() 
{
    checkIfReadOnly();
    mark = -1;
    int pos = position();
    if (pos  > 0)
      {
	int count = remaining();
	// Call shiftDown method optimized for direct buffers.
	VMDirectByteBuffer.shiftDown(address, 0, pos, count);
	position(count);
	limit(capacity());
      }
    else
      {
	position(limit());
	limit(capacity());
      }
    return this;
}

 public ByteBuffer duplicate() 
{
    return duplicate(isReadOnly());
}

 native  void forceImpl()

 public byte get() 
{
    checkForUnderflow();
    int pos = position();
    byte result = VMDirectByteBuffer.get(address, pos);
    position(pos + 1);
    return result;
}

 public byte get(int index) 
{
    checkIndex(index);
    return VMDirectByteBuffer.get(address, index);
}

 public ByteBuffer get(byte[] dst,
    int offset,
    int length) 
{
    checkArraySize(dst.length, offset, length);
    checkForUnderflow(length);
    int index = position();
    VMDirectByteBuffer.get(address, index, dst, offset, length);
    position(index+length);
    return this;
}

 public char getChar() 
{
    return ByteBufferHelper.getChar(this, order());
}

 public char getChar(int index) 
{
    return ByteBufferHelper.getChar(this, index, order());
}

 public double getDouble() 
{
    return ByteBufferHelper.getDouble(this, order());
}

 public double getDouble(int index) 
{
    return ByteBufferHelper.getDouble(this, index, order());
}

 public float getFloat() 
{
    return ByteBufferHelper.getFloat(this, order());
}

 public float getFloat(int index) 
{
    return ByteBufferHelper.getFloat(this, index, order());
}

 public int getInt() 
{
    return ByteBufferHelper.getInt(this, order());
}

 public int getInt(int index) 
{
    return ByteBufferHelper.getInt(this, index, order());
}

 public long getLong() 
{
    return ByteBufferHelper.getLong(this, order());
}

 public long getLong(int index) 
{
    return ByteBufferHelper.getLong(this, index, order());
}

 public short getShort() 
{
    return ByteBufferHelper.getShort(this, order());
}

 public short getShort(int index) 
{
    return ByteBufferHelper.getShort(this, index, order());
}

 public boolean isDirect() 
{
    return true;
}

 native boolean isLoadedImpl()

 public boolean isReadOnly() 
{
    return readOnly;
}

 native  void loadImpl()

 public ByteBuffer put(byte value) 
{
    checkIfReadOnly();
    checkForOverflow();
    int pos = position();
    VMDirectByteBuffer.put(address, pos, value);
    position(pos + 1);
    return this;
}

 public ByteBuffer put(int index,
    byte value) 
{
    checkIfReadOnly();
    checkIndex(index);
    VMDirectByteBuffer.put(address, index, value);
    return this;
}

 public ByteBuffer putChar(char value) 
{
    ByteBufferHelper.putChar(this, value, order());
    return this;
}

 public ByteBuffer putChar(int index,
    char value) 
{
    ByteBufferHelper.putChar(this, index, value, order());
    return this;
}

 public ByteBuffer putDouble(double value) 
{
    ByteBufferHelper.putDouble(this, value, order());
    return this;
}

 public ByteBuffer putDouble(int index,
    double value) 
{
    ByteBufferHelper.putDouble(this, index, value, order());
    return this;
}

 public ByteBuffer putFloat(float value) 
{
    ByteBufferHelper.putFloat(this, value, order());
    return this;
}

 public ByteBuffer putFloat(int index,
    float value) 
{
    ByteBufferHelper.putFloat(this, index, value, order());
    return this;
}

 public ByteBuffer putInt(int value) 
{
    ByteBufferHelper.putInt(this, value, order());
    return this;
}

 public ByteBuffer putInt(int index,
    int value) 
{
    ByteBufferHelper.putInt(this, index, value, order());
    return this;
}

 public ByteBuffer putLong(long value) 
{
    ByteBufferHelper.putLong(this, value, order());
    return this;
}

 public ByteBuffer putLong(int index,
    long value) 
{
    ByteBufferHelper.putLong(this, index, value, order());
    return this;
}

 public ByteBuffer putShort(short value) 
{
    ByteBufferHelper.putShort(this, value, order());
    return this;
}

 public ByteBuffer putShort(int index,
    short value) 
{
    ByteBufferHelper.putShort(this, index, value, order());
    return this;
}

 public ByteBuffer slice() 
{
    int rem = remaining();
    if (isReadOnly())
        return new DirectByteBufferImpl.ReadOnly
      (this, VMDirectByteBuffer.adjustAddress(address, position()),
       rem, rem, 0);
    else
        return new DirectByteBufferImpl.ReadWrite
      (this, VMDirectByteBuffer.adjustAddress(address, position()),
       rem, rem, 0);
}

 native  void unmapImpl()