OSDN Git Service

* java/text/SimpleDateFormat.java: Re-merged with Classpath.
[pf3gnuchains/gcc-fork.git] / libjava / java / text / DecimalFormatSymbols.java
1 /* DecimalFormatSymbols.java -- Format symbols used by DecimalFormat
2    Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
3
4 This file is part of GNU Classpath.
5
6 GNU Classpath is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10  
11 GNU Classpath is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Classpath; see the file COPYING.  If not, write to the
18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA.
20
21 As a special exception, if you link this library with other files to
22 produce an executable, this library does not by itself cause the
23 resulting executable to be covered by the GNU General Public License.
24 This exception does not however invalidate any other reasons why the
25 executable file might be covered by the GNU General Public License. */
26
27
28 package java.text;
29
30 import java.io.Serializable;
31 import java.util.Locale;
32 import java.util.MissingResourceException;
33 import java.util.ResourceBundle;
34 import java.io.ObjectInputStream;
35 import java.io.IOException;
36
37 /**
38  * This class is a container for the symbols used by 
39  * <code>DecimalFormat</code> to format numbers and currency.  These are
40  * normally handled automatically, but an application can override
41  * values as desired using this class.
42  *
43  * @author Tom Tromey <tromey@cygnus.com>
44  * @author Aaron M. Renn (arenn@urbanophile.com)
45  * @date February 24, 1999
46  */
47 /* Written using "Java Class Libraries", 2nd edition, plus online
48  * API docs for JDK 1.2 from http://www.javasoft.com.
49  * Status:  Believed complete and correct to 1.2.
50  */
51 public final class DecimalFormatSymbols implements Cloneable, Serializable
52 {
53   public Object clone ()
54   {
55     try
56       {
57         return super.clone ();
58       }
59     catch(CloneNotSupportedException e)
60       {
61         return null;
62       }
63   }
64
65   /**
66    * This method initializes a new instance of
67    * <code>DecimalFormatSymbols</code> for the default locale.
68    */
69   public DecimalFormatSymbols ()
70   {
71     this (Locale.getDefault());
72   }
73
74   private final String safeGetString (ResourceBundle bundle,
75                                       String name, String def)
76   {
77     if (bundle != null)
78       {
79         try
80           {
81             return bundle.getString(name);
82           }
83         catch (MissingResourceException x)
84           {
85           }
86       }
87     return def;
88   }
89
90   private final char safeGetChar (ResourceBundle bundle,
91                                   String name, char def)
92   {
93     String r = null;
94     if (bundle != null)
95       {
96         try
97           {
98             r = bundle.getString(name);
99           }
100         catch (MissingResourceException x)
101           {
102           }
103       }
104     if (r == null || r.length() < 1)
105       return def;
106     return r.charAt(0);
107   }
108
109   /**
110    * This method initializes a new instance of
111    * <code>DecimalFormatSymbols</code> for the specified locale.
112    *
113    * @param locale The local to load symbols for.
114    */
115   public DecimalFormatSymbols (Locale loc)
116   {
117     ResourceBundle res;
118     try
119       {
120         res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
121                                        loc);
122       }
123     catch (MissingResourceException x)
124       {
125         res = null;
126       }
127     currencySymbol = safeGetString (res, "currencySymbol", "$");
128     decimalSeparator = safeGetChar (res, "decimalSeparator", '.');
129     digit = safeGetChar (res, "digit", '#');
130     exponential = safeGetChar (res, "exponential", 'E');
131     groupingSeparator = safeGetChar (res, "groupingSeparator", ',');
132     infinity = safeGetString (res, "infinity", "\u221e");
133     // FIXME: default?
134     intlCurrencySymbol = safeGetString (res, "intlCurrencySymbol", "$");
135     try
136       {
137         monetarySeparator = safeGetChar (res, "monetarySeparator", '.');
138       }
139     catch (MissingResourceException x)
140       {
141         monetarySeparator = decimalSeparator;
142       }
143     minusSign = safeGetChar (res, "minusSign", '-');
144     NaN = safeGetString (res, "NaN", "\ufffd");
145     patternSeparator = safeGetChar (res, "patternSeparator", ';');
146     percent = safeGetChar (res, "percent", '%');
147     perMill = safeGetChar (res, "perMill", '\u2030');
148     zeroDigit = safeGetChar (res, "zeroDigit", '0');
149   }
150
151   /**
152    * This method this this object for equality against the specified object.
153    * This will be true if and only if the following criteria are met with
154    * regard to the specified object:
155    * <p>
156    * <ul>
157    * <li>It is not <code>null</code>.
158    * <li>It is an instance of <code>DecimalFormatSymbols</code>
159    * <li>All of its symbols are identical to the symbols in this object.
160    * </ul>
161    *
162    * @return <code>true</code> if the specified object is equal to this
163    * object, <code>false</code> otherwise.
164    */
165   public boolean equals (Object obj)
166   {
167     if (! (obj instanceof DecimalFormatSymbols))
168       return false;
169     DecimalFormatSymbols dfs = (DecimalFormatSymbols) obj;
170     return (currencySymbol.equals(dfs.currencySymbol)
171             && decimalSeparator == dfs.decimalSeparator
172             && digit == dfs.digit
173             && exponential == dfs.exponential
174             && groupingSeparator == dfs.groupingSeparator
175             && infinity.equals(dfs.infinity)
176             && intlCurrencySymbol.equals(dfs.intlCurrencySymbol)
177             && minusSign == dfs.minusSign
178             && monetarySeparator == dfs.monetarySeparator
179             && NaN.equals(dfs.NaN)
180             && patternSeparator == dfs.patternSeparator
181             && percent == dfs.percent
182             && perMill == dfs.perMill
183             && zeroDigit == dfs.zeroDigit);
184   }
185
186   /**
187    * This method returns the currency symbol in local format.  For example,
188    * "$" for Canadian dollars.
189    *
190    * @return The currency symbol in local format.
191    */
192   public String getCurrencySymbol ()
193   {
194     return currencySymbol;
195   }
196
197   /**
198    * This method returns the character used as the decimal point.
199    *
200    * @return The character used as the decimal point.
201    */
202   public char getDecimalSeparator ()
203   {
204     return decimalSeparator;
205   }
206
207   /**
208    * This method returns the character used to represent a digit in a
209    * format pattern string.
210    *
211    * @return The character used to represent a digit in a format
212    * pattern string. 
213    */
214   public char getDigit ()
215   {
216     return digit;
217   }
218
219   // This is our own extension.
220   char getExponential ()
221   {
222     return exponential;
223   }
224
225   /**
226    * This method sets the character used to separate groups of digits.  For
227    * example, the United States uses a comma (,) to separate thousands in
228    * a number.
229    *
230    * @return The character used to separate groups of digits.
231    */
232   public char getGroupingSeparator ()
233   {
234     return groupingSeparator;
235   }
236
237   /**
238    * This method returns the character used to represent infinity.
239    *
240    * @return The character used to represent infinity.
241    */
242   public String getInfinity ()
243   {
244     return infinity;
245   }
246
247   /**
248    * This method returns the currency symbol in international format.  For
249    * example, "C$" for Canadian dollars.
250    *
251    * @return The currency symbol in international format.
252    */
253   public String getInternationalCurrencySymbol ()
254   {
255     return intlCurrencySymbol;
256   }
257
258   /**
259    * This method returns the character used to represent the minus sign.
260    *
261    * @return The character used to represent the minus sign.
262    */
263   public char getMinusSign ()
264   {
265     return minusSign;
266   }
267
268   /**
269    * This method returns the character used to represent the decimal
270    * point for currency values.
271    *
272    * @return The decimal point character used in currency values.
273    */
274   public char getMonetaryDecimalSeparator ()
275   {
276     return monetarySeparator;
277   }
278
279   /**
280    * This method returns the string used to represent the NaN (not a number)
281    * value.
282    *
283    * @return The string used to represent NaN
284    */
285   public String getNaN ()
286   {
287     return NaN;
288   }
289
290   /**
291    * This method returns the character used to separate positive and negative
292    * subpatterns in a format pattern.
293    *
294    * @return The character used to separate positive and negative subpatterns
295    * in a format pattern.
296    */
297   public char getPatternSeparator ()
298   {
299     return patternSeparator;
300   }
301
302   /**
303    * This method returns the character used as the percent sign.
304    *
305    * @return The character used as the percent sign.
306    */
307   public char getPercent ()
308   {
309     return percent;
310   }
311
312   /**
313    * This method returns the character used as the per mille character.
314    *
315    * @return The per mille character.
316    */
317   public char getPerMill ()
318   {
319     return perMill;
320   }
321
322   /**
323    * This method returns the character used to represent the digit zero.
324    *
325    * @return The character used to represent the digit zero.
326    */
327   public char getZeroDigit ()
328   {
329     return zeroDigit;
330   }
331
332   /**
333    * This method returns a hash value for this object.
334    *
335    * @return A hash value for this object.
336    */
337   public int hashCode ()
338   {
339     // Compute based on zero digit, grouping separator, and decimal
340     // separator -- JCL book.  This probably isn't a very good hash
341     // code.
342     return zeroDigit << 16 + groupingSeparator << 8 + decimalSeparator;
343   }
344
345   /**
346    * This method sets the currency symbol to the specified value.
347    *
348    * @param currencySymbol The new currency symbol
349    */
350   public void setCurrencySymbol (String currency)
351   {
352     currencySymbol = currency;
353   }
354
355   /**
356    * This method sets the decimal point character to the specified value.
357    *
358    * @param decimalSeparator The new decimal point character
359    */
360   public void setDecimalSeparator (char decimalSep)
361   {
362     decimalSeparator = decimalSep;
363   }
364
365   /**
366    * This method sets the character used to represents a digit in a format
367    * string to the specified value.
368    *
369    * @param digit The character used to represent a digit in a format pattern.
370    */
371   public void setDigit (char digit)
372   {
373     this.digit = digit;
374   }
375
376   // This is our own extension.
377   void setExponential (char exp)
378   {
379     exponential = exp;
380   }
381
382   /**
383    * This method sets the character used to separate groups of digits.
384    *
385    * @param groupingSeparator The character used to separate groups of digits.
386    */
387   public void setGroupingSeparator (char groupSep)
388   {
389     groupingSeparator = groupSep;
390   }
391
392   /**
393    * This method sets the string used to represents infinity.
394    *
395    * @param infinity The string used to represent infinity.
396    */
397   public void setInfinity (String infinity)
398   {
399     this.infinity = infinity;
400   }
401
402   /**
403    * This method sets the international currency symbols to the
404    * specified value. 
405    *
406    * @param intlCurrencySymbol The new international currency symbol.
407    */
408   public void setInternationalCurrencySymbol (String currency)
409   {
410     intlCurrencySymbol = currency;
411   }
412
413   /**
414    * This method sets the character used to represent the minus sign.
415    *
416    * @param minusSign The character used to represent the minus sign.
417    */
418   public void setMinusSign (char minusSign)
419   {
420     this.minusSign = minusSign;
421   }
422
423   /**
424    * This method sets the character used for the decimal point in currency
425    * values.
426    *
427    * @param monetarySeparator The decimal point character used in
428    *                          currency values. 
429    */
430   public void setMonetaryDecimalSeparator (char decimalSep)
431   {
432     monetarySeparator = decimalSep;
433   }
434
435   /**
436    * This method sets the string used to represent the NaN (not a
437    * number) value. 
438    *
439    * @param NaN The string used to represent NaN
440    */
441   public void setNaN (String nan)
442   {
443     NaN = nan;
444   }
445
446   /**
447    * This method sets the character used to separate positive and negative
448    * subpatterns in a format pattern.
449    *
450    * @param patternSeparator The character used to separate positive and
451    * negative subpatterns in a format pattern.
452    */
453   public void setPatternSeparator (char patternSep)
454   {
455     patternSeparator = patternSep;
456   }
457
458   /**
459    * This method sets the character used as the percent sign.
460    *
461    * @param percent  The character used as the percent sign.
462    */
463   public void setPercent (char percent)
464   {
465     this.percent = percent;
466   }
467
468   /**
469    * This method sets the character used as the per mille character.
470    *
471    * @param perMill The per mille character.
472    */
473   public void setPerMill (char perMill)
474   {
475     this.perMill = perMill;
476   }
477
478   /**
479    * This method sets the charcter used to represen the digit zero.
480    *
481    * @param zeroDigit The character used to represent the digit zero.
482    */
483   public void setZeroDigit (char zeroDigit)
484   {
485     this.zeroDigit = zeroDigit;
486   }
487
488   /**
489    * @serial A string used for the local currency
490    */
491   private String currencySymbol;
492   /**
493    * @serial The <code>char</code> used to separate decimals in a number.
494    */
495   private char decimalSeparator;
496   /**
497    * @serial This is the <code>char</code> used to represent a digit in
498    * a format specification.
499    */
500   private char digit;
501   /**
502    * @serial This is the <code>char</code> used to represent the exponent
503    * separator in exponential notation.
504    */
505   private char exponential;
506   /**
507    * @serial This separates groups of thousands in numbers.
508    */
509   private char groupingSeparator;
510   /**
511    * @serial This string represents infinity.
512    */
513   private String infinity;
514   /**
515    * @serial This string represents the local currency in an international
516    * context, eg, "C$" for Canadian dollars.
517    */
518   private String intlCurrencySymbol;
519   /**
520    * @serial This is the character used to represent the minus sign.
521    */
522   private char minusSign;
523   /**
524    * @serial This character is used to separate decimals when formatting
525    * currency values.
526    */
527   private char monetarySeparator;
528   /**
529    * @serial This string is used the represent the Java NaN value for
530    * "not a number".
531    */
532   private String NaN;
533   /**
534    * @serial This is the character used to separate positive and negative
535    * subpatterns in a format pattern.
536    */
537   private char patternSeparator;
538   /**
539    * @serial This is the percent symbols
540    */
541   private char percent;
542   /**
543    * @serial This character is used for the mille percent sign.
544    */
545   private char perMill;
546   /**
547    * @serial This value represents the type of object being de-serialized.
548    * 0 indicates a pre-Java 1.1.6 version, 1 indicates 1.1.6 or later.
549    */
550   private int serialVersionOnStream = 1;
551   /**
552    * @serial This is the character used to represent 0.
553    */
554   private char zeroDigit;
555
556   private static final long serialVersionUID = 5772796243397350300L;
557
558   private void readObject(ObjectInputStream stream)
559     throws IOException, ClassNotFoundException
560   {
561     stream.defaultReadObject();
562     if (serialVersionOnStream < 1)
563       {
564         monetarySeparator = decimalSeparator;
565         exponential = 'E';
566         serialVersionOnStream = 1;
567       }
568   }
569 }