Back to index...

	/*
	* Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.nio;


	// ## If the sequence is a string, use reflection to share its array

	class StringCharBuffer // package-private
	extends CharBuffer
	{
	CharSequence str;

	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;
	this.isReadOnly = true;
	}

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

	private StringCharBuffer(CharSequence s,
	int mark,
	int pos,
	int limit,
	int cap,
	int offset) {
	super(mark, pos, limit, cap, null, offset);
	str = s;
	this.isReadOnly = true;
	}

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

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

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

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

	char getUnchecked(int index) {
	return str.charAt(index + offset);
	}

	// ## Override bulk get methods for better performance

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

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

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

	public final boolean isReadOnly() {
	return true;
	}

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

	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();
	}
	}

	public boolean isDirect() {
	return false;
	}

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

	ByteOrder charRegionOrder() {
	return null;
	}

	public boolean equals(Object ob) {
	if (this == ob)
	return true;
	if (!(ob instanceof CharBuffer))
	return false;
	CharBuffer that = (CharBuffer)ob;
	if (this.remaining() != that.remaining())
	return false;
	return BufferMismatch.mismatch(this, this.position(),
	that, that.position(),
	this.remaining()) < 0;
	}

	public int compareTo(CharBuffer that) {
	int i = BufferMismatch.mismatch(this, this.position(),
	that, that.position(),
	Math.min(this.remaining(), that.remaining()));
	if (i >= 0) {
	return Character.compare(this.get(this.position() + i), that.get(that.position() + i));
	}
	return this.remaining() - that.remaining();
	}
	}

Back to index...