libjava/java/text/AttributedStringIterator.java

   1 /* AttributedStringIterator.java -- Class to iterate over AttributedString
   2    Copyright (C) 1998, 1999, 2004 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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.Iterator;
  44 import java.util.Map;
  45 import java.util.Set;
  46
  47 /**
  48   * This class implements the AttributedCharacterIterator interface.  It
  49   * is used by AttributedString.getIterator().
  50   *
  51   * @version 0.0
  52   *
  53   * @author Aaron M. Renn (arenn@urbanophile.com)
  54   */
  55 class AttributedStringIterator implements AttributedCharacterIterator
  56 {
  57
  58 /*************************************************************************/
  59
  60 /**
  61   * Instance Variables
  62   */
  63
  64 /**
  65   * The character iterator containing the text
  66   */
  67 private CharacterIterator ci;
  68
  69 /**
  70   * The list of attributes and ranges
  71   */
  72 private AttributedString.AttributeRange[] attribs;
  73
  74 /**
  75   * The list of attributes that the user is interested in.  We may,
  76   * at our option, not return any other attributes.
  77   */
  78 private AttributedCharacterIterator.Attribute[] restricts;
  79
  80 /*************************************************************************/
  81
  82 /*
  83  * Constructors
  84  */
  85
  86 AttributedStringIterator(StringCharacterIterator sci,
  87                          AttributedString.AttributeRange[] attribs,
  88                          int begin_index, int end_index,
  89                          AttributedCharacterIterator.Attribute[] restricts)
  90 {
  91   this.ci = new StringCharacterIterator(sci, begin_index, end_index);
  92   this.attribs = attribs;
  93   this.restricts = restricts;
  94 }
  95
  96 /*************************************************************************/
  97
  98 /*
  99  * Instance Methods
 100  */
 101
 102 // First we have a bunch of stupid redirects.  If StringCharacterIterator
 103 // weren't final, I just would have extended that for this class.  Alas, no.
 104
 105 public Object
 106 clone()
 107 {
 108   return(ci.clone());
 109 }
 110
 111 public char
 112 current()
 113 {
 114   return(ci.current());
 115 }
 116
 117 public char
 118 next()
 119 {
 120   return(ci.next());
 121 }
 122
 123 public char
 124 previous()
 125 {
 126   return(ci.previous());
 127 }
 128
 129 public char
 130 first()
 131 {
 132   return(ci.first());
 133 }
 134
 135 public char
 136 last()
 137 {
 138   return(ci.last());
 139 }
 140
 141 public int
 142 getIndex()
 143 {
 144   return(ci.getIndex());
 145 }
 146
 147 public char
 148 setIndex(int index)
 149 {
 150   return(ci.setIndex(index));
 151 }
 152
 153 public int
 154 getBeginIndex()
 155 {
 156   return(ci.getBeginIndex());
 157 }
 158
 159 public int
 160 getEndIndex()
 161 {
 162   return(ci.getEndIndex());
 163 }
 164
 165 /*
 166  * Here is where the AttributedCharacterIterator methods start.
 167  */
 168
 169 /*************************************************************************/
 170
 171 /**
 172   * Returns a list of all the attribute keys that are defined anywhere
 173   * on this string.
 174   */
 175 public Set
 176 getAllAttributeKeys()
 177 {
 178   HashSet s = new HashSet();
 179   if (attribs == null)
 180     return(s);
 181
 182     for (int i = 0; i < attribs.length; i++)
 183     {
 184       if (attribs[i].begin_index > getEndIndex()
 185           || attribs[i].end_index <= getBeginIndex())
 186         continue;
 187
 188       Set key_set = attribs[i].attribs.keySet();
 189       Iterator iter = key_set.iterator();
 190       while (iter.hasNext())
 191         {
 192           s.add(iter.next());
 193         }
 194     }
 195
 196   return(s);
 197 }
 198
 199 /*************************************************************************/
 200
 201 /**
 202   * Various methods that determine how far the run extends for various
 203   * attribute combinations.
 204   */
 205
 206 public int
 207 getRunLimit()
 208 {
 209   return(getRunLimit(getAttributes().keySet()));
 210 }
 211
 212 public int
 213 getRunLimit(AttributedCharacterIterator.Attribute attrib)
 214 {
 215   HashSet s = new HashSet();
 216   s.add(attrib);
 217
 218   return(getRunLimit(s));
 219 }
 220
 221 public synchronized int
 222 getRunLimit(Set attribute_set)
 223 {
 224   boolean hit = false;
 225   int runLimit = ci.getEndIndex ();
 226   int pos = ci.getIndex ();
 227
 228   for (int i = 0; i < attribs.length; ++i)
 229     {
 230       if (pos >= attribs[i].begin_index &&
 231           pos <= attribs[i].end_index)
 232         {
 233           Iterator iter = attribute_set.iterator();
 234           while(iter.hasNext())
 235             if (attribs[i].attribs.containsKey(iter.next()))
 236               {
 237                 hit = true;
 238                 runLimit = Math.min(runLimit, attribs[i].end_index);
 239               }
 240         }
 241     }
 242   if (hit)
 243     return runLimit;
 244   else
 245     return -1;
 246 }
 247
 248 /*************************************************************************/
 249
 250 /**
 251   * Various methods that determine where the run begins for various
 252   * attribute combinations.
 253   */
 254
 255 public int
 256 getRunStart()
 257 {
 258   return(getRunStart(getAttributes().keySet()));
 259 }
 260
 261 public int
 262 getRunStart(AttributedCharacterIterator.Attribute attrib)
 263 {
 264   HashSet s = new HashSet();
 265   s.add(attrib);
 266
 267   return(getRunStart(s));
 268 }
 269
 270 public int
 271 getRunStart(Set attribute_set)
 272 {
 273   boolean hit = false;
 274   int runBegin = 0;
 275   int pos = ci.getIndex ();
 276
 277   for (int i = 0; i < attribs.length; ++i)
 278     {
 279       if (pos >= attribs[i].begin_index &&
 280           pos <= attribs[i].end_index)
 281         {
 282           Iterator iter = attribute_set.iterator();
 283           while(iter.hasNext())
 284             if (attribs[i].attribs.containsKey(iter.next()))
 285               {
 286                 hit = true;
 287                 runBegin = Math.max(runBegin, attribs[i].begin_index);
 288               }
 289         }
 290     }
 291   if (hit)
 292     return runBegin;
 293   else
 294     return -1;
 295 }
 296
 297 /*************************************************************************/
 298
 299 public Object
 300 getAttribute(AttributedCharacterIterator.Attribute attrib)
 301 {
 302   if (attribs == null)
 303     return(null);
 304
 305   for (int i = 0; i < attribs.length; i++)
 306     {
 307       Set key_set = attribs[i].attribs.keySet();
 308       Iterator iter = key_set.iterator();
 309       while (iter.hasNext())
 310         {
 311           Object obj = iter.next();
 312
 313           // Check for attribute match and range match
 314           if (obj.equals(attrib))
 315             if ((ci.getIndex() >= attribs[i].begin_index) &&
 316                 (ci.getIndex() < attribs[i].end_index))
 317               return(attribs[i].attribs.get(obj));
 318         }
 319     }
 320
 321   return(null);
 322 }
 323
 324 /*************************************************************************/
 325
 326 /**
 327   * Return a list of all the attributes and values defined for this
 328   * character
 329   */
 330 public Map
 331 getAttributes()
 332 {
 333   HashMap m = new HashMap();
 334   if (attribs == null)
 335     return(m);
 336
 337   for (int i = 0; i < attribs.length; i++)
 338     {
 339        if ((ci.getIndex() >= attribs[i].begin_index) &&
 340            (ci.getIndex() < attribs[i].end_index))
 341          m.putAll(attribs[i].attribs);
 342     }
 343
 344   return(m);
 345 }
 346
 347 } // class AttributedStringIterator
 348