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