001    /* DecimalFormatSymbols.java -- Format symbols used by DecimalFormat
002       Copyright (C) 1999, 2000, 2001, 2004, 2007 Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010     
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    
039    package java.text;
040    
041    import gnu.java.locale.LocaleHelper;
042    
043    import java.io.IOException;
044    import java.io.ObjectInputStream;
045    import java.io.Serializable;
046    
047    import java.text.spi.DecimalFormatSymbolsProvider;
048    
049    import java.util.Currency;
050    import java.util.Locale;
051    import java.util.MissingResourceException;
052    import java.util.ResourceBundle;
053    import java.util.ServiceLoader;
054    
055    /**
056     * This class is a container for the symbols used by 
057     * <code>DecimalFormat</code> to format numbers and currency.  These are
058     * normally handled automatically, but an application can override
059     * values as desired using this class.
060     *
061     * @author Tom Tromey (tromey@cygnus.com)
062     * @author Aaron M. Renn (arenn@urbanophile.com)
063     * @date February 24, 1999
064     */
065    /* Written using "Java Class Libraries", 2nd edition, plus online
066     * API docs for JDK 1.2 from http://www.javasoft.com.
067     * Status:  Believed complete and correct to 1.2.
068     */
069    public final class DecimalFormatSymbols implements Cloneable, Serializable
070    {
071      public Object clone ()
072      {
073        try
074          {
075            return super.clone ();
076          }
077        catch(CloneNotSupportedException e)
078          {
079            return null;
080          }
081      }
082    
083      /**
084       * This method initializes a new instance of
085       * <code>DecimalFormatSymbols</code> for the default locale.
086       * This constructor only obtains instances using the runtime's resources;
087       * to also include {@link java.text.spi.DateFormatSymbolsProvider} instances,
088       * call {@link #getInstance()} instead.
089       *
090       * @see #getInstance()
091       */
092      public DecimalFormatSymbols ()
093      {
094        this (Locale.getDefault());
095      }
096    
097      private String safeGetString(ResourceBundle bundle,
098                                   String name, String def)
099      {
100        if (bundle != null)
101          {
102            try
103              {
104                return bundle.getString(name);
105              }
106            catch (MissingResourceException x)
107              {
108              }
109          }
110        return def;
111      }
112    
113      private char safeGetChar(ResourceBundle bundle,
114                               String name, char def)
115      {
116        String r = null;
117        if (bundle != null)
118          {
119            try
120              {
121                r = bundle.getString(name);
122              }
123            catch (MissingResourceException x)
124              {
125              }
126          }
127        if (r == null || r.length() < 1)
128          return def;
129        return r.charAt(0);
130      }
131    
132      /**
133       * This method initializes a new instance of
134       * <code>DecimalFormatSymbols</code> for the specified locale.
135       * <strong>Note</strong>: if the locale does not have an associated
136       * <code>Currency</code> instance, the currency symbol and
137       * international currency symbol will be set to the strings "?"
138       * and "XXX" respectively.  This generally happens with language
139       * locales (those with no specified country), such as
140       * <code>Locale.ENGLISH</code>.  This constructor only obtains
141       * instances using the runtime's resources; to also include
142       * {@link java.text.spi.DecimalFormatSymbolsProvider} instances,
143       * call {@link #getInstance(java.util.Locale)} instead.
144       *
145       * @param loc The local to load symbols for.
146       * @throws NullPointerException if the locale is null.
147       * @see #getInstance(java.util.Locale)
148       */
149      public DecimalFormatSymbols (Locale loc)
150      {
151        ResourceBundle res;
152        try
153          {
154            res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
155                    loc, ClassLoader.getSystemClassLoader());
156          }
157        catch (MissingResourceException x)
158          {
159            res = null;
160          }
161        currency = Currency.getInstance("XXX");
162        currencySymbol = "?";
163        intlCurrencySymbol = "XXX";
164        try
165          {
166            Currency localeCurrency = Currency.getInstance(loc);
167            if (localeCurrency != null)
168              {
169                setCurrency(localeCurrency);
170              }
171          }
172        catch(IllegalArgumentException exception)
173          {
174            /* Locale has an invalid currency */
175          }
176        decimalSeparator = safeGetChar (res, "decimalSeparator", '.');
177        digit = safeGetChar (res, "digit", '#');
178        exponential = safeGetChar (res, "exponential", 'E');
179        groupingSeparator = safeGetChar (res, "groupingSeparator", ',');
180        infinity = safeGetString (res, "infinity", "\u221e");
181        try
182          {
183            monetarySeparator = safeGetChar (res, "monetarySeparator", '.');
184          }
185        catch (MissingResourceException x)
186          {
187            monetarySeparator = decimalSeparator;
188          }
189        minusSign = safeGetChar (res, "minusSign", '-');
190        NaN = safeGetString (res, "NaN", "\ufffd");
191        patternSeparator = safeGetChar (res, "patternSeparator", ';');
192        percent = safeGetChar (res, "percent", '%');
193        perMill = safeGetChar (res, "perMill", '\u2030');
194        zeroDigit = safeGetChar (res, "zeroDigit", '0');
195        locale = loc;
196      }
197    
198      /**
199       * This method this this object for equality against the specified object.
200       * This will be true if and only if the following criteria are met with
201       * regard to the specified object:
202       * <p>
203       * <ul>
204       * <li>It is not <code>null</code>.</li>
205       * <li>It is an instance of <code>DecimalFormatSymbols</code>.</li>
206       * <li>All of its symbols are identical to the symbols in this object.</li>
207       * </ul>
208       *
209       * @return <code>true</code> if the specified object is equal to this
210       * object, <code>false</code> otherwise.
211       */
212      public boolean equals (Object obj)
213      {
214        if (! (obj instanceof DecimalFormatSymbols))
215          return false;
216        DecimalFormatSymbols dfs = (DecimalFormatSymbols) obj;
217        return (currencySymbol.equals(dfs.currencySymbol)
218                && decimalSeparator == dfs.decimalSeparator
219                && digit == dfs.digit
220                && exponential == dfs.exponential
221                && groupingSeparator == dfs.groupingSeparator
222                && infinity.equals(dfs.infinity)
223                && intlCurrencySymbol.equals(dfs.intlCurrencySymbol)
224                && minusSign == dfs.minusSign
225                && monetarySeparator == dfs.monetarySeparator
226                && NaN.equals(dfs.NaN)
227                && patternSeparator == dfs.patternSeparator
228                && percent == dfs.percent
229                && perMill == dfs.perMill
230                && zeroDigit == dfs.zeroDigit);
231      }
232    
233      /**
234       * Returns the currency corresponding to the currency symbol stored
235       * in the instance of <code>DecimalFormatSymbols</code>.
236       *
237       * @return An instance of <code>Currency</code> which matches
238       *         the currency used, or null if there is no corresponding
239       *         instance.
240       */
241      public Currency getCurrency ()
242      {
243        return currency;
244      }
245    
246      /**
247       * This method returns the currency symbol in local format.  For example,
248       * "$" for Canadian dollars.
249       *
250       * @return The currency symbol in local format.
251       */
252      public String getCurrencySymbol ()
253      {
254        return currencySymbol;
255      }
256    
257      /**
258       * This method returns the character used as the decimal point.
259       *
260       * @return The character used as the decimal point.
261       */
262      public char getDecimalSeparator ()
263      {
264        return decimalSeparator;
265      }
266    
267      /**
268       * This method returns the character used to represent a digit in a
269       * format pattern string.
270       *
271       * @return The character used to represent a digit in a format
272       * pattern string. 
273       */
274      public char getDigit ()
275      {
276        return digit;
277      }
278    
279      // This is our own extension.
280      char getExponential ()
281      {
282        return exponential;
283      }
284    
285      /**
286       * This method sets the character used to separate groups of digits.  For
287       * example, the United States uses a comma (,) to separate thousands in
288       * a number.
289       *
290       * @return The character used to separate groups of digits.
291       */
292      public char getGroupingSeparator ()
293      {
294        return groupingSeparator;
295      }
296    
297      /**
298       * This method returns the character used to represent infinity.
299       *
300       * @return The character used to represent infinity.
301       */
302      public String getInfinity ()
303      {
304        return infinity;
305      }
306    
307      /**
308       * This method returns the currency symbol in international format.  For
309       * example, "C$" for Canadian dollars.
310       *
311       * @return The currency symbol in international format.
312       */
313      public String getInternationalCurrencySymbol ()
314      {
315        return intlCurrencySymbol;
316      }
317    
318      /**
319       * This method returns the character used to represent the minus sign.
320       *
321       * @return The character used to represent the minus sign.
322       */
323      public char getMinusSign ()
324      {
325        return minusSign;
326      }
327    
328      /**
329       * This method returns the character used to represent the decimal
330       * point for currency values.
331       *
332       * @return The decimal point character used in currency values.
333       */
334      public char getMonetaryDecimalSeparator ()
335      {
336        return monetarySeparator;
337      }
338    
339      /**
340       * This method returns the string used to represent the NaN (not a number)
341       * value.
342       *
343       * @return The string used to represent NaN
344       */
345      public String getNaN ()
346      {
347        return NaN;
348      }
349    
350      /**
351       * This method returns the character used to separate positive and negative
352       * subpatterns in a format pattern.
353       *
354       * @return The character used to separate positive and negative subpatterns
355       * in a format pattern.
356       */
357      public char getPatternSeparator ()
358      {
359        return patternSeparator;
360      }
361    
362      /**
363       * This method returns the character used as the percent sign.
364       *
365       * @return The character used as the percent sign.
366       */
367      public char getPercent ()
368      {
369        return percent;
370      }
371    
372      /**
373       * This method returns the character used as the per mille character.
374       *
375       * @return The per mille character.
376       */
377      public char getPerMill ()
378      {
379        return perMill;
380      }
381    
382      /**
383       * This method returns the character used to represent the digit zero.
384       *
385       * @return The character used to represent the digit zero.
386       */
387      public char getZeroDigit ()
388      {
389        return zeroDigit;
390      }
391    
392      /**
393       * This method returns a hash value for this object.
394       *
395       * @return A hash value for this object.
396       */
397      public int hashCode ()
398      {
399        // Compute based on zero digit, grouping separator, and decimal
400        // separator -- JCL book.  This probably isn't a very good hash
401        // code.
402        return zeroDigit << 16 + groupingSeparator << 8 + decimalSeparator;
403      }
404    
405      /**
406       * This method sets the currency symbol and ISO 4217 currency
407       * code to the values obtained from the supplied currency.
408       *
409       * @param currency the currency from which to obtain the values.
410       * @throws NullPointerException if the currency is null.
411       */
412      public void setCurrency (Currency currency)
413      {
414        setCurrencySymbol (currency.getSymbol());
415        this.currency = currency;
416      }
417    
418      /**
419       * This method sets the currency symbol to the specified value.
420       *
421       * @param currency The new currency symbol
422       */
423      public void setCurrencySymbol (String currency)
424      {
425        currencySymbol = currency;
426      }
427    
428      /**
429       * This method sets the decimal point character to the specified value.
430       *
431       * @param decimalSep The new decimal point character
432       */
433      public void setDecimalSeparator (char decimalSep)
434      {
435        decimalSeparator = decimalSep;
436      }
437    
438      /**
439       * This method sets the character used to represents a digit in a format
440       * string to the specified value.
441       *
442       * @param digit The character used to represent a digit in a format pattern.
443       */
444      public void setDigit (char digit)
445      {
446        this.digit = digit;
447      }
448    
449      // This is our own extension.
450      void setExponential (char exp)
451      {
452        exponential = exp;
453      }
454    
455      /**
456       * This method sets the character used to separate groups of digits.
457       *
458       * @param groupSep The character used to separate groups of digits.
459       */
460      public void setGroupingSeparator (char groupSep)
461      {
462        groupingSeparator = groupSep;
463      }
464    
465      /**
466       * This method sets the string used to represents infinity.
467       *
468       * @param infinity The string used to represent infinity.
469       */
470      public void setInfinity (String infinity)
471      {
472        this.infinity = infinity;
473      }
474    
475      /**
476       * This method sets the international currency symbol to the
477       * specified value. If a valid <code>Currency</code> instance
478       * exists for the international currency code, then this is
479       * used for the currency attribute, and the currency symbol
480       * is set to the corresponding value from this instance.
481       * Otherwise, the currency attribute is set to null and the
482       * symbol is left unmodified. 
483       *
484       * @param currencyCode The new international currency symbol.
485       */
486      public void setInternationalCurrencySymbol (String currencyCode)
487      {
488        intlCurrencySymbol = currencyCode;
489        try
490          {
491            currency = Currency.getInstance(currencyCode);
492          }
493        catch (IllegalArgumentException exception)
494          {
495            currency = null;
496          }
497        if (currency != null)
498          {
499            setCurrencySymbol(currency.getSymbol(locale));
500          }
501      }
502    
503      /**
504       * This method sets the character used to represent the minus sign.
505       *
506       * @param minusSign The character used to represent the minus sign.
507       */
508      public void setMinusSign (char minusSign)
509      {
510        this.minusSign = minusSign;
511      }
512    
513      /**
514       * This method sets the character used for the decimal point in currency
515       * values.
516       *
517       * @param decimalSep The decimal point character used in currency values. 
518       */
519      public void setMonetaryDecimalSeparator (char decimalSep)
520      {
521        monetarySeparator = decimalSep;
522      }
523    
524      /**
525       * This method sets the string used to represent the NaN (not a
526       * number) value. 
527       *
528       * @param nan The string used to represent NaN
529       */
530      public void setNaN (String nan)
531      {
532        NaN = nan;
533      }
534    
535      /**
536       * This method sets the character used to separate positive and negative
537       * subpatterns in a format pattern.
538       *
539       * @param patternSep The character used to separate positive and
540       * negative subpatterns in a format pattern.
541       */
542      public void setPatternSeparator (char patternSep)
543      {
544        patternSeparator = patternSep;
545      }
546    
547      /**
548       * This method sets the character used as the percent sign.
549       *
550       * @param percent  The character used as the percent sign.
551       */
552      public void setPercent (char percent)
553      {
554        this.percent = percent;
555      }
556    
557      /**
558       * This method sets the character used as the per mille character.
559       *
560       * @param perMill The per mille character.
561       */
562      public void setPerMill (char perMill)
563      {
564        this.perMill = perMill;
565      }
566    
567      /**
568       * This method sets the character used to represent the digit zero.
569       *
570       * @param zeroDigit The character used to represent the digit zero.
571       */
572      public void setZeroDigit (char zeroDigit)
573      {
574        this.zeroDigit = zeroDigit;
575      }
576    
577      /**
578       * @serial A string used for the local currency
579       */
580      private String currencySymbol;
581      /**
582       * @serial The <code>char</code> used to separate decimals in a number.
583       */
584      private char decimalSeparator;
585      /**
586       * @serial This is the <code>char</code> used to represent a digit in
587       * a format specification.
588       */
589      private char digit;
590      /**
591       * @serial This is the <code>char</code> used to represent the exponent
592       * separator in exponential notation.
593       */
594      private char exponential;
595      /**
596       * @serial This separates groups of thousands in numbers.
597       */
598      private char groupingSeparator;
599      /**
600       * @serial This string represents infinity.
601       */
602      private String infinity;
603      /**
604       * @serial This string represents the local currency in an international
605       * context, eg, "C$" for Canadian dollars.
606       */
607      private String intlCurrencySymbol;
608      /**
609       * @serial This is the character used to represent the minus sign.
610       */
611      private char minusSign;
612      /**
613       * @serial This character is used to separate decimals when formatting
614       * currency values.
615       */
616      private char monetarySeparator;
617      /**
618       * @serial This string is used the represent the Java NaN value for
619       * "not a number".
620       */
621      private String NaN;
622      /**
623       * @serial This is the character used to separate positive and negative
624       * subpatterns in a format pattern.
625       */
626      private char patternSeparator;
627      /**
628       * @serial This is the percent symbols
629       */
630      private char percent;
631      /**
632       * @serial This character is used for the mille percent sign.
633       */
634      private char perMill;
635      /**
636       * @serial This value represents the type of object being de-serialized.
637       * 0 indicates a pre-Java 1.1.6 version, 1 indicates 1.1.6 or later.
638       * 0 indicates a pre-Java 1.1.6 version, 1 indicates 1.1.6 or later,
639       * 2 indicates 1.4 or later
640        */
641      private int serialVersionOnStream = 2;
642      /**
643       * @serial This is the character used to represent 0.
644       */
645      private char zeroDigit;
646    
647      /**
648       * @serial The locale of these currency symbols.
649       */
650      private Locale locale;
651    
652      /**
653       * The currency used for the symbols in this instance.
654       * This is stored temporarily for efficiency reasons,
655       * as well as to ensure that the correct instance
656       * is restored from the currency code.
657       *
658       * @serial Ignored.
659       */
660      private transient Currency currency;
661    
662      private static final long serialVersionUID = 5772796243397350300L;
663    
664      private void readObject(ObjectInputStream stream)
665        throws IOException, ClassNotFoundException
666      {
667        stream.defaultReadObject();
668        if (serialVersionOnStream < 1)
669          {
670            monetarySeparator = decimalSeparator;
671            exponential = 'E';
672          }
673        if (serialVersionOnStream < 2)
674            locale = Locale.getDefault();
675    
676        serialVersionOnStream = 2;
677      }
678    
679      /**
680       * Returns a {@link DecimalFormatSymbols} instance for the
681       * default locale obtained from either the runtime itself
682       * or one of the installed
683       * {@link java.text.spi.DecimalFormatSymbolsProvider} instances.
684       * This is equivalent to calling
685       * <code>getInstance(Locale.getDefault())</code>.
686       * 
687       * @return a {@link DecimalFormatSymbols} instance for the default
688       *         locale.
689       * @since 1.6
690       */
691      public static final DecimalFormatSymbols getInstance()
692      {
693        return getInstance(Locale.getDefault());
694      }
695    
696      /**
697       * Returns a {@link DecimalFormatSymbols} instance for the
698       * specified locale obtained from either the runtime itself
699       * or one of the installed
700       * {@link java.text.spi.DecimalFormatSymbolsProvider} instances.
701       * 
702       * @param locale the locale for which an instance should be
703       *               returned.
704       * @return a {@link DecimalFormatSymbols} instance for the specified
705       *         locale.
706       * @throws NullPointerException if <code>locale</code> is
707       *                              <code>null</code>.
708       * @since 1.6
709       */
710      public static final DecimalFormatSymbols getInstance(Locale locale)
711      {
712        try
713          {
714            if (!locale.equals(Locale.ROOT))
715              ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
716                                       locale,
717                                       ClassLoader.getSystemClassLoader());
718            return new DecimalFormatSymbols(locale);        
719          }
720        catch (MissingResourceException x)
721          {
722            /* This means runtime support for the locale
723             * is not available, so we check providers. */
724          }
725        for (DecimalFormatSymbolsProvider p :
726               ServiceLoader.load(DecimalFormatSymbolsProvider.class))
727          {
728            for (Locale loc : p.getAvailableLocales())
729              {
730                if (loc.equals(locale))
731                  {
732                    DecimalFormatSymbols syms = p.getInstance(locale);
733                    if (syms != null)
734                      return syms;
735                    break;
736                  }
737              }
738          }
739        return getInstance(LocaleHelper.getFallbackLocale(locale));
740      }
741    
742    }