StringCharBuffer(CharSequence s,
    int start,
    int end) 
{
 // package-private
        super(-1, start, end, s.length());
        int n = s.length();
        if ((start <  0) || (start  > n) || (end <  start) || (end  > n))
            throw new IndexOutOfBoundsException();
        str = s;
}

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

 public final CharBuffer compact() 
{
        throw new ReadOnlyBufferException();
}

 public CharBuffer duplicate() 
{
        return new StringCharBuffer(str, markValue(),
                                    position(), limit(), capacity(), offset);
}

 public final char get() 
{
        return str.charAt(nextGetIndex() + offset);
}

 public final char get(int index) 
{
        return str.charAt(checkIndex(index) + offset);
}

 public boolean isDirect() 
{
        return false;
}

 public final boolean isReadOnly() 
{
        return true;
}

 public ByteOrder order() 
{
        return ByteOrder.nativeOrder();
}

 public final CharBuffer put(char c) 
{
        throw new ReadOnlyBufferException();
}

 public final CharBuffer put(int index,
    char c) 
{
        throw new ReadOnlyBufferException();
}

 public CharBuffer slice() 
{
        return new StringCharBuffer(str,
                                    -1,
                                    0,
                                    this.remaining(),
                                    this.remaining(),
                                    offset + this.position());
}

 public final CharBuffer subSequence(int start,
    int end) 
{
        try {
            int pos = position();
            return new StringCharBuffer(str,
                                        -1,
                                        pos + checkIndex(start, pos),
                                        pos + checkIndex(end, pos),
                                        capacity(),
                                        offset);
        } catch (IllegalArgumentException x) {
            throw new IndexOutOfBoundsException();
        }
}

 final String toString(int start,
    int end) 
{
        return str.toString().substring(start + offset, end + offset);
}