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