OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [java/] [text/] [NumberFormat.java] - Blame information for rev 791

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 771 jeremybenn
/* 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
    @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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.