gomp-20050608-branch/libjava/classpath/java/text/StringCharacterIterator.java

   1 /* StringCharacterIterator.java -- Iterate over a character range in a string
   2    Copyright (C) 1998, 1999, 2001, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.text;
  40
  41 /**
  42  * This class iterates over a range of characters in a <code>String</code>.
  43  * For a given range of text, a beginning and ending index,
  44  * as well as a current index are defined.  These values can be queried
  45  * by the methods in this interface.  Additionally, various methods allow
  46  * the index to be set.
  47  *
  48  * @author Aaron M. Renn (arenn@urbanophile.com)
  49  * @author Tom Tromey (tromey@cygnus.com)
  50  */
  51 public final class StringCharacterIterator implements CharacterIterator
  52 {
  53   /**
  54    * This is the string to iterate over
  55    */
  56   private String text;
  57
  58   /**
  59    * This is the value of the start position of the text range.
  60    */
  61   private int begin;
  62
  63   /**
  64    * This is the value of the ending position of the text range.
  65    */
  66   private int end;
  67
  68   /**
  69    * This is the current value of the scan index.
  70    */
  71   private int index;
  72
  73   /**
  74    * This method initializes a new instance of
  75    * <code>StringCharacterIterator</code> to iterate over the entire
  76    * text of the specified <code>String</code>.  The initial index
  77    * value will be set to the first character in the string.
  78    *
  79    * @param text The <code>String</code> to iterate through (<code>null</code>
  80    *             not permitted).
  81    *
  82    * @throws NullPointerException if <code>text</code> is <code>null</code>.
  83    */
  84   public StringCharacterIterator (String text)
  85   {
  86     this (text, 0, text.length (), 0);
  87   }
  88
  89   /*************************************************************************/
  90
  91   /**
  92    * This method initializes a new instance of
  93    * <code>StringCharacterIterator</code> to iterate over the entire
  94    * text of the specified <code>String</code>.  The initial index
  95    * value will be set to the specified value.
  96    *
  97    * @param text The <code>String</code> to iterate through.
  98    * @param index The initial index position.
  99    */
 100   public StringCharacterIterator (String text, int index)
 101   {
 102     this (text, 0, text.length (), index);
 103   }
 104
 105   /*************************************************************************/
 106
 107   /**
 108    * This method initializes a new instance of
 109    * <code>StringCharacterIterator</code> that iterates over the text
 110    * in a subrange of the specified <code>String</code>.  The
 111    * beginning and end of the range are specified by the caller, as is
 112    * the initial index position.
 113    *
 114    * @param text The <code>String</code> to iterate through.
 115    * @param begin The beginning position in the character range.
 116    * @param end The ending position in the character range.
 117    * @param index The initial index position.
 118    *
 119    * @throws IllegalArgumentException If any of the range values are
 120    * invalid.
 121    */
 122   public StringCharacterIterator (String text, int begin, int end, int index)
 123   {
 124     int len = text.length ();
 125
 126     if ((begin < 0) || (begin > len))
 127       throw new IllegalArgumentException ("Bad begin position");
 128
 129     if ((end < begin) || (end > len))
 130       throw new IllegalArgumentException ("Bad end position");
 131
 132     if ((index < begin) || (index > end))
 133       throw new IllegalArgumentException ("Bad initial index position");
 134
 135     this.text = text;
 136     this.begin = begin;
 137     this.end = end;
 138     this.index = index;
 139   }
 140
 141   /**
 142    * This is a package level constructor that copies the text out of
 143    * an existing StringCharacterIterator and resets the beginning and
 144    * ending index.
 145    *
 146    * @param sci The StringCharacterIterator to copy the info from
 147    * @param begin The beginning index of the range we are interested in.
 148    * @param end The ending index of the range we are interested in.
 149    */
 150   StringCharacterIterator (StringCharacterIterator sci, int begin, int end)
 151   {
 152     this (sci.text, begin, end, begin);
 153   }
 154
 155   /**
 156    * This method returns the character at the current index position
 157    *
 158    * @return The character at the current index position.
 159    */
 160   public char current ()
 161   {
 162     return (index < end) ? text.charAt (index) : DONE;
 163   }
 164
 165   /*************************************************************************/
 166
 167   /**
 168    * This method increments the current index and then returns the
 169    * character at the new index value.  If the index is already at
 170    * <code>getEndIndex () - 1</code>, it will not be incremented.
 171    *
 172    * @return The character at the position of the incremented index
 173    * value, or <code>DONE</code> if the index has reached
 174    * getEndIndex () - 1.
 175    */
 176   public char next ()
 177   {
 178     if (index == end)
 179       return DONE;
 180
 181     ++index;
 182     return current ();
 183   }
 184
 185   /*************************************************************************/
 186
 187   /**
 188    * This method decrements the current index and then returns the
 189    * character at the new index value.  If the index value is already
 190    * at the beginning index, it will not be decremented.
 191    *
 192    * @return The character at the position of the decremented index
 193    * value, or <code>DONE</code> if index was already equal to the
 194    * beginning index value.
 195    */
 196   public char previous ()
 197   {
 198     if (index == begin)
 199       return DONE;
 200
 201     --index;
 202     return current ();
 203   }
 204
 205   /*************************************************************************/
 206
 207   /**
 208    * This method sets the index value to the beginning of the range and returns
 209    * the character there.
 210    *
 211    * @return The character at the beginning of the range, or
 212    * <code>DONE</code> if the range is empty.
 213    */
 214   public char first ()
 215   {
 216     index = begin;
 217     return current ();
 218   }
 219
 220   /*************************************************************************/
 221
 222   /**
 223    * This method sets the index value to <code>getEndIndex () - 1</code> and
 224    * returns the character there.  If the range is empty, then the index value
 225    * will be set equal to the beginning index.
 226    *
 227    * @return The character at the end of the range, or
 228    * <code>DONE</code> if the range is empty.
 229    */
 230   public char last ()
 231   {
 232     if (end == begin)
 233       return DONE;
 234
 235     index = end - 1;
 236     return current ();
 237   }
 238
 239   /*************************************************************************/
 240
 241   /**
 242    * This method returns the current value of the index.
 243    *
 244    * @return The current index value
 245    */
 246   public int getIndex ()
 247   {
 248     return index;
 249   }
 250
 251   /*************************************************************************/
 252
 253   /**
 254    * This method sets the value of the index to the specified value, then
 255    * returns the character at that position.
 256    *
 257    * @param index The new index value.
 258    *
 259    * @return The character at the new index value or <code>DONE</code>
 260    * if the index value is equal to <code>getEndIndex</code>.
 261    *
 262    * @exception IllegalArgumentException If the specified index is not valid
 263    */
 264   public char setIndex (int index)
 265   {
 266     if ((index < begin) || (index > end))
 267       throw new IllegalArgumentException ("Bad index specified");
 268
 269     this.index = index;
 270     return current ();
 271   }
 272
 273   /*************************************************************************/
 274
 275   /**
 276    * This method returns the character position of the first character in the
 277    * range.
 278    *
 279    * @return The index of the first character in the range.
 280    */
 281   public int getBeginIndex ()
 282   {
 283     return begin;
 284   }
 285
 286   /*************************************************************************/
 287
 288   /**
 289    * This method returns the character position of the end of the text range.
 290    * This will actually be the index of the first character following the
 291    * end of the range.  In the event the text range is empty, this will be
 292    * equal to the first character in the range.
 293    *
 294    * @return The index of the end of the range.
 295    */
 296   public int getEndIndex ()
 297   {
 298     return end;
 299   }
 300
 301   /*************************************************************************/
 302
 303   /**
 304    * This method creates a copy of this <code>CharacterIterator</code>.
 305    *
 306    * @return A copy of this <code>CharacterIterator</code>.
 307    */
 308   public Object clone ()
 309   {
 310     return new StringCharacterIterator (text, begin, end, index);
 311   }
 312
 313   /*************************************************************************/
 314
 315   /**
 316    * This method tests this object for equality againt the specified
 317    * object.  This will be true if and only if the specified object:
 318    * <p>
 319    * <ul>
 320    * <li>is not <code>null</code>.</li>
 321    * <li>is an instance of <code>StringCharacterIterator</code></li>
 322    * <li>has the same text as this object</li>
 323    * <li>has the same beginning, ending, and current index as this object.</li>
 324    * </ul>
 325    *
 326    * @param obj The object to test for equality against.
 327    *
 328    * @return <code>true</code> if the specified object is equal to this
 329    * object, <code>false</code> otherwise.
 330    */
 331   public boolean equals (Object obj)
 332   {
 333     if (! (obj instanceof StringCharacterIterator))
 334       return false;
 335
 336     StringCharacterIterator sci = (StringCharacterIterator) obj;
 337
 338     return (begin == sci.begin
 339             && end == sci.end
 340             && index == sci.index
 341             && text.equals (sci.text));
 342   }
 343
 344   /**
 345    * Return the hash code for this object.
 346    * @return the hash code
 347    */
 348   public int hashCode()
 349   {
 350     // Incorporate all the data in a goofy way.
 351     return begin ^ end ^ index ^ text.hashCode();
 352   }
 353
 354   /*************************************************************************/
 355
 356   /**
 357    * This method allows other classes in java.text to change the value
 358    * of the underlying text being iterated through.
 359    *
 360    * @param text The new <code>String</code> to iterate through.
 361    */
 362   public void setText (String text)
 363   {
 364     this.text = text;
 365     this.begin = 0;
 366     this.end = text.length ();
 367     this.index = 0;
 368   }
 369 }