libjava/classpath/java/text/MessageFormat.java

   1 /* MessageFormat.java - Localized message formatting.
   2    Copyright (C) 1999, 2001, 2002, 2004, 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 import gnu.java.text.FormatCharacterIterator;
  42
  43 import java.io.InvalidObjectException;
  44 import java.util.Date;
  45 import java.util.HashMap;
  46 import java.util.Locale;
  47 import java.util.Vector;
  48
  49 public class MessageFormat extends Format
  50 {
  51   /**
  52    * @author Tom Tromey (tromey@cygnus.com)
  53    * @author Jorge Aliss (jaliss@hotmail.com)
  54    * @date March 3, 1999
  55    */
  56   /* Written using "Java Class Libraries", 2nd edition, plus online
  57    * API docs for JDK 1.2 from http://www.javasoft.com.
  58    * Status:  Believed complete and correct to 1.2, except serialization.
  59    *          and parsing.
  60    */
  61   private static final class MessageFormatElement
  62   {
  63     // Argument number.
  64     int argNumber;
  65     // Formatter to be used.  This is the format set by setFormat.
  66     Format setFormat;
  67     // Formatter to be used based on the type.
  68     Format format;
  69
  70     // Argument will be checked to make sure it is an instance of this
  71     // class.
  72     Class formatClass;
  73
  74     // Formatter type.
  75     String type;
  76     // Formatter style.
  77     String style;
  78
  79     // Text to follow this element.
  80     String trailer;
  81
  82     // Recompute the locale-based formatter.
  83     void setLocale (Locale loc)
  84     {
  85       if (type == null)
  86         ;
  87       else if (type.equals("number"))
  88         {
  89           formatClass = java.lang.Number.class;
  90
  91           if (style == null)
  92             format = NumberFormat.getInstance(loc);
  93           else if (style.equals("currency"))
  94             format = NumberFormat.getCurrencyInstance(loc);
  95           else if (style.equals("percent"))
  96             format = NumberFormat.getPercentInstance(loc);
  97           else if (style.equals("integer"))
  98             {
  99               NumberFormat nf = NumberFormat.getNumberInstance(loc);
 100               nf.setMaximumFractionDigits(0);
 101               nf.setGroupingUsed(false);
 102               format = nf;
 103             }
 104           else
 105             {
 106               format = NumberFormat.getNumberInstance(loc);
 107               DecimalFormat df = (DecimalFormat) format;
 108               df.applyPattern(style);
 109             }
 110         }
 111       else if (type.equals("time") || type.equals("date"))
 112         {
 113           formatClass = java.util.Date.class;
 114
 115           int val = DateFormat.DEFAULT;
 116           boolean styleIsPattern = false;
 117           if (style == null)
 118             ;
 119           else if (style.equals("short"))
 120             val = DateFormat.SHORT;
 121           else if (style.equals("medium"))
 122             val = DateFormat.MEDIUM;
 123           else if (style.equals("long"))
 124             val = DateFormat.LONG;
 125           else if (style.equals("full"))
 126             val = DateFormat.FULL;
 127           else
 128             styleIsPattern = true;
 129
 130           if (type.equals("time"))
 131             format = DateFormat.getTimeInstance(val, loc);
 132           else
 133             format = DateFormat.getDateInstance(val, loc);
 134
 135           if (styleIsPattern)
 136             {
 137               SimpleDateFormat sdf = (SimpleDateFormat) format;
 138               sdf.applyPattern(style);
 139             }
 140         }
 141       else if (type.equals("choice"))
 142         {
 143           formatClass = java.lang.Number.class;
 144
 145           if (style == null)
 146             throw new
 147               IllegalArgumentException ("style required for choice format");
 148           format = new ChoiceFormat (style);
 149         }
 150     }
 151   }
 152
 153   private static final long serialVersionUID = 6479157306784022952L;
 154
 155   public static class Field extends Format.Field
 156   {
 157     static final long serialVersionUID = 7899943957617360810L;
 158
 159     /**
 160      * This is the attribute set for all characters produced
 161      * by MessageFormat during a formatting.
 162      */
 163     public static final MessageFormat.Field ARGUMENT = new MessageFormat.Field("argument");
 164
 165     // For deserialization
 166     private Field()
 167     {
 168       super("");
 169     }
 170
 171     protected Field(String s)
 172     {
 173       super(s);
 174     }
 175
 176     /**
 177      * invoked to resolve the true static constant by
 178      * comparing the deserialized object to know name.
 179      *
 180      * @return object constant
 181      */
 182     protected Object readResolve() throws InvalidObjectException
 183     {
 184       if (getName().equals(ARGUMENT.getName()))
 185         return ARGUMENT;
 186
 187       throw new InvalidObjectException("no such MessageFormat field called " + getName());
 188     }
 189
 190   }
 191
 192   // Helper that returns the text up to the next format opener.  The
 193   // text is put into BUFFER.  Returns index of character after end of
 194   // string.  Throws IllegalArgumentException on error.
 195   private static int scanString(String pat, int index, StringBuffer buffer)
 196   {
 197     int max = pat.length();
 198     buffer.setLength(0);
 199     boolean quoted = false;
 200     for (; index < max; ++index)
 201       {
 202         char c = pat.charAt(index);
 203         if (quoted)
 204           {
 205             // In a quoted context, a single quote ends the quoting.
 206             if (c == '\'')
 207               quoted = false;
 208             else
 209               buffer.append(c);
 210           }
 211         // Check for '', which is a single quote.
 212         else if (c == '\'' && index + 1 < max && pat.charAt(index + 1) == '\'')
 213           {
 214             buffer.append(c);
 215             ++index;
 216           }
 217         else if (c == '\'')
 218           {
 219             // Start quoting.
 220             quoted = true;
 221           }
 222         else if (c == '{')
 223           break;
 224         else
 225           buffer.append(c);
 226       }
 227     // Note that we explicitly allow an unterminated quote.  This is
 228     // done for compatibility.
 229     return index;
 230   }
 231
 232   // This helper retrieves a single part of a format element.  Returns
 233   // the index of the terminating character.
 234   private static int scanFormatElement(String pat, int index,
 235                                        StringBuffer buffer, char term)
 236   {
 237     int max = pat.length();
 238     buffer.setLength(0);
 239     int brace_depth = 1;
 240     boolean quoted = false;
 241
 242     for (; index < max; ++index)
 243       {
 244         char c = pat.charAt(index);
 245         // First see if we should turn off quoting.
 246         if (quoted)
 247           {
 248             if (c == '\'')
 249               quoted = false;
 250             // In both cases we fall through to inserting the
 251             // character here.
 252           }
 253         // See if we have just a plain quote to insert.
 254         else if (c == '\'' && index + 1 < max
 255                  && pat.charAt(index + 1) == '\'')
 256           {
 257             buffer.append(c);
 258             ++index;
 259           }
 260         // See if quoting should turn on.
 261         else if (c == '\'')
 262           quoted = true;
 263         else if (c == '{')
 264           ++brace_depth;
 265         else if (c == '}')
 266           {
 267             if (--brace_depth == 0)
 268               break;
 269           }
 270         // Check for TERM after braces, because TERM might be `}'.
 271         else if (c == term)
 272           break;
 273         // All characters, including opening and closing quotes, are
 274         // inserted here.
 275         buffer.append(c);
 276       }
 277     return index;
 278   }
 279
 280   // This is used to parse a format element and whatever non-format
 281   // text might trail it.
 282   private static int scanFormat(String pat, int index, StringBuffer buffer,
 283                                 Vector elts, Locale locale)
 284   {
 285     MessageFormatElement mfe = new MessageFormatElement ();
 286     elts.addElement(mfe);
 287
 288     int max = pat.length();
 289
 290     // Skip the opening `{'.
 291     ++index;
 292
 293     // Fetch the argument number.
 294     index = scanFormatElement (pat, index, buffer, ',');
 295     try
 296       {
 297         mfe.argNumber = Integer.parseInt(buffer.toString());
 298       }
 299     catch (NumberFormatException nfx)
 300       {
 301         IllegalArgumentException iae = new IllegalArgumentException(pat);
 302         iae.initCause(nfx);
 303         throw iae;
 304       }
 305
 306     // Extract the element format.
 307     if (index < max && pat.charAt(index) == ',')
 308       {
 309         index = scanFormatElement (pat, index + 1, buffer, ',');
 310         mfe.type = buffer.toString();
 311
 312         // Extract the style.
 313         if (index < max && pat.charAt(index) == ',')
 314           {
 315             index = scanFormatElement (pat, index + 1, buffer, '}');
 316             mfe.style = buffer.toString ();
 317           }
 318       }
 319
 320     // Advance past the last terminator.
 321     if (index >= max || pat.charAt(index) != '}')
 322       throw new IllegalArgumentException("Missing '}' at end of message format");
 323     ++index;
 324
 325     // Now fetch trailing string.
 326     index = scanString (pat, index, buffer);
 327     mfe.trailer = buffer.toString ();
 328
 329     mfe.setLocale(locale);
 330
 331     return index;
 332   }
 333
 334   /**
 335    * Applies the specified pattern to this MessageFormat.
 336    *
 337    * @param newPattern The Pattern
 338    */
 339   public void applyPattern (String newPattern)
 340   {
 341     pattern = newPattern;
 342
 343     StringBuffer tempBuffer = new StringBuffer ();
 344
 345     int index = scanString (newPattern, 0, tempBuffer);
 346     leader = tempBuffer.toString();
 347
 348     Vector elts = new Vector ();
 349     while (index < newPattern.length())
 350       index = scanFormat (newPattern, index, tempBuffer, elts, locale);
 351
 352     elements = new MessageFormatElement[elts.size()];
 353     elts.copyInto(elements);
 354   }
 355
 356   /**
 357    * Overrides Format.clone()
 358    */
 359   public Object clone ()
 360   {
 361     MessageFormat c = (MessageFormat) super.clone ();
 362     c.elements = (MessageFormatElement[]) elements.clone ();
 363     return c;
 364   }
 365
 366   /**
 367    * Overrides Format.equals(Object obj)
 368    */
 369   public boolean equals (Object obj)
 370   {
 371     if (! (obj instanceof MessageFormat))
 372       return false;
 373     MessageFormat mf = (MessageFormat) obj;
 374     return (pattern.equals(mf.pattern)
 375             && locale.equals(mf.locale));
 376   }
 377
 378   /**
 379    * A convinience method to format patterns.
 380    *
 381    * @param arguments The array containing the objects to be formatted.
 382    */
 383   public AttributedCharacterIterator formatToCharacterIterator (Object arguments)
 384   {
 385     Object[] arguments_array = (Object[])arguments;
 386     FormatCharacterIterator iterator = new FormatCharacterIterator();
 387
 388     formatInternal(arguments_array, new StringBuffer(), null, iterator);
 389
 390     return iterator;
 391   }
 392
 393   /**
 394    * A convinience method to format patterns.
 395    *
 396    * @param pattern The pattern used when formatting.
 397    * @param arguments The array containing the objects to be formatted.
 398    */
 399   public static String format (String pattern, Object... arguments)
 400   {
 401     MessageFormat mf = new MessageFormat (pattern);
 402     StringBuffer sb = new StringBuffer ();
 403     FieldPosition fp = new FieldPosition (NumberFormat.INTEGER_FIELD);
 404     return mf.formatInternal(arguments, sb, fp, null).toString();
 405   }
 406
 407   /**
 408    * Returns the pattern with the formatted objects.
 409    *
 410    * @param arguments The array containing the objects to be formatted.
 411    * @param appendBuf The StringBuffer where the text is appened.
 412    * @param fp A FieldPosition object (it is ignored).
 413    */
 414   public final StringBuffer format (Object arguments[], StringBuffer appendBuf,
 415                                     FieldPosition fp)
 416   {
 417     return formatInternal(arguments, appendBuf, fp, null);
 418   }
 419
 420   private StringBuffer formatInternal (Object arguments[],
 421                                        StringBuffer appendBuf,
 422                                        FieldPosition fp,
 423                                        FormatCharacterIterator output_iterator)
 424   {
 425     appendBuf.append(leader);
 426     if (output_iterator != null)
 427       output_iterator.append(leader);
 428
 429     for (int i = 0; i < elements.length; ++i)
 430       {
 431         Object thisArg = null;
 432         boolean unavailable = false;
 433         if (arguments == null || elements[i].argNumber >= arguments.length)
 434           unavailable = true;
 435         else
 436           thisArg = arguments[elements[i].argNumber];
 437
 438         AttributedCharacterIterator iterator = null;
 439
 440         Format formatter = null;
 441
 442         if (fp != null && i == fp.getField() && fp.getFieldAttribute() == Field.ARGUMENT)
 443           fp.setBeginIndex(appendBuf.length());
 444
 445         if (unavailable)
 446           appendBuf.append("{" + elements[i].argNumber + "}");
 447         else
 448           {
 449             if (elements[i].setFormat != null)
 450               formatter = elements[i].setFormat;
 451             else if (elements[i].format != null)
 452               {
 453                 if (elements[i].formatClass != null
 454                     && ! elements[i].formatClass.isInstance(thisArg))
 455                   throw new IllegalArgumentException("Wrong format class");
 456
 457                 formatter = elements[i].format;
 458               }
 459             else if (thisArg instanceof Number)
 460               formatter = NumberFormat.getInstance(locale);
 461             else if (thisArg instanceof Date)
 462               formatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale);
 463             else
 464               appendBuf.append(thisArg);
 465           }
 466
 467         if (fp != null && fp.getField() == i && fp.getFieldAttribute() == Field.ARGUMENT)
 468           fp.setEndIndex(appendBuf.length());
 469
 470         if (formatter != null)
 471           {
 472             // Special-case ChoiceFormat.
 473             if (formatter instanceof ChoiceFormat)
 474               {
 475                 StringBuffer buf = new StringBuffer ();
 476                 formatter.format(thisArg, buf, fp);
 477                 MessageFormat mf = new MessageFormat ();
 478                 mf.setLocale(locale);
 479                 mf.applyPattern(buf.toString());
 480                 mf.format(arguments, appendBuf, fp);
 481               }
 482             else
 483               {
 484                 if (output_iterator != null)
 485                   iterator = formatter.formatToCharacterIterator(thisArg);
 486                 else
 487                   formatter.format(thisArg, appendBuf, fp);
 488               }
 489
 490             elements[i].format = formatter;
 491           }
 492
 493         if (output_iterator != null)
 494           {
 495             HashMap hash_argument = new HashMap();
 496             int position = output_iterator.getEndIndex();
 497
 498             hash_argument.put (MessageFormat.Field.ARGUMENT,
 499                                new Integer(elements[i].argNumber));
 500
 501
 502             if (iterator != null)
 503               {
 504                 output_iterator.append(iterator);
 505                 output_iterator.addAttributes(hash_argument, position,
 506                                               output_iterator.getEndIndex());
 507               }
 508             else
 509               output_iterator.append(thisArg.toString(), hash_argument);
 510
 511             output_iterator.append(elements[i].trailer);
 512           }
 513
 514         appendBuf.append(elements[i].trailer);
 515       }
 516
 517     return appendBuf;
 518   }
 519
 520   /**
 521    * Returns the pattern with the formatted objects.  The first argument
 522    * must be a array of Objects.
 523    * This is equivalent to format((Object[]) objectArray, appendBuf, fpos)
 524    *
 525    * @param objectArray The object array to be formatted.
 526    * @param appendBuf The StringBuffer where the text is appened.
 527    * @param fpos A FieldPosition object (it is ignored).
 528    */
 529   public final StringBuffer format (Object objectArray, StringBuffer appendBuf,
 530                                     FieldPosition fpos)
 531   {
 532     return format ((Object[])objectArray, appendBuf, fpos);
 533   }
 534
 535   /**
 536    * Returns an array with the Formats for
 537    * the arguments.
 538    */
 539   public Format[] getFormats ()
 540   {
 541     Format[] f = new Format[elements.length];
 542     for (int i = elements.length - 1; i >= 0; --i)
 543       f[i] = elements[i].setFormat;
 544     return f;
 545   }
 546
 547   /**
 548    * Returns the locale.
 549    */
 550   public Locale getLocale ()
 551   {
 552     return locale;
 553   }
 554
 555   /**
 556    * Overrides Format.hashCode()
 557    */
 558   public int hashCode ()
 559   {
 560     // FIXME: not a very good hash.
 561     return pattern.hashCode() + locale.hashCode();
 562   }
 563
 564   private MessageFormat ()
 565   {
 566   }
 567
 568   /**
 569    * Creates a new MessageFormat object with
 570    * the specified pattern
 571    *
 572    * @param pattern The Pattern
 573    */
 574   public MessageFormat(String pattern)
 575   {
 576     this(pattern, Locale.getDefault());
 577   }
 578
 579   /**
 580    * Creates a new MessageFormat object with
 581    * the specified pattern
 582    *
 583    * @param pattern The Pattern
 584    * @param locale The Locale to use
 585    *
 586    * @since 1.4
 587    */
 588   public MessageFormat(String pattern, Locale locale)
 589   {
 590     this.locale = locale;
 591     applyPattern (pattern);
 592   }
 593
 594   /**
 595    * Parse a string <code>sourceStr</code> against the pattern specified
 596    * to the MessageFormat constructor.
 597    *
 598    * @param sourceStr the string to be parsed.
 599    * @param pos the current parse position (and eventually the error position).
 600    * @return the array of parsed objects sorted according to their argument number
 601    * in the pattern.
 602    */
 603   public Object[] parse (String sourceStr, ParsePosition pos)
 604   {
 605     // Check initial text.
 606     int index = pos.getIndex();
 607     if (! sourceStr.startsWith(leader, index))
 608       {
 609         pos.setErrorIndex(index);
 610         return null;
 611       }
 612     index += leader.length();
 613
 614     Vector results = new Vector (elements.length, 1);
 615     // Now check each format.
 616     for (int i = 0; i < elements.length; ++i)
 617       {
 618         Format formatter = null;
 619         if (elements[i].setFormat != null)
 620           formatter = elements[i].setFormat;
 621         else if (elements[i].format != null)
 622           formatter = elements[i].format;
 623
 624         Object value = null;
 625         if (formatter instanceof ChoiceFormat)
 626           {
 627             // We must special-case a ChoiceFormat because it might
 628             // have recursive formatting.
 629             ChoiceFormat cf = (ChoiceFormat) formatter;
 630             String[] formats = (String[]) cf.getFormats();
 631             double[] limits = (double[]) cf.getLimits();
 632             MessageFormat subfmt = new MessageFormat ();
 633             subfmt.setLocale(locale);
 634             ParsePosition subpos = new ParsePosition (index);
 635
 636             int j;
 637             for (j = 0; value == null && j < limits.length; ++j)
 638               {
 639                 subfmt.applyPattern(formats[j]);
 640                 subpos.setIndex(index);
 641                 value = subfmt.parse(sourceStr, subpos);
 642               }
 643             if (value != null)
 644               {
 645                 index = subpos.getIndex();
 646                 value = new Double (limits[j]);
 647               }
 648           }
 649         else if (formatter != null)
 650           {
 651             pos.setIndex(index);
 652             value = formatter.parseObject(sourceStr, pos);
 653             if (value != null)
 654               index = pos.getIndex();
 655           }
 656         else
 657           {
 658             // We have a String format.  This can lose in a number
 659             // of ways, but we give it a shot.
 660             int next_index;
 661             if (elements[i].trailer.length() > 0)
 662               next_index = sourceStr.indexOf(elements[i].trailer, index);
 663             else
 664               next_index = sourceStr.length();
 665             if (next_index == -1)
 666               {
 667                 pos.setErrorIndex(index);
 668                 return null;
 669               }
 670             value = sourceStr.substring(index, next_index);
 671             index = next_index;
 672           }
 673
 674         if (value == null
 675             || ! sourceStr.startsWith(elements[i].trailer, index))
 676           {
 677             pos.setErrorIndex(index);
 678             return null;
 679           }
 680
 681         if (elements[i].argNumber >= results.size())
 682           results.setSize(elements[i].argNumber + 1);
 683         results.setElementAt(value, elements[i].argNumber);
 684
 685         index += elements[i].trailer.length();
 686       }
 687
 688     Object[] r = new Object[results.size()];
 689     results.copyInto(r);
 690     return r;
 691   }
 692
 693   public Object[] parse (String sourceStr) throws ParseException
 694   {
 695     ParsePosition pp = new ParsePosition (0);
 696     Object[] r = parse (sourceStr, pp);
 697     if (r == null)
 698       throw new ParseException ("couldn't parse string", pp.getErrorIndex());
 699     return r;
 700   }
 701
 702   public Object parseObject (String sourceStr, ParsePosition pos)
 703   {
 704     return parse (sourceStr, pos);
 705   }
 706
 707   /**
 708    * Sets the format for the argument at an specified
 709    * index.
 710    *
 711    * @param variableNum The index.
 712    * @param newFormat The Format object.
 713    */
 714   public void setFormat (int variableNum, Format newFormat)
 715   {
 716     elements[variableNum].setFormat = newFormat;
 717   }
 718
 719   /**
 720    * Sets the formats for the arguments.
 721    *
 722    * @param newFormats An array of Format objects.
 723    */
 724   public void setFormats (Format[] newFormats)
 725   {
 726     if (newFormats.length < elements.length)
 727       throw new IllegalArgumentException("Not enough format objects");
 728
 729     int len = Math.min(newFormats.length, elements.length);
 730     for (int i = 0; i < len; ++i)
 731       elements[i].setFormat = newFormats[i];
 732   }
 733
 734   /**
 735    * Sets the locale.
 736    *
 737    * @param loc A Locale
 738    */
 739   public void setLocale (Locale loc)
 740   {
 741     locale = loc;
 742     if (elements != null)
 743       {
 744         for (int i = 0; i < elements.length; ++i)
 745           elements[i].setLocale(loc);
 746       }
 747   }
 748
 749   /**
 750    * Returns the pattern.
 751    */
 752   public String toPattern ()
 753   {
 754     return pattern;
 755   }
 756
 757   /**
 758    * Return the formatters used sorted by argument index. It uses the
 759    * internal table to fill in this array: if a format has been
 760    * set using <code>setFormat</code> or <code>setFormatByArgumentIndex</code>
 761    * then it returns it at the right index. If not it uses the detected
 762    * formatters during a <code>format</code> call. If nothing is known
 763    * about that argument index it just puts null at that position.
 764    * To get useful informations you may have to call <code>format</code>
 765    * at least once.
 766    *
 767    * @return an array of formatters sorted by argument index.
 768    */
 769   public Format[] getFormatsByArgumentIndex()
 770   {
 771     int argNumMax = 0;
 772     // First, find the greatest argument number.
 773     for (int i=0;i<elements.length;i++)
 774       if (elements[i].argNumber > argNumMax)
 775         argNumMax = elements[i].argNumber;
 776
 777     Format[] formats = new Format[argNumMax];
 778     for (int i=0;i<elements.length;i++)
 779       {
 780         if (elements[i].setFormat != null)
 781           formats[elements[i].argNumber] = elements[i].setFormat;
 782         else if (elements[i].format != null)
 783           formats[elements[i].argNumber] = elements[i].format;
 784       }
 785     return formats;
 786   }
 787
 788   /**
 789    * Set the format to used using the argument index number.
 790    *
 791    * @param argumentIndex the argument index.
 792    * @param newFormat the format to use for this argument.
 793    */
 794   public void setFormatByArgumentIndex(int argumentIndex,
 795                                        Format newFormat)
 796   {
 797     for (int i=0;i<elements.length;i++)
 798       {
 799         if (elements[i].argNumber == argumentIndex)
 800           elements[i].setFormat = newFormat;
 801       }
 802   }
 803
 804   /**
 805    * Set the format for argument using a specified array of formatters
 806    * which is sorted according to the argument index. If the number of
 807    * elements in the array is fewer than the number of arguments only
 808    * the arguments specified by the array are touched.
 809    *
 810    * @param newFormats array containing the new formats to set.
 811    *
 812    * @throws NullPointerException if newFormats is null
 813    */
 814   public void setFormatsByArgumentIndex(Format[] newFormats)
 815   {
 816     for (int i=0;i<newFormats.length;i++)
 817       {
 818         // Nothing better than that can exist here.
 819         setFormatByArgumentIndex(i, newFormats[i]);
 820       }
 821   }
 822
 823   // The pattern string.
 824   private String pattern;
 825   // The locale.
 826   private Locale locale;
 827   // Variables.
 828   private MessageFormatElement[] elements;
 829   // Leader text.
 830   private String leader;
 831 }