content: /*
   * Copyright (c) 1996, 2013, 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.
   */
  
  /*
   * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
   * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
   *
   * The original version of this source code and documentation
   * is copyrighted and owned by Taligent, Inc., a wholly-owned
   * subsidiary of IBM. These materials are provided under terms
   * of a License Agreement between Taligent and Sun. This technology
   * is protected by multiple US and International patents.
   *
   * This notice and attribution to Taligent may not be removed.
   * Taligent is a registered trademark of Taligent, Inc.
   *
   */
  
  package java.text;
  
  /**
   * <code>StringCharacterIterator</code> implements the
   * <code>CharacterIterator</code> protocol for a <code>String</code>.
   * The <code>StringCharacterIterator</code> class iterates over the
   * entire <code>String</code>.
   *
   * @see CharacterIterator
   */
  
  public final class StringCharacterIterator implements CharacterIterator
  {
      private String text;
      private int begin;
      private int end;
      // invariant: begin <= pos <= end
      private int pos;
  
      /**
       * Constructs an iterator with an initial index of 0.
       *
       * @param text the {@code String} to be iterated over
       */
      public StringCharacterIterator(String text)
      {
          this(text, 0);
      }
  
      /**
       * Constructs an iterator with the specified initial index.
       *
       * @param  text   The String to be iterated over
       * @param  pos    Initial iterator position
       */
      public StringCharacterIterator(String text, int pos)
      {
      this(text, 0, text.length(), pos);
      }
  
      /**
       * Constructs an iterator over the given range of the given string, with the
       * index set at the specified position.
       *
       * @param  text   The String to be iterated over
       * @param  begin  Index of the first character
       * @param  end    Index of the character following the last character
       * @param  pos    Initial iterator position
       */
      public StringCharacterIterator(String text, int begin, int end, int pos) {
          if (text == null)
              throw new NullPointerException();
          this.text = text;
  
          if (begin < 0 || begin > end || end > text.length())
              throw new IllegalArgumentException("Invalid substring range");
  
          if (pos < begin || pos > end)
              throw new IllegalArgumentException("Invalid position");
  
          this.begin = begin;
          this.end = end;
          this.pos = pos;
      }
  
      /**
       * Reset this iterator to point to a new string.  This package-visible
       * method is used by other java.text classes that want to avoid allocating
       * new StringCharacterIterator objects every time their setText method
       * is called.
       *
       * @param  text   The String to be iterated over
       * @since 1.2
       */
      public void setText(String text) {
          if (text == null)
              throw new NullPointerException();
          this.text = text;
          this.begin = 0;
          this.end = text.length();
          this.pos = 0;
      }
  
      /**
       * Implements CharacterIterator.first() for String.
       * @see CharacterIterator#first
       */
      public char first()
      {
          pos = begin;
          return current();
      }
  
      /**
       * Implements CharacterIterator.last() for String.
       * @see CharacterIterator#last
       */
      public char last()
      {
          if (end != begin) {
              pos = end - 1;
          } else {
              pos = end;
          }
          return current();
       }
  
      /**
       * Implements CharacterIterator.setIndex() for String.
       * @see CharacterIterator#setIndex
       */
      public char setIndex(int p)
      {
      if (p < begin || p > end)
              throw new IllegalArgumentException("Invalid index");
          pos = p;
          return current();
      }
  
      /**
       * Implements CharacterIterator.current() for String.
       * @see CharacterIterator#current
       */
      public char current()
      {
          if (pos >= begin && pos < end) {
              return text.charAt(pos);
          }
          else {
              return DONE;
          }
      }
  
      /**
       * Implements CharacterIterator.next() for String.
       * @see CharacterIterator#next
       */
      public char next()
      {
          if (pos < end - 1) {
              pos++;
              return text.charAt(pos);
          }
          else {
              pos = end;
              return DONE;
          }
      }
  
      /**
       * Implements CharacterIterator.previous() for String.
       * @see CharacterIterator#previous
       */
      public char previous()
      {
          if (pos > begin) {
              pos--;
              return text.charAt(pos);
          }
          else {
              return DONE;
          }
      }
  
      /**
       * Implements CharacterIterator.getBeginIndex() for String.
       * @see CharacterIterator#getBeginIndex
       */
      public int getBeginIndex()
      {
          return begin;
      }
  
      /**
       * Implements CharacterIterator.getEndIndex() for String.
       * @see CharacterIterator#getEndIndex
       */
      public int getEndIndex()
      {
          return end;
      }
  
      /**
       * Implements CharacterIterator.getIndex() for String.
       * @see CharacterIterator#getIndex
       */
      public int getIndex()
      {
          return pos;
      }
  
      /**
       * Compares the equality of two StringCharacterIterator objects.
       * @param obj the StringCharacterIterator object to be compared with.
       * @return true if the given obj is the same as this
       * StringCharacterIterator object; false otherwise.
       */
      public boolean equals(Object obj)
      {
          if (this == obj)
              return true;
          if (!(obj instanceof StringCharacterIterator))
              return false;
  
          StringCharacterIterator that = (StringCharacterIterator) obj;
  
          if (hashCode() != that.hashCode())
              return false;
          if (!text.equals(that.text))
              return false;
          if (pos != that.pos || begin != that.begin || end != that.end)
              return false;
          return true;
      }
  
      /**
       * Computes a hashcode for this iterator.
       * @return A hash code
       */
      public int hashCode()
      {
          return text.hashCode() ^ pos ^ begin ^ end;
      }
  
      /**
       * Creates a copy of this iterator.
       * @return A copy of this
       */
      public Object clone()
      {
          try {
              StringCharacterIterator other
              = (StringCharacterIterator) super.clone();
              return other;
          }
          catch (CloneNotSupportedException e) {
              throw new InternalError(e);
          }
      }
  
  }
  