Segment.java

/*
 * Copyright (c) 1997, 2020, 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.
 */
packagejavax.swing.text;

importjava.text.CharacterIterator;

/**
 * A segment of a character array representing a fragment
 * of text. It should be treated as immutable even though
 * the array is directly accessible. This gives fast access
 * to fragments of text without the overhead of copying
 * around characters. This is effectively an unprotected
 * String.
 * <p>
 * The Segment implements the java.text.CharacterIterator
 * interface to support use with the i18n support without
 * copying text into a string.
 *
 * @author Timothy Prinzing
 */
publicclassSegmentimplementsCloneable, CharacterIterator, CharSequence {

/**
 * This is the array containing the text of
 * interest. This array should never be modified;
 * it is available only for efficiency.
 */
publicchar[] array;

/**
 * This is the offset into the array that
 * the desired text begins.
 */
publicintoffset;

/**
 * This is the number of array elements that
 * make up the text of interest.
 */
publicintcount;

/**
 * Whether the array is a copy of data or not.
 */
booleancopy;

privatebooleanpartialReturn;

/**
 * Creates a new segment.
 */
publicSegment() {
this(null, 0, 0);
 }

/**
 * Creates a new segment referring to an existing array.
 *
 * @param array the array to refer to
 * @param offset the offset into the array
 * @param count the number of characters
 */
publicSegment(char[] array, intoffset, intcount) {
this.array = array;
this.offset = offset;
this.count = count;
partialReturn = false;
 }

/**
 * Flag to indicate that partial returns are valid. If the flag is true,
 * an implementation of the interface method Document.getText(position,length,Segment)
 * should return as much text as possible without making a copy. The default
 * state of the flag is false which will cause Document.getText(position,length,Segment)
 * to provide the same return behavior it always had, which may or may not
 * make a copy of the text depending upon the request.
 *
 * @param p whether or not partial returns are valid.
 * @since 1.4
 */
publicvoidsetPartialReturn(booleanp) {
partialReturn = p;
 }

/**
 * Flag to indicate that partial returns are valid.
 *
 * @return whether or not partial returns are valid.
 * @since 1.4
 */
publicbooleanisPartialReturn() {
returnpartialReturn;
 }

/**
 * Converts a segment into a String.
 *
 * @return the string
 */
publicStringtoString() {
if (array != null) {
returnnewString(array, offset, count);
 }
return"";
 }

// --- CharacterIterator methods -------------------------------------

/**
 * Sets the position to getBeginIndex() and returns the character at that
 * position.
 * @return the first character in the text, or DONE if the text is empty
 * @see #getBeginIndex
 * @since 1.3
 */
publiccharfirst() {
pos = offset;
if (count != 0) {
returnarray[pos];
 }
returnDONE;
 }

/**
 * Sets the position to getEndIndex()-1 (getEndIndex() if the text is empty)
 * and returns the character at that position.
 * @return the last character in the text, or DONE if the text is empty
 * @see #getEndIndex
 * @since 1.3
 */
publiccharlast() {
pos = offset + count;
if (count != 0) {
pos -= 1;
returnarray[pos];
 }
returnDONE;
 }

/**
 * Gets the character at the current position (as returned by getIndex()).
 * @return the character at the current position or DONE if the current
 * position is off the end of the text.
 * @see #getIndex
 * @since 1.3
 */
publiccharcurrent() {
if (count != 0 && pos < offset + count) {
returnarray[pos];
 }
returnDONE;
 }

/**
 * Increments the iterator's index by one and returns the character
 * at the new index. If the resulting index is greater or equal
 * to getEndIndex(), the current index is reset to getEndIndex() and
 * a value of DONE is returned.
 * @return the character at the new position or DONE if the new
 * position is off the end of the text range.
 * @since 1.3
 */
publiccharnext() {
pos += 1;
intend = offset + count;
if (pos >= end) {
pos = end;
returnDONE;
 }
returncurrent();
 }

/**
 * Decrements the iterator's index by one and returns the character
 * at the new index. If the current index is getBeginIndex(), the index
 * remains at getBeginIndex() and a value of DONE is returned.
 * @return the character at the new position or DONE if the current
 * position is equal to getBeginIndex().
 * @since 1.3
 */
publiccharprevious() {
if (pos == offset) {
returnDONE;
 }
pos -= 1;
returncurrent();
 }

/**
 * Sets the position to the specified position in the text and returns that
 * character.
 * @param position the position within the text. Valid values range from
 * getBeginIndex() to getEndIndex(). An IllegalArgumentException is thrown
 * if an invalid value is supplied.
 * @return the character at the specified position or DONE if the specified position is equal to getEndIndex()
 * @since 1.3
 */
publiccharsetIndex(intposition) {
intend = offset + count;
if ((position < offset) || (position > end)) {
thrownewIllegalArgumentException("bad position: " + position);
 }
pos = position;
if ((pos != end) && (count != 0)) {
returnarray[pos];
 }
returnDONE;
 }

/**
 * Returns the start index of the text.
 * @return the index at which the text begins.
 * @since 1.3
 */
publicintgetBeginIndex() {
returnoffset;
 }

/**
 * Returns the end index of the text. This index is the index of the first
 * character following the end of the text.
 * @return the index after the last character in the text
 * @since 1.3
 */
publicintgetEndIndex() {
returnoffset + count;
 }

/**
 * Returns the current index.
 * @return the current index.
 * @since 1.3
 */
publicintgetIndex() {
returnpos;
 }

// --- CharSequence methods -------------------------------------

/**
 * {@inheritDoc}
 * @since 1.6
 */
publiccharcharAt(intindex) {
if (index < 0
 || index >= count) {
thrownewStringIndexOutOfBoundsException(index);
 }
returnarray[offset + index];
 }

/**
 * {@inheritDoc}
 * @since 1.6
 */
publicintlength() {
returncount;
 }

/**
 * {@inheritDoc}
 * @since 1.6
 */
publicCharSequencesubSequence(intstart, intend) {
if (start < 0) {
thrownewStringIndexOutOfBoundsException(start);
 }
if (end > count) {
thrownewStringIndexOutOfBoundsException(end);
 }
if (start > end) {
thrownewStringIndexOutOfBoundsException(end - start);
 }
Segmentsegment = newSegment();
segment.array = this.array;
segment.offset = this.offset + start;
segment.count = end - start;
returnsegment;
 }

/**
 * Creates a shallow copy.
 *
 * @return the copy
 */
publicObjectclone() {
Objecto;
try {
o = super.clone();
 } catch (CloneNotSupportedExceptioncnse) {
o = null;
 }
returno;
 }

privateintpos;


}