AttributedString.java 12.9 KB
Newer Older
Tom Tromey committed
1
/* AttributedString.java -- Models text with attributes
2
   Copyright (C) 1998, 1999, 2004, 2005, 2006, Free Software Foundation, Inc.
Tom Tromey committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package java.text;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
Tom Tromey committed
50 51
 * This class models a <code>String</code> with attributes over various
 * subranges of the string.  It allows applications to access this 
52
 * information via the <code>AttributedCharacterIterator</code> interface.
53 54
 * 
 * @since 1.2
Tom Tromey committed
55 56
 *
 * @author Aaron M. Renn (arenn@urbanophile.com)
57
 * @since 1.2
Tom Tromey committed
58
 */
Tom Tromey committed
59
public class AttributedString
Tom Tromey committed
60 61
{

Tom Tromey committed
62 63 64 65 66 67 68 69 70 71
  /** 
   * The attributes and ranges of text over which those attributes apply. 
   */
  final class AttributeRange
  {

    /** A Map of the attributes */
    Map attribs;

    /** The beginning index of the attributes */
72
    int beginIndex;
Tom Tromey committed
73 74

    /** The ending index of the attributes */
75
    int endIndex;
Tom Tromey committed
76 77 78 79 80

    /**
     * Creates a new attribute range.
     * 
     * @param attribs  the attributes.
81 82
     * @param beginIndex  the start index.
     * @param endIndex  the end index.
Tom Tromey committed
83
     */
84
    AttributeRange(Map attribs, int beginIndex, int endIndex) 
Tom Tromey committed
85 86
    {
      this.attribs = attribs;
87 88
      this.beginIndex = beginIndex;
      this.endIndex = endIndex;
Tom Tromey committed
89 90
    }

Tom Tromey committed
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
  } // Inner class AttributeRange

  /** The string we are representing. */
  private StringCharacterIterator sci;

  /** The attribute information */
  private AttributeRange[] attribs;

  /**
   * Creates a new instance of <code>AttributedString</code>
   * that represents the specified <code>String</code> with no attributes.
   *
   * @param str The <code>String</code> to be attributed (<code>null</code> not
   *            permitted).
   * 
   * @throws NullPointerException if <code>str</code> is <code>null</code>.
   */
  public AttributedString(String str)
  {
    sci = new StringCharacterIterator(str);
    attribs = new AttributeRange[0];
  }

  /**
   * Creates a new instance of <code>AttributedString</code>
   * that represents that specified <code>String</code> with the specified
   * attributes over the entire length of the <code>String</code>.
   *
   * @param str The <code>String</code> to be attributed.
   * @param attributes The attribute list.
   */
122 123
  public AttributedString(String str,
                          Map<? extends AttributedCharacterIterator.Attribute, ?> attributes)
Tom Tromey committed
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
  {
    this(str);

    attribs = new AttributeRange[1];
    attribs[0] = new AttributeRange(attributes, 0, str.length());
  }

  /**
   * Initializes a new instance of <code>AttributedString</code>
   * that will use the text and attribute information from the specified
   * <code>AttributedCharacterIterator</code>.
   *
   * @param aci The <code>AttributedCharacterIterator</code> containing the 
   *            text and attribute information (<code>null</code> not 
   *            permitted).
   * 
   * @throws NullPointerException if <code>aci</code> is <code>null</code>.
   */
  public AttributedString(AttributedCharacterIterator aci)
  {
    this(aci, aci.getBeginIndex(), aci.getEndIndex(), null);
  }

  /**
   * Initializes a new instance of <code>AttributedString</code>
   * that will use the text and attribute information from the specified
   * subrange of the specified <code>AttributedCharacterIterator</code>.
   *
   * @param aci The <code>AttributedCharacterIterator</code> containing the 
   *            text and attribute information.
154 155
   * @param beginIndex The beginning index of the text subrange.
   * @param endIndex The ending index of the text subrange.
Tom Tromey committed
156
   */
157 158
  public AttributedString(AttributedCharacterIterator aci, int beginIndex,
                          int endIndex)
Tom Tromey committed
159
  {
160
    this(aci, beginIndex, endIndex, null);
Tom Tromey committed
161 162 163 164 165 166 167 168 169 170 171 172
  }

  /**
   * Initializes a new instance of <code>AttributedString</code>
   * that will use the text and attribute information from the specified
   * subrange of the specified <code>AttributedCharacterIterator</code>.
   * Only attributes from the source iterator that are present in the
   * specified array of attributes will be included in the attribute list
   * for this object.
   *
   * @param aci The <code>AttributedCharacterIterator</code> containing the 
   *            text and attribute information.
173 174
   * @param begin The beginning index of the text subrange.
   * @param end The ending index of the text subrange.
Tom Tromey committed
175 176 177
   * @param attributes A list of attributes to include from the iterator, or 
   *                   <code>null</code> to include all attributes.
   */
178 179
  public AttributedString(AttributedCharacterIterator aci, int begin, int end, 
                          AttributedCharacterIterator.Attribute[] attributes)
Tom Tromey committed
180 181
  {
    // Validate some arguments
182
    if ((begin < 0) || (end < begin) || end > aci.getEndIndex())
Tom Tromey committed
183 184 185 186 187
      throw new IllegalArgumentException("Bad index values");

    StringBuffer sb = new StringBuffer("");

    // Get the valid attribute list
188
    Set allAttribs = aci.getAllAttributeKeys();
Tom Tromey committed
189
    if (attributes != null)
190
      allAttribs.retainAll(Arrays.asList(attributes));
Tom Tromey committed
191 192

    // Loop through and extract the attributes
193
    char c = aci.setIndex(begin);
Tom Tromey committed
194 195 196 197 198 199

    ArrayList accum = new ArrayList();
    do
      { 
        sb.append(c);

200
        Iterator iter = allAttribs.iterator();
Tom Tromey committed
201 202 203 204 205 206 207 208 209 210 211 212
        while(iter.hasNext())
          {
            Object obj = iter.next();

            // What should we do if this is not true?
            if (!(obj instanceof AttributedCharacterIterator.Attribute))
              continue;

            AttributedCharacterIterator.Attribute attrib = 
              (AttributedCharacterIterator.Attribute)obj;

            // Make sure the attribute is defined.
213 214
            Object attribObj = aci.getAttribute(attrib);
            if (attribObj == null)
Tom Tromey committed
215
              continue;
216
            int rl = aci.getRunLimit(attrib);
217 218 219
            if (rl > end)
              rl = end;
            rl -= begin;
Tom Tromey committed
220 221 222

            // Check to see if we already processed this one
            int rs = aci.getRunStart(attrib);
223
            if ((rs < aci.getIndex()) && (aci.getIndex() != begin))
Tom Tromey committed
224 225 226 227
              continue;

            // If the attribute run starts before the beginning index, we
            // need to junk it if it is an Annotation.
228
            rs -= begin;
229
            if (rs < 0)
Tom Tromey committed
230
              {
231
                if (attribObj instanceof Annotation)
Tom Tromey committed
232 233
                   continue;

234
                rs = 0;
Tom Tromey committed
235 236 237
              }

            // Create a map object.  Yes this will only contain one attribute
238 239
            Map newMap = new Hashtable();
            newMap.put(attrib, attribObj);
Tom Tromey committed
240 241

            // Add it to the attribute list.
242
            accum.add(new AttributeRange(newMap, rs, rl));
Tom Tromey committed
243 244 245 246
          }

        c = aci.next();
      }
247
    while( aci.getIndex() < end );
Tom Tromey committed
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272

    attribs = new AttributeRange[accum.size()];
    attribs = (AttributeRange[]) accum.toArray(attribs);

    sci = new StringCharacterIterator(sb.toString());
  }

  /**
   * Adds a new attribute that will cover the entire string.
   *
   * @param attrib The attribute to add.
   * @param value The value of the attribute.
   */
  public void addAttribute(AttributedCharacterIterator.Attribute attrib, 
          Object value)
  {
    addAttribute(attrib, value, 0, sci.getEndIndex());
  }

  /**
   * Adds a new attribute that will cover the specified subrange
   * of the string.
   *
   * @param attrib The attribute to add.
   * @param value The value of the attribute, which may be <code>null</code>.
273 274
   * @param begin The beginning index of the subrange.
   * @param end The ending index of the subrange.
Tom Tromey committed
275 276 277 278 279
   *
   * @exception IllegalArgumentException If attribute is <code>null</code> or 
   *            the subrange is not valid.
   */
  public void addAttribute(AttributedCharacterIterator.Attribute attrib, 
280
          Object value, int begin, int end)
Tom Tromey committed
281 282 283
  {
    if (attrib == null)
      throw new IllegalArgumentException("null attribute");
284 285
    if (end <= begin)
      throw new IllegalArgumentException("Requires end > begin");
Tom Tromey committed
286 287 288
    HashMap hm = new HashMap();
    hm.put(attrib, value);

289
    addAttributes(hm, begin, end);
Tom Tromey committed
290 291 292 293 294 295 296
  }

  /**
   * Adds all of the attributes in the specified list to the
   * specified subrange of the string.
   *
   * @param attributes The list of attributes.
297 298
   * @param beginIndex The beginning index.
   * @param endIndex The ending index
Tom Tromey committed
299
   *
300 301 302
   * @throws NullPointerException if <code>attributes</code> is 
   *         <code>null</code>.
   * @throws IllegalArgumentException if the subrange is not valid.
Tom Tromey committed
303
   */
304 305
  public void addAttributes(Map<? extends AttributedCharacterIterator.Attribute, ?> attributes,
			    int beginIndex, int endIndex)
Tom Tromey committed
306 307
  {
    if (attributes == null)
308
      throw new NullPointerException("null attribute");
Tom Tromey committed
309

310 311
    if ((beginIndex < 0) || (endIndex > sci.getEndIndex()) ||
        (endIndex <= beginIndex))
Tom Tromey committed
312 313 314 315 316
      throw new IllegalArgumentException("bad range");

    AttributeRange[] new_list = new AttributeRange[attribs.length + 1];
    System.arraycopy(attribs, 0, new_list, 0, attribs.length);
    attribs = new_list;
317 318
    attribs[attribs.length - 1] = new AttributeRange(attributes, beginIndex, 
                                                     endIndex);
Tom Tromey committed
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
  } 

  /**
   * Returns an <code>AttributedCharacterIterator</code> that 
   * will iterate over the entire string.
   *
   * @return An <code>AttributedCharacterIterator</code> for the entire string.
   */
  public AttributedCharacterIterator getIterator()
  {
    return(new AttributedStringIterator(sci, attribs, 0, sci.getEndIndex(), 
            null));
  }

  /**
   * Returns an <code>AttributedCharacterIterator</code> that
   * will iterate over the entire string.  This iterator will return information
   * about the list of attributes in the specified array.  Attributes not in
   * the array may or may not be returned by the iterator.  If the specified
   * array is <code>null</code>, all attributes will be returned.
   *
   * @param attributes A list of attributes to include in the returned iterator.
   *
   * @return An <code>AttributedCharacterIterator</code> for this string.
   */
  public AttributedCharacterIterator getIterator(
          AttributedCharacterIterator.Attribute[] attributes)
  {
    return(getIterator(attributes, 0, sci.getEndIndex()));
  }

  /**
   * Returns an <code>AttributedCharacterIterator</code> that
   * will iterate over the specified subrange.  This iterator will return 
   * information about the list of attributes in the specified array.  
   * Attributes not in the array may or may not be returned by the iterator.  
   * If the specified array is <code>null</code>, all attributes will be 
   * returned.  
   *
   * @param attributes A list of attributes to include in the returned iterator.
359 360
   * @param beginIndex The beginning index of the subrange.
   * @param endIndex The ending index of the subrange.
Tom Tromey committed
361 362 363 364 365
   *
   * @return An <code>AttributedCharacterIterator</code> for this string.
   */
  public AttributedCharacterIterator getIterator(
          AttributedCharacterIterator.Attribute[] attributes, 
366
          int beginIndex, int endIndex)
Tom Tromey committed
367
  {
368 369
    if ((beginIndex < 0) || (endIndex > sci.getEndIndex()) ||
        (endIndex < beginIndex))
Tom Tromey committed
370 371
      throw new IllegalArgumentException("bad range");

372
    return(new AttributedStringIterator(sci, attribs, beginIndex, endIndex,
Tom Tromey committed
373 374
                                        attributes));
  }
Tom Tromey committed
375 376

} // class AttributedString