Source for java.text.NumberFormat

   1: /* NumberFormat.java -- Formats and parses numbers
   2:    Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2007
   3:    Free Software Foundation, Inc.
   4: 
   5: This file is part of GNU Classpath.
   6: 
   7: GNU Classpath is free software; you can redistribute it and/or modify
   8: it under the terms of the GNU General Public License as published by
   9: the Free Software Foundation; either version 2, or (at your option)
  10: any later version.
  11:  
  12: GNU Classpath is distributed in the hope that it will be useful, but
  13: WITHOUT ANY WARRANTY; without even the implied warranty of
  14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15: General Public License for more details.
  16: 
  17: You should have received a copy of the GNU General Public License
  18: along with GNU Classpath; see the file COPYING.  If not, write to the
  19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20: 02110-1301 USA.
  21: 
  22: Linking this library statically or dynamically with other modules is
  23: making a combined work based on this library.  Thus, the terms and
  24: conditions of the GNU General Public License cover the whole
  25: combination.
  26: 
  27: As a special exception, the copyright holders of this library give you
  28: permission to link this library with independent modules to produce an
  29: executable, regardless of the license terms of these independent
  30: modules, and to copy and distribute the resulting executable under
  31: terms of your choice, provided that you also meet, for each linked
  32: independent module, the terms and conditions of the license of that
  33: module.  An independent module is a module which is not derived from
  34: or based on this library.  If you modify this library, you may extend
  35: this exception to your version of the library, but you are not
  36: obligated to do so.  If you do not wish to do so, delete this
  37: exception statement from your version. */
  38: 
  39: 
  40: package java.text;
  41: 
  42: import gnu.java.locale.LocaleHelper;
  43: 
  44: import java.io.IOException;
  45: import java.io.InvalidObjectException;
  46: import java.io.ObjectInputStream;
  47: import java.io.ObjectOutputStream;
  48: 
  49: import java.text.spi.NumberFormatProvider;
  50: 
  51: import java.util.Currency;
  52: import java.util.Locale;
  53: import java.util.MissingResourceException;
  54: import java.util.ResourceBundle;
  55: import java.util.ServiceLoader;
  56: 
  57: /**
  58:  * This is the abstract superclass of all classes which format and 
  59:  * parse numeric values such as decimal numbers, integers, currency values,
  60:  * and percentages.  These classes perform their parsing and formatting
  61:  * in a locale specific manner, accounting for such items as differing
  62:  * currency symbols and thousands separators.
  63:  * <p>
  64:  * To create an instance of a concrete subclass of <code>NumberFormat</code>,
  65:  * do not call a class constructor directly.  Instead, use one of the
  66:  * static factory methods in this class such as 
  67:  * <code>getCurrencyInstance</code>.
  68:  * 
  69:  * @author Tom Tromey (tromey@cygnus.com)
  70:  * @author Aaron M. Renn (arenn@urbanophile.com)
  71:  * @date March 4, 1999
  72:  */
  73: /* Written using "Java Class Libraries", 2nd edition, plus online
  74:  * API docs for JDK 1.2 from http://www.javasoft.com.
  75:  * Status:  Believed complete and correct to 1.2, except getAvailableLocales.
  76:  */
  77: public abstract class NumberFormat extends Format implements Cloneable
  78: {
  79:   /**
  80:    * This is a constant used to create a <code>FieldPosition</code> object
  81:    * that will return the integer portion of a formatted number.
  82:    */
  83:   public static final int INTEGER_FIELD = 0;
  84: 
  85:   /**
  86:    * This is a constant used to create a <code>FieldPosition</code> object
  87:    * that will return the fractional portion of a formatted number.
  88:    */
  89:   public static final int FRACTION_FIELD = 1;
  90: 
  91:   public static class Field extends Format.Field
  92:   {
  93:     static final long serialVersionUID = 7494728892700160890L;
  94: 
  95:     /**
  96:      * Attribute set to all characters containing digits of the integer
  97:      * part.
  98:      */
  99:     public static final NumberFormat.Field INTEGER
 100:       = new Field("integer");
 101: 
 102:     /**
 103:      * Attribute set to all characters containing digits of the fractional
 104:      * part.
 105:      */
 106:     public static final NumberFormat.Field FRACTION
 107:       = new Field("fraction");
 108: 
 109:     /**
 110:      * Attribute set to all characters containing digits of the exponential
 111:      * part.
 112:      */
 113:     public static final NumberFormat.Field EXPONENT
 114:       = new Field("exponent");
 115: 
 116:     /**
 117:      * Attribute set to all characters containing a decimal separator.
 118:      */
 119:     public static final NumberFormat.Field DECIMAL_SEPARATOR
 120:       = new Field("decimal separator");
 121: 
 122:     /**
 123:      * Attribute set to all characters containing a sign (plus or minus).
 124:      */
 125:     public static final NumberFormat.Field SIGN
 126:       = new Field("sign");
 127: 
 128:     /**
 129:      * Attribute set to all characters containing a grouping separator (e.g.
 130:      * a comma, a white space,...).
 131:      */
 132:     public static final NumberFormat.Field GROUPING_SEPARATOR
 133:       = new Field("grouping separator");
 134: 
 135:     /**
 136:      * Attribute set to all characters containing an exponential symbol (e.g.
 137:      * 'E')
 138:      */
 139:     public static final NumberFormat.Field EXPONENT_SYMBOL
 140:       = new Field("exponent symbol");
 141: 
 142:     /**
 143:      * Attribute set to all characters containing a percent symbol (e.g. '%')
 144:      */
 145:     public static final NumberFormat.Field PERCENT
 146:       = new Field("percent");
 147: 
 148:     /**
 149:      * Attribute set to all characters containing a permille symbol.
 150:      */
 151:     public static final NumberFormat.Field PERMILLE
 152:       = new Field("permille");
 153: 
 154:     /**
 155:      * Attribute set to all characters containing the currency unit.
 156:      */
 157:     public static final NumberFormat.Field CURRENCY
 158:       = new Field("currency");
 159: 
 160:     /**
 161:      * Attribute set to all characters containing the exponent sign.
 162:      */
 163:     public static final NumberFormat.Field EXPONENT_SIGN
 164:       = new Field("exponent sign");
 165: 
 166:     /**
 167:      * Private fields to register all fields contained in this descriptor.
 168:      */
 169:     private static final NumberFormat.Field[] allFields =
 170:     {
 171:       INTEGER, FRACTION, EXPONENT, DECIMAL_SEPARATOR, SIGN,
 172:       GROUPING_SEPARATOR, EXPONENT_SYMBOL, PERCENT,
 173:       PERMILLE, CURRENCY, EXPONENT_SIGN
 174:     };
 175: 
 176:     /**
 177:      * This constructor is only used by the deserializer. Without it,
 178:      * it would fail to construct a valid object.
 179:      */
 180:     private Field()
 181:     {
 182:       super("");
 183:     }
 184: 
 185:     /**
 186:      * Create a Field instance with the specified field name.
 187:      *
 188:      * @param field_name Field name for the new Field instance.
 189:      */
 190:     protected Field(String field_name)
 191:     {
 192:       super (field_name);
 193:     }
 194: 
 195:     /**
 196:      * This function is used by the deserializer to know which object
 197:      * to use when it encounters an encoded NumberFormat.Field in a 
 198:      * serialization stream. If the stream is valid it should return
 199:      * one of the above field. In the other case we throw an exception.
 200:      *
 201:      * @return a valid official NumberFormat.Field instance.
 202:      *
 203:      * @throws InvalidObjectException if the field name is invalid.
 204:      */
 205:     protected Object readResolve() throws InvalidObjectException
 206:     {
 207:       String s = getName();
 208:       for (int i = 0; i < allFields.length; i++)
 209:     if (s.equals(allFields[i].getName()))
 210:       return allFields[i];
 211: 
 212:       throw new InvalidObjectException("no such NumberFormat field called "
 213:                        + s);
 214:     }
 215:   }
 216: 
 217:   /**
 218:    * This method is a specialization of the format method that performs
 219:    * a simple formatting of the specified <code>long</code> number.
 220:    *
 221:    * @param number The <code>long</code> to format.
 222:    *
 223:    * @return The formatted number
 224:    */
 225:   public final String format (long number)
 226:   {
 227:     StringBuffer sbuf = new StringBuffer(50);
 228:     format (number, sbuf, new FieldPosition(0));
 229:     return sbuf.toString();
 230:   }
 231: 
 232:   /**
 233:    * @specnote this method was final in releases before 1.5
 234:    */
 235:   public StringBuffer format (Object obj, StringBuffer sbuf,
 236:                               FieldPosition pos)
 237:   {
 238:     if (obj instanceof Number)
 239:       return format(((Number) obj).doubleValue(), sbuf, pos);
 240:   
 241:     throw new
 242:       IllegalArgumentException("Cannot format given Object as a Number");
 243:   }
 244: 
 245:   /**
 246:    * This method formats the specified <code>double</code> and appends it to
 247:    * a <code>StringBuffer</code>.
 248:    * 
 249:    * @param number The <code>double</code> to format.
 250:    * @param sbuf The <code>StringBuffer</code> to append the formatted number 
 251:    *             to.
 252:    * @param pos The desired <code>FieldPosition</code>.
 253:    *
 254:    * @return The <code>StringBuffer</code> with the appended number.
 255:    */
 256:   public abstract StringBuffer format (double number,
 257:                        StringBuffer sbuf, FieldPosition pos);
 258: 
 259:   /**
 260:    * This method formats the specified <code>long</code> and appends it to
 261:    * a <code>StringBuffer</code>.
 262:    * 
 263:    * @param number The <code>long</code> to format.
 264:    * @param sbuf The <code>StringBuffer</code> to append the formatted number 
 265:    *             to.
 266:    * @param pos The desired <code>FieldPosition</code>.
 267:    *
 268:    * @return The <code>StringBuffer</code> with the appended number.
 269:    */
 270:   public abstract StringBuffer format (long number,
 271:                        StringBuffer sbuf, FieldPosition pos);
 272: 
 273:   /**
 274:    * This method tests the specified object for equality against this object.
 275:    * This will be <code>true</code> if the following conditions are met:
 276:    * <p>
 277:    * <ul>
 278:    * <li>The specified object is not <code>null</code>.
 279:    * <li>The specified object is an instance of <code>NumberFormat</code>.
 280:    * </ul>
 281:    * <p>
 282:    * Since this method does not test much, it is highly advised that 
 283:    * concrete subclasses override this method.
 284:    *
 285:    * @param obj The <code>Object</code> to test against equality with
 286:    *            this object. 
 287:    * 
 288:    * @return <code>true</code> if the specified object is equal to
 289:    * this object, <code>false</code> otherwise. 
 290:    */
 291:   public boolean equals (Object obj)
 292:   {
 293:     if (! (obj instanceof NumberFormat))
 294:       return false;
 295:     NumberFormat nf = (NumberFormat) obj;
 296:     return (groupingUsed == nf.groupingUsed
 297:         && maximumFractionDigits == nf.maximumFractionDigits
 298:         && maximumIntegerDigits == nf.maximumIntegerDigits
 299:         && minimumFractionDigits == nf.minimumFractionDigits
 300:         && minimumIntegerDigits == nf.minimumIntegerDigits
 301:         && parseIntegerOnly == nf.parseIntegerOnly);
 302:   }
 303: 
 304:   /**
 305:    * This method returns a list of locales for which concrete instances
 306:    * of <code>NumberFormat</code> subclasses may be created.
 307:    *
 308:    * @return The list of available locales.
 309:    */
 310:   public static Locale[] getAvailableLocales ()
 311:   {
 312:     Locale[] list = new Locale[1];
 313:     list[0] = Locale.US;
 314:     return list;
 315:   }
 316: 
 317:   private static NumberFormat computeInstance(Locale loc, String resource,
 318:                                               String def)
 319:     throws MissingResourceException
 320:   {
 321:     if (loc.equals(Locale.ROOT))
 322:       return new DecimalFormat(def, DecimalFormatSymbols.getInstance(loc)); 
 323:     ResourceBundle res =
 324:       ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
 325:                    loc, ClassLoader.getSystemClassLoader());
 326:     String fmt;
 327:     try
 328:       {
 329:     fmt = res == null ? def : res.getString(resource);
 330:       }
 331:     catch (MissingResourceException x)
 332:       {
 333:     fmt = def;
 334:       }
 335:     DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(loc);
 336:     return new DecimalFormat (fmt, dfs);
 337:   }
 338: 
 339:   /**
 340:    * This method returns an instance of <code>NumberFormat</code> suitable
 341:    * for formatting and parsing currency values in the default locale.
 342:    *
 343:    * @return An instance of <code>NumberFormat</code> for handling currencies.
 344:    */
 345:   public static final NumberFormat getCurrencyInstance ()
 346:   {
 347:     return getCurrencyInstance (Locale.getDefault());
 348:   }
 349: 
 350:   /**
 351:    * This method returns an instance of <code>NumberFormat</code> suitable
 352:    * for formatting and parsing currency values in the specified locale.
 353:    *
 354:    * @return An instance of <code>NumberFormat</code> for handling currencies.
 355:    */
 356:   public static NumberFormat getCurrencyInstance (Locale loc)
 357:   {
 358:     try
 359:       {
 360:     NumberFormat format;
 361:     
 362:     format = computeInstance (loc, "currencyFormat",
 363:                   "\u00A4#,##0.00;(\u00A4#,##0.00)");
 364:     format.setMaximumFractionDigits(format.getCurrency().getDefaultFractionDigits());  
 365:     return format;
 366:       }
 367:     catch (MissingResourceException e)
 368:       {
 369:     for (NumberFormatProvider p :
 370:            ServiceLoader.load(NumberFormatProvider.class))
 371:       {
 372:         for (Locale l : p.getAvailableLocales())
 373:           {
 374:         if (l.equals(loc))
 375:           {
 376:             NumberFormat nf = p.getCurrencyInstance(loc);
 377:             if (nf != null)
 378:               return nf;
 379:             break;
 380:           }
 381:           }
 382:       }
 383:     return getCurrencyInstance(LocaleHelper.getFallbackLocale(loc));
 384:       }
 385:   }
 386: 
 387:   /**
 388:    * This method returns a default instance for the default locale. This
 389:    * will be a concrete subclass of <code>NumberFormat</code>, but the 
 390:    * actual class returned is dependent on the locale.
 391:    *
 392:    * @return An instance of the default <code>NumberFormat</code> class.
 393:    */
 394:   public static final NumberFormat getInstance ()
 395:   {
 396:     return getInstance (Locale.getDefault());
 397:   }
 398: 
 399:   /**
 400:    * This method returns a default instance for the specified locale. This
 401:    * will be a concrete subclass of <code>NumberFormat</code>, but the 
 402:    * actual class returned is dependent on the locale.
 403:    *
 404:    * @param loc The desired locale.
 405:    *
 406:    * @return An instance of the default <code>NumberFormat</code> class.
 407:    */
 408:   public static NumberFormat getInstance (Locale loc)
 409:   {
 410:     // For now always return a number instance.
 411:     return getNumberInstance (loc);
 412:   }
 413: 
 414:   /**
 415:    * This method returns the maximum number of digits allowed in the fraction
 416:    * portion of a number.
 417:    *
 418:    * @return The maximum number of digits allowed in the fraction
 419:    * portion of a number. 
 420:    */
 421:   public int getMaximumFractionDigits ()
 422:   {
 423:     return maximumFractionDigits;
 424:   }
 425: 
 426:   /**
 427:    * This method returns the maximum number of digits allowed in the integer
 428:    * portion of a number.
 429:    *
 430:    * @return The maximum number of digits allowed in the integer
 431:    * portion of a number. 
 432:    */
 433:   public int getMaximumIntegerDigits ()
 434:   {
 435:     return maximumIntegerDigits;
 436:   }
 437: 
 438:   /**
 439:    * This method returns the minimum number of digits allowed in the fraction
 440:    * portion of a number.
 441:    *
 442:    * @return The minimum number of digits allowed in the fraction
 443:    * portion of a number. 
 444:    */
 445:   public int getMinimumFractionDigits ()
 446:   {
 447:     return minimumFractionDigits;
 448:   }
 449: 
 450:   /**
 451:    * This method returns the minimum number of digits allowed in the integer
 452:    * portion of a number.
 453:    *
 454:    * @return The minimum number of digits allowed in the integer
 455:    * portion of a number. 
 456:    */
 457:   public int getMinimumIntegerDigits ()
 458:   {
 459:     return minimumIntegerDigits;
 460:   }
 461: 
 462:   /**
 463:    * This method returns a default instance for the specified locale. This
 464:    * will be a concrete subclass of <code>NumberFormat</code>, but the 
 465:    * actual class returned is dependent on the locale.
 466:    *
 467:    * @return An instance of the default <code>NumberFormat</code> class.
 468:    */
 469:   public static final NumberFormat getNumberInstance ()
 470:   {
 471:     return getNumberInstance (Locale.getDefault());
 472:   }
 473: 
 474:   /**
 475:    * This method returns a general purpose number formatting and parsing
 476:    * class for the default locale.  This will be a concrete subclass of
 477:    * <code>NumberFormat</code>, but the actual class returned is dependent
 478:    * on the locale.
 479:    *
 480:    * @return An instance of a generic number formatter for the default locale.
 481:    */
 482:   public static NumberFormat getNumberInstance (Locale loc)
 483:   {
 484:     try
 485:       {
 486:     return computeInstance (loc, "numberFormat", "#,##0.###");
 487:       }
 488:     catch (MissingResourceException e)
 489:       {
 490:     for (NumberFormatProvider p :
 491:            ServiceLoader.load(NumberFormatProvider.class))
 492:       {
 493:         for (Locale l : p.getAvailableLocales())
 494:           {
 495:         if (l.equals(loc))
 496:           {
 497:             NumberFormat nf = p.getNumberInstance(loc);
 498:             if (nf != null)
 499:               return nf;
 500:             break;
 501:           }
 502:           }
 503:       }
 504:     return getNumberInstance(LocaleHelper.getFallbackLocale(loc));
 505:       }
 506:   }
 507: 
 508:   /**
 509:    * This method returns an integer formatting and parsing class for the
 510:    * default locale. This will be a concrete subclass of <code>NumberFormat</code>,
 511:    * but the actual class returned is dependent on the locale.
 512:    *
 513:    * @return An instance of an integer number formatter for the default locale.
 514:    * @since 1.4 
 515:    */
 516:   public static final NumberFormat getIntegerInstance()
 517:   {
 518:     return getIntegerInstance (Locale.getDefault());
 519:   }
 520: 
 521:   /**
 522:    * This method returns an integer formatting and parsing class for the
 523:    * default locale. This will be a concrete subclass of <code>NumberFormat</code>,
 524:    * but the actual class returned is dependent on the locale.
 525:    *
 526:    * @param locale the desired locale.
 527:    *
 528:    * @return An instance of an integer number formatter for the desired locale.
 529:    * @since 1.4 
 530:    */
 531:   public static NumberFormat getIntegerInstance(Locale locale)
 532:   {
 533:     try
 534:       {
 535:     NumberFormat format = computeInstance (locale,
 536:                            "integerFormat", "#,##0");
 537:     format.setMaximumFractionDigits(0);
 538:     format.setParseIntegerOnly (true);
 539:     return format;
 540:       }
 541:     catch (MissingResourceException e)
 542:       {
 543:     for (NumberFormatProvider p :
 544:            ServiceLoader.load(NumberFormatProvider.class))
 545:       {
 546:         for (Locale l : p.getAvailableLocales())
 547:           {
 548:         if (l.equals(locale))
 549:           {
 550:             NumberFormat nf = p.getIntegerInstance(locale);
 551:             if (nf != null)
 552:               return nf;
 553:             break;
 554:           }
 555:           }
 556:       }
 557:     return getIntegerInstance(LocaleHelper.getFallbackLocale(locale));
 558:       }
 559:   }
 560: 
 561:   /**
 562:    * This method returns an instance of <code>NumberFormat</code> suitable
 563:    * for formatting and parsing percentage values in the default locale.
 564:    *
 565:    * @return An instance of <code>NumberFormat</code> for handling percentages.
 566:    */
 567:   public static final NumberFormat getPercentInstance ()
 568:   {
 569:     return getPercentInstance (Locale.getDefault());
 570:   }
 571: 
 572:   /**
 573:    * This method returns an instance of <code>NumberFormat</code> suitable
 574:    * for formatting and parsing percentage values in the specified locale.
 575:    *
 576:    * @param loc The desired locale.
 577:    *
 578:    * @return An instance of <code>NumberFormat</code> for handling percentages.
 579:    */
 580:   public static NumberFormat getPercentInstance (Locale loc)
 581:   {
 582:     try
 583:       {
 584:     return computeInstance (loc, "percentFormat", "#,##0%");
 585:       }
 586:     catch (MissingResourceException e)
 587:       {
 588:     for (NumberFormatProvider p :
 589:            ServiceLoader.load(NumberFormatProvider.class))
 590:       {
 591:         for (Locale l : p.getAvailableLocales())
 592:           {
 593:         if (l.equals(loc))
 594:           {
 595:             NumberFormat nf = p.getPercentInstance(loc);
 596:             if (nf != null)
 597:               return nf;
 598:             break;
 599:           }
 600:           }
 601:       }
 602:     return getPercentInstance(LocaleHelper.getFallbackLocale(loc));
 603:       }
 604:   }
 605: 
 606:   /**
 607:    * This method returns a hash value for this object.
 608:    *
 609:    * @return The hash code.
 610:    */
 611:   public int hashCode ()
 612:   {
 613:     int hash = super.hashCode();
 614:     hash ^= (maximumFractionDigits + maximumIntegerDigits
 615:          + minimumFractionDigits + minimumIntegerDigits);
 616:     if (groupingUsed)
 617:       hash ^= 0xf0f0;
 618:     if (parseIntegerOnly)
 619:       hash ^= 0x0f0f;
 620:     return hash;
 621:   }
 622: 
 623:   /**
 624:    * This method tests whether or not grouping is in use.  Grouping is
 625:    * a method of marking separations in numbers, such as thousand separators
 626:    * in the US English locale.  The grouping positions and symbols are all
 627:    * locale specific.  As an example, with grouping disabled, the number one
 628:    * million would appear as "1000000".  With grouping enabled, this number
 629:    * might appear as "1,000,000".  (Both of these assume the US English
 630:    * locale).
 631:    *
 632:    * @return <code>true</code> if grouping is enabled,
 633:    * <code>false</code> otherwise. 
 634:    */
 635:   public boolean isGroupingUsed ()
 636:   {
 637:     return groupingUsed;
 638:   }
 639: 
 640:   /**
 641:    * This method tests whether or not only integer values should be parsed.
 642:    * If this class is parsing only integers, parsing stops at the decimal
 643:    * point.
 644:    *
 645:    * @return <code>true</code> if only integers are parsed,
 646:    * <code>false</code> otherwise. 
 647:    */
 648:   public boolean isParseIntegerOnly ()
 649:   {
 650:     return parseIntegerOnly;
 651:   }
 652: 
 653:   /**
 654:    * This is a default constructor for use by subclasses.
 655:    */
 656:   public NumberFormat ()
 657:   {
 658:   }
 659: 
 660:   /**
 661:    * This method parses the specified string into a <code>Number</code>.  This
 662:    * will be a <code>Long</code> if possible, otherwise it will be a
 663:    * <code>Double</code>.    If no number can be parsed, no exception is
 664:    * thrown.  Instead, the parse position remains at its initial index.
 665:    *
 666:    * @param sourceStr The string to parse.
 667:    * @param pos The desired <code>ParsePosition</code>.
 668:    *
 669:    * @return The parsed <code>Number</code>
 670:    */
 671:   public abstract Number parse (String sourceStr, ParsePosition pos);
 672: 
 673:   /**
 674:    * This method parses the specified string into a <code>Number</code>.  This
 675:    * will be a <code>Long</code> if possible, otherwise it will be a
 676:    * <code>Double</code>.  If no number can be parsed, an exception will be
 677:    * thrown.
 678:    *
 679:    * @param sourceStr The string to parse.
 680:    *
 681:    * @return The parsed <code>Number</code>
 682:    *
 683:    * @exception ParseException If no number can be parsed.
 684:    */
 685:   public Number parse (String sourceStr) throws ParseException
 686:   {
 687:     ParsePosition pp = new ParsePosition (0);
 688:     Number r = parse (sourceStr, pp);
 689:     if (r == null)
 690:       {
 691:     int index = pp.getErrorIndex();
 692:     if (index < 0)
 693:       index = pp.getIndex();
 694:     throw new ParseException ("couldn't parse number", index);
 695:       }
 696:     return r;
 697:   }
 698: 
 699:   /**
 700:    * This method parses the specified string into an <code>Object</code>.  This
 701:    * will be a <code>Long</code> if possible, otherwise it will be a
 702:    * <code>Double</code>.    If no number can be parsed, no exception is
 703:    * thrown.  Instead, the parse position remains at its initial index.
 704:    *
 705:    * @param sourceStr The string to parse.
 706:    * @param pos The desired <code>ParsePosition</code>.
 707:   *
 708:   * @return The parsed <code>Object</code>
 709:   */
 710:   public final Object parseObject (String sourceStr, ParsePosition pos)
 711:   {
 712:     return parse (sourceStr, pos);
 713:   }
 714: 
 715:   /**
 716:    * This method sets the grouping behavior of this formatter.  Grouping is
 717:    * a method of marking separations in numbers, such as thousand separators
 718:    * in the US English locale.  The grouping positions and symbols are all
 719:    * locale specific.  As an example, with grouping disabled, the number one
 720:    * million would appear as "1000000".  With grouping enabled, this number
 721:    * might appear as "1,000,000".  (Both of these assume the US English
 722:    * locale).
 723:    *
 724:    * @param newValue <code>true</code> to enable grouping,
 725:    *                     <code>false</code> to disable it. 
 726:    */
 727:   public void setGroupingUsed (boolean newValue)
 728:   {
 729:     groupingUsed = newValue;
 730:   }
 731: 
 732:   /**
 733:    * This method sets the maximum number of digits allowed in the fraction
 734:    * portion of a number to the specified value.  If this is less than the
 735:    * current minimum allowed digits, the minimum allowed digits value will
 736:    * be lowered to be equal to the new maximum allowed digits value.
 737:    *
 738:    * @param digits The new maximum fraction digits value.
 739:    */
 740:   public void setMaximumFractionDigits (int digits)
 741:   {
 742:     maximumFractionDigits = digits;
 743:     if (getMinimumFractionDigits () > maximumFractionDigits)
 744:       setMinimumFractionDigits (maximumFractionDigits);
 745:   }
 746: 
 747:   /**
 748:    * This method sets the maximum number of digits allowed in the integer
 749:    * portion of a number to the specified value.  If this is less than the
 750:    * current minimum allowed digits, the minimum allowed digits value will
 751:    * be lowered to be equal to the new maximum allowed digits value.
 752:    *
 753:    * @param digits The new maximum integer digits value.
 754:    */
 755:   public void setMaximumIntegerDigits (int digits)
 756:   {
 757:     maximumIntegerDigits = digits;
 758:     if (getMinimumIntegerDigits () > maximumIntegerDigits)
 759:       setMinimumIntegerDigits (maximumIntegerDigits);
 760:   }
 761: 
 762:   /**
 763:    * This method sets the minimum number of digits allowed in the fraction
 764:    * portion of a number to the specified value.  If this is greater than the
 765:    * current maximum allowed digits, the maximum allowed digits value will
 766:    * be raised to be equal to the new minimum allowed digits value.
 767:    *
 768:    * @param digits The new minimum fraction digits value.
 769:    */
 770:   public void setMinimumFractionDigits (int digits)
 771:   {
 772:     minimumFractionDigits = digits;
 773:     if (getMaximumFractionDigits () < minimumFractionDigits)
 774:       setMaximumFractionDigits (minimumFractionDigits);
 775:   }
 776: 
 777:   /**
 778:    * This method sets the minimum number of digits allowed in the integer
 779:    * portion of a number to the specified value.  If this is greater than the
 780:    * current maximum allowed digits, the maximum allowed digits value will
 781:    * be raised to be equal to the new minimum allowed digits value.
 782:    *
 783:    * @param digits The new minimum integer digits value.
 784:    */
 785:   public void setMinimumIntegerDigits (int digits)
 786:   {
 787:     minimumIntegerDigits = digits;
 788:     if (getMaximumIntegerDigits () < minimumIntegerDigits)
 789:       setMaximumIntegerDigits (minimumIntegerDigits);
 790:   }
 791: 
 792:   /** 
 793:    * This method sets the parsing behavior of this object to parse only 
 794:    * integers or not.
 795:    *
 796:    * @param value <code>true</code> to parse only integers,
 797:    *                         <code>false</code> otherwise. 
 798:    */
 799:   public void setParseIntegerOnly (boolean value)
 800:   {
 801:     parseIntegerOnly = value;
 802:   }
 803: 
 804:   /**
 805:    * This method is a specialization of the format method that performs
 806:    * a simple formatting of the specified <code>double</code> number.
 807:    *
 808:    * @param number The <code>double</code> to format.
 809:    *
 810:    * @return The formatted number
 811:    */
 812:   public final String format (double number)
 813:   {
 814:     StringBuffer sbuf = new StringBuffer(50);
 815:     FieldPosition position = new FieldPosition(0);
 816:     
 817:     format (number, sbuf, position);
 818:     return sbuf.toString();
 819:   }
 820: 
 821:   // These field names are fixed by the serialization spec.
 822:   boolean groupingUsed;
 823:   int maximumFractionDigits;
 824:   private byte maxFractionDigits;
 825:   int maximumIntegerDigits;
 826:   private byte maxIntegerDigits;
 827:   int minimumFractionDigits;
 828:   private byte minFractionDigits;
 829:   int minimumIntegerDigits;
 830:   private byte minIntegerDigits;
 831:   boolean parseIntegerOnly;
 832:   private int serialVersionOnStream;
 833:   private static final long serialVersionUID = -2308460125733713944L;
 834: 
 835:   private void readObject(ObjectInputStream stream)
 836:     throws IOException, ClassNotFoundException
 837:   {
 838:     stream.defaultReadObject();
 839:     if (serialVersionOnStream < 1)
 840:       {
 841:         maximumFractionDigits = maxFractionDigits;
 842:     maximumIntegerDigits = maxIntegerDigits;
 843:     minimumFractionDigits = minFractionDigits;
 844:     minimumIntegerDigits = minIntegerDigits;
 845:     serialVersionOnStream = 1;
 846:       }
 847:   }
 848: 
 849:   private void writeObject(ObjectOutputStream stream) throws IOException
 850:   {
 851:     maxFractionDigits = maximumFractionDigits < Byte.MAX_VALUE ?
 852:       (byte) maximumFractionDigits : Byte.MAX_VALUE;
 853:     maxIntegerDigits = maximumIntegerDigits < Byte.MAX_VALUE ?
 854:       (byte) maximumIntegerDigits : Byte.MAX_VALUE;
 855:     minFractionDigits = minimumFractionDigits < Byte.MAX_VALUE ?
 856:       (byte) minimumFractionDigits : Byte.MAX_VALUE;
 857:     minIntegerDigits = minimumIntegerDigits < Byte.MAX_VALUE ?
 858:       (byte) minimumIntegerDigits : Byte.MAX_VALUE;
 859:     serialVersionOnStream = 1;
 860:     stream.defaultWriteObject();
 861:   }
 862: 
 863:   /**
 864:    * Returns the currency used by this number format when formatting currency
 865:    * values.
 866:    *
 867:    * The default implementation throws UnsupportedOperationException.
 868:    *
 869:    * @return The used currency object, or null.
 870:    *
 871:    * @throws UnsupportedOperationException If the number format class doesn't
 872:    * implement currency formatting.
 873:    *
 874:    * @since 1.4
 875:    */
 876:   public Currency getCurrency()
 877:   {
 878:     throw new UnsupportedOperationException();
 879:   }
 880: 
 881:   /**
 882:    * Sets the currency used by this number format when formatting currency
 883:    * values.
 884:    *
 885:    * The default implementation throws UnsupportedOperationException.
 886:    *
 887:    * @param currency The new currency to be used by this number format.
 888:    *
 889:    * @throws NullPointerException If currenc is null.
 890:    * @throws UnsupportedOperationException If the number format class doesn't
 891:    * implement currency formatting.
 892:    *
 893:    * @since 1.4
 894:    */
 895:   public void setCurrency(Currency currency)
 896:   {
 897:     if (currency == null)
 898:       throw new NullPointerException("currency may not be null");
 899:     
 900:     throw new UnsupportedOperationException();
 901:   }
 902: }