| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.text; |
| |
| /** |
| * An implementation of {@link CharacterIterator} for strings. |
| */ |
| public final class StringCharacterIterator implements CharacterIterator { |
| |
| String string; |
| |
| int start, end, offset; |
| |
| /** |
| * Constructs a new {@code StringCharacterIterator} on the specified string. |
| * The begin and current indices are set to the beginning of the string, the |
| * end index is set to the length of the string. |
| * |
| * @param value |
| * the source string to iterate over. |
| */ |
| public StringCharacterIterator(String value) { |
| string = value; |
| start = offset = 0; |
| end = string.length(); |
| } |
| |
| /** |
| * Constructs a new {@code StringCharacterIterator} on the specified string |
| * with the current index set to the specified value. The begin index is set |
| * to the beginning of the string, the end index is set to the length of the |
| * string. |
| * |
| * @param value |
| * the source string to iterate over. |
| * @param location |
| * the current index. |
| * @throws IllegalArgumentException |
| * if {@code location} is negative or greater than the length |
| * of the source string. |
| */ |
| public StringCharacterIterator(String value, int location) { |
| string = value; |
| start = 0; |
| end = string.length(); |
| if (location < 0 || location > end) { |
| throw new IllegalArgumentException(); |
| } |
| offset = location; |
| } |
| |
| /** |
| * Constructs a new {@code StringCharacterIterator} on the specified string |
| * with the begin, end and current index set to the specified values. |
| * |
| * @param value |
| * the source string to iterate over. |
| * @param start |
| * the index of the first character to iterate. |
| * @param end |
| * the index one past the last character to iterate. |
| * @param location |
| * the current index. |
| * @throws IllegalArgumentException |
| * if {@code start < 0}, {@code start > end}, {@code location < |
| * start}, {@code location > end} or if {@code end} is greater |
| * than the length of {@code value}. |
| */ |
| public StringCharacterIterator(String value, int start, int end, int location) { |
| string = value; |
| if (start < 0 || end > string.length() || start > end |
| || location < start || location > end) { |
| throw new IllegalArgumentException(); |
| } |
| this.start = start; |
| this.end = end; |
| offset = location; |
| } |
| |
| /** |
| * Returns a new {@code StringCharacterIterator} with the same source |
| * string, begin, end, and current index as this iterator. |
| * |
| * @return a shallow copy of this iterator. |
| * @see java.lang.Cloneable |
| */ |
| @Override |
| public Object clone() { |
| try { |
| return super.clone(); |
| } catch (CloneNotSupportedException e) { |
| throw new AssertionError(e); |
| } |
| } |
| |
| /** |
| * Returns the character at the current index in the source string. |
| * |
| * @return the current character, or {@code DONE} if the current index is |
| * past the end. |
| */ |
| public char current() { |
| if (offset == end) { |
| return DONE; |
| } |
| return string.charAt(offset); |
| } |
| |
| /** |
| * Compares the specified object with this {@code StringCharacterIterator} |
| * and indicates if they are equal. In order to be equal, {@code object} |
| * must be an instance of {@code StringCharacterIterator} that iterates over |
| * the same sequence of characters with the same index. |
| * |
| * @param object |
| * the object to compare with this object. |
| * @return {@code true} if the specified object is equal to this |
| * {@code StringCharacterIterator}; {@code false} otherwise. |
| * @see #hashCode |
| */ |
| @Override |
| public boolean equals(Object object) { |
| if (!(object instanceof StringCharacterIterator)) { |
| return false; |
| } |
| StringCharacterIterator it = (StringCharacterIterator) object; |
| return string.equals(it.string) && start == it.start && end == it.end |
| && offset == it.offset; |
| } |
| |
| /** |
| * Sets the current position to the begin index and returns the character at |
| * the new position in the source string. |
| * |
| * @return the character at the begin index or {@code DONE} if the begin |
| * index is equal to the end index. |
| */ |
| public char first() { |
| if (start == end) { |
| return DONE; |
| } |
| offset = start; |
| return string.charAt(offset); |
| } |
| |
| /** |
| * Returns the begin index in the source string. |
| * |
| * @return the index of the first character of the iteration. |
| */ |
| public int getBeginIndex() { |
| return start; |
| } |
| |
| /** |
| * Returns the end index in the source string. |
| * |
| * @return the index one past the last character of the iteration. |
| */ |
| public int getEndIndex() { |
| return end; |
| } |
| |
| /** |
| * Returns the current index in the source string. |
| * |
| * @return the current index. |
| */ |
| public int getIndex() { |
| return offset; |
| } |
| |
| @Override |
| public int hashCode() { |
| return string.hashCode() + start + end + offset; |
| } |
| |
| /** |
| * Sets the current position to the end index - 1 and returns the character |
| * at the new position. |
| * |
| * @return the character before the end index or {@code DONE} if the begin |
| * index is equal to the end index. |
| */ |
| public char last() { |
| if (start == end) { |
| return DONE; |
| } |
| offset = end - 1; |
| return string.charAt(offset); |
| } |
| |
| /** |
| * Increments the current index and returns the character at the new index. |
| * |
| * @return the character at the next index, or {@code DONE} if the next |
| * index would be past the end. |
| */ |
| public char next() { |
| if (offset >= (end - 1)) { |
| offset = end; |
| return DONE; |
| } |
| return string.charAt(++offset); |
| } |
| |
| /** |
| * Decrements the current index and returns the character at the new index. |
| * |
| * @return the character at the previous index, or {@code DONE} if the |
| * previous index would be past the beginning. |
| */ |
| public char previous() { |
| if (offset == start) { |
| return DONE; |
| } |
| return string.charAt(--offset); |
| } |
| |
| /** |
| * Sets the current index in the source string. |
| * |
| * @param location |
| * the index the current position is set to. |
| * @return the character at the new index, or {@code DONE} if |
| * {@code location} is set to the end index. |
| * @throws IllegalArgumentException |
| * if {@code location} is smaller than the begin index or greater |
| * than the end index. |
| */ |
| public char setIndex(int location) { |
| if (location < start || location > end) { |
| throw new IllegalArgumentException(); |
| } |
| offset = location; |
| if (offset == end) { |
| return DONE; |
| } |
| return string.charAt(offset); |
| } |
| |
| /** |
| * Sets the source string to iterate over. The begin and end positions are |
| * set to the start and end of this string. |
| * |
| * @param value |
| * the new source string. |
| */ |
| public void setText(String value) { |
| string = value; |
| start = offset = 0; |
| end = value.length(); |
| } |
| } |