CharViewBufferImpl(ByteBuffer bb,
    int capacity) 
{
    super (capacity, capacity, 0, -1);
    this.bb = bb;
    this.offset = bb.position();
    this.readOnly = bb.isReadOnly();
    this.endian = bb.order();
    if (bb.isDirect())
      this.address = VMDirectByteBuffer.adjustAddress(bb.address, offset);
}

 public CharViewBufferImpl(ByteBuffer bb,
    int offset,
    int capacity,
    int limit,
    int position,
    int mark,
    boolean readOnly,
    ByteOrder endian) 
{
    super (capacity, limit, position, mark);
    this.bb = bb;
    this.offset = offset;
    this.readOnly = readOnly;
    this.endian = endian;
    if (bb.isDirect())
      this.address = VMDirectByteBuffer.adjustAddress(bb.address, offset);
}

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

 public CharBuffer compact() 
{
    if (position ()  > 0)
      {
        int count = limit () - position ();
	bb.shiftDown(offset, offset + 2 * position(), 2 * count);
        position (count);
        limit (capacity ());
      }
    else
      {
	position(limit());
	limit(capacity());
      }
    return this;
}

 public CharBuffer duplicate() 
{
    return duplicate(readOnly);
}

 CharBuffer duplicate(boolean readOnly) 
{
    int pos = position();
    reset();
    int mark = position();
    position(pos);
    return new CharViewBufferImpl (bb, offset, capacity(), limit(),
                                     pos, mark, readOnly, endian);
}

 public char get() 
{
    int p = position();
    char result = ByteBufferHelper.getChar(bb, (p < <  1) + offset, endian);
    position(p + 1);
    return result;
}

Reads the char at this buffer's current position, and then increments the position.

 public char get(int index) 
{
    return ByteBufferHelper.getChar(bb, (index < <  1) + offset, endian);
}

Absolute get method. Reads the char at position index.

 public boolean isDirect() 
{
    return bb.isDirect ();
}

 public boolean isReadOnly() 
{
    return readOnly;
}

 public ByteOrder order() 
{
    return endian;
}

 public CharBuffer put(char value) 
{
    int p = position();
    ByteBufferHelper.putChar(bb, (p < <  1) + offset, value, endian);
    position(p + 1);
    return this;
}

 public CharBuffer put(int index,
    char value) 
{
    ByteBufferHelper.putChar(bb, (index < <  1) + offset, value, endian);
    return this;
}

 public CharBuffer slice() 
{
    // Create a sliced copy of this object that shares its content.
    return new CharViewBufferImpl (bb, (position ()  > > 1) + offset,
				   remaining (), remaining (), 0, -1,
				   isReadOnly (), endian);
}

 public CharSequence subSequence(int start,
    int end) 
{
    if (start <  0
        || end <  start
        || end  > length ())
      throw new IndexOutOfBoundsException ();
    return new CharViewBufferImpl (bb, array_offset, capacity (),
				   position () + end, position () + start,
				   -1, isReadOnly (), endian);
}