001/* DecimalFormatSymbols.java -- Format symbols used by DecimalFormat
002   Copyright (C) 1999, 2000, 2001, 2004, 2007 Free Software Foundation, Inc.
003
004This file is part of GNU Classpath.
005
006GNU Classpath is free software; you can redistribute it and/or modify
007it under the terms of the GNU General Public License as published by
008the Free Software Foundation; either version 2, or (at your option)
009any later version.
010 
011GNU Classpath is distributed in the hope that it will be useful, but
012WITHOUT ANY WARRANTY; without even the implied warranty of
013MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014General Public License for more details.
015
016You should have received a copy of the GNU General Public License
017along with GNU Classpath; see the file COPYING.  If not, write to the
018Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
01902110-1301 USA.
020
021Linking this library statically or dynamically with other modules is
022making a combined work based on this library.  Thus, the terms and
023conditions of the GNU General Public License cover the whole
024combination.
025
026As a special exception, the copyright holders of this library give you
027permission to link this library with independent modules to produce an
028executable, regardless of the license terms of these independent
029modules, and to copy and distribute the resulting executable under
030terms of your choice, provided that you also meet, for each linked
031independent module, the terms and conditions of the license of that
032module.  An independent module is a module which is not derived from
033or based on this library.  If you modify this library, you may extend
034this exception to your version of the library, but you are not
035obligated to do so.  If you do not wish to do so, delete this
036exception statement from your version. */
037
038
039package java.text;
040
041import gnu.java.locale.LocaleHelper;
042
043import java.io.IOException;
044import java.io.ObjectInputStream;
045import java.io.Serializable;
046
047import java.text.spi.DecimalFormatSymbolsProvider;
048
049import java.util.Currency;
050import java.util.Locale;
051import java.util.MissingResourceException;
052import java.util.ResourceBundle;
053import 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 */
072public 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}