Source for java.text.MessageFormat

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