OSDN Git Service

80d5c136255b604c63637ae6c03e1ae223d1a145
[pf3gnuchains/gcc-fork.git] / libjava / java / text / NumberFormat.java
1 /* Copyright (C) 1998, 1999, 2000  Free Software Foundation
2
3    This file is part of libgcj.
4
5 This software is copyrighted work licensed under the terms of the
6 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
7 details.  */
8
9 package java.text;
10
11 import java.util.Locale;
12 import java.util.ResourceBundle;
13 import java.util.MissingResourceException;
14 import java.io.ObjectInputStream;
15 import java.io.ObjectOutputStream;
16 import java.io.IOException;
17
18 /**
19  * @author Tom Tromey <tromey@cygnus.com>
20  * @date March 4, 1999
21  */
22 /* Written using "Java Class Libraries", 2nd edition, plus online
23  * API docs for JDK 1.2 from http://www.javasoft.com.
24  * Status:  Believed complete and correct to 1.2, except getAvailableLocales.
25  */
26
27 public abstract class NumberFormat extends Format implements Cloneable
28 {
29   public static final int INTEGER_FIELD = 0;
30   public static final int FRACTION_FIELD = 1;
31
32   public final String format (long number)
33     {
34       StringBuffer sbuf = new StringBuffer(50);
35       format (number, sbuf, null);
36       return sbuf.toString();
37     }
38
39   public final StringBuffer format (Object obj, StringBuffer sbuf,
40                                     FieldPosition pos)
41     {
42       if (obj instanceof Number)
43         return format(((Number) obj).doubleValue(), sbuf, pos);
44       else
45         throw new IllegalArgumentException 
46           ("Cannot format given Object as a Number");
47     }
48
49   public abstract StringBuffer format (double number,
50                                        StringBuffer sbuf, FieldPosition pos);
51
52   public abstract StringBuffer format (long number,
53                                        StringBuffer sbuf, FieldPosition pos);
54
55   public Object clone ()
56   {
57     // We know the superclass just uses Object's generic cloner.
58     // Why not just inherit?  Because the online docs specify that
59     // this method exists for this class.
60     return super.clone ();
61   }
62
63   public boolean equals (Object obj)
64   {
65     if (! (obj instanceof NumberFormat))
66       return false;
67     NumberFormat nf = (NumberFormat) obj;
68     return (groupingUsed == nf.groupingUsed
69             && maximumFractionDigits == nf.maximumFractionDigits
70             && maximumIntegerDigits == nf.maximumIntegerDigits
71             && minimumFractionDigits == nf.minimumFractionDigits
72             && minimumIntegerDigits == nf.minimumIntegerDigits
73             && parseIntegerOnly == nf.parseIntegerOnly);
74   }
75
76   public static Locale[] getAvailableLocales ()
77     {
78       // FIXME.
79       return null;
80     }
81
82   private static final NumberFormat computeInstance (Locale loc,
83                                                      String resource,
84                                                      String def)
85     {
86       ResourceBundle res;
87       try
88         {
89           res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc);
90         }
91       catch (MissingResourceException x)
92         {
93           res = null;
94         }
95       String fmt;
96       try
97         {
98           fmt = res == null ? def : res.getString(resource);
99         }
100       catch (MissingResourceException x)
101         {
102           fmt = def;
103         }
104       DecimalFormatSymbols dfs = new DecimalFormatSymbols (loc);
105       return new DecimalFormat (fmt, dfs);
106     }
107
108   public static final NumberFormat getCurrencyInstance ()
109     {
110       return getCurrencyInstance (Locale.getDefault());
111     }
112
113   public static NumberFormat getCurrencyInstance (Locale loc)
114     {
115       return computeInstance (loc, "currencyFormat", "$#,##0.00;($#,##0.00)");
116     }
117
118   public static final NumberFormat getInstance ()
119     {
120       return getInstance (Locale.getDefault());
121     }
122
123   public static NumberFormat getInstance (Locale loc)
124     {
125       // For now always return a number instance.
126       return getNumberInstance (loc);
127     }
128
129   public int getMaximumFractionDigits ()
130     {
131       return maximumFractionDigits;
132     }
133
134   public int getMaximumIntegerDigits ()
135     {
136       return maximumIntegerDigits;
137     }
138
139   public int getMinimumFractionDigits ()
140     {
141       return minimumFractionDigits;
142     }
143
144   public int getMinimumIntegerDigits ()
145     {
146       return minimumIntegerDigits;
147     }
148
149   public static final NumberFormat getNumberInstance ()
150     {
151       return getNumberInstance (Locale.getDefault());
152     }
153
154   public static NumberFormat getNumberInstance (Locale loc)
155     {
156       return computeInstance (loc, "numberFormat", "#,##0.###");
157     }
158
159   public static final NumberFormat getPercentInstance ()
160     {
161       return getPercentInstance (Locale.getDefault());
162     }
163
164   public static NumberFormat getPercentInstance (Locale loc)
165     {
166       return computeInstance (loc, "percentFormat", "#,##0%");
167     }
168
169   public int hashCode ()
170     {
171       int hash = super.hashCode();
172       hash ^= (maximumFractionDigits + maximumIntegerDigits
173                + minimumFractionDigits + minimumIntegerDigits);
174       if (groupingUsed)
175         hash ^= 0xf0f0;
176       if (parseIntegerOnly)
177         hash ^= 0x0f0f;
178       return hash;
179     }
180
181   public boolean isGroupingUsed ()
182     {
183       return groupingUsed;
184     }
185
186   public boolean isParseIntegerOnly ()
187     {
188       return parseIntegerOnly;
189     }
190
191   public NumberFormat ()
192     {
193     }
194
195   public abstract Number parse (String sourceStr, ParsePosition pos);
196
197   public Number parse (String sourceStr) throws ParseException
198     {
199       ParsePosition pp = new ParsePosition (0);
200       Number r = parse (sourceStr, pp);
201       if (r == null)
202         {
203           int index = pp.getErrorIndex();
204           if (index < 0)
205             index = pp.getIndex();
206           throw new ParseException ("couldn't parse number", index);
207         }
208       return r;
209     }
210
211   public final Object parseObject (String sourceStr, ParsePosition pos)
212     {
213       return parse (sourceStr, pos);
214     }
215
216   public void setGroupingUsed (boolean newValue)
217     {
218       groupingUsed = newValue;
219     }
220
221   public void setMaximumFractionDigits (int newValue)
222     {
223       maximumFractionDigits = newValue;
224     }
225
226   public void setMaximumIntegerDigits (int newValue)
227     {
228       maximumIntegerDigits = newValue;
229     }
230
231   public void setMinimumFractionDigits (int newValue)
232     {
233       minimumFractionDigits = newValue;
234     }
235
236   public void setMinimumIntegerDigits (int newValue)
237     {
238       minimumIntegerDigits = newValue;
239     }
240
241   public void setParseIntegerOnly (boolean value)
242     {
243       parseIntegerOnly = value;
244     }
245
246   public final String format (double number)
247     {
248       StringBuffer sbuf = new StringBuffer(50);
249       format (number, sbuf, null);
250       return sbuf.toString();
251     }
252
253   // These field names are fixed by the serialization spec.
254   boolean groupingUsed;
255   int maximumFractionDigits;
256   private byte maxFractionDigits;
257   int maximumIntegerDigits;
258   private byte maxIntegerDigits;
259   int minimumFractionDigits;
260   private byte minFractionDigits;
261   int minimumIntegerDigits;
262   private byte minIntegerDigits;
263   boolean parseIntegerOnly;
264   private int serialVersionOnStream;
265   private static final long serialVersionUID = -2308460125733713944L;
266
267   private void readObject(ObjectInputStream stream)
268     throws IOException, ClassNotFoundException
269   {
270     stream.defaultReadObject();
271     if (serialVersionOnStream < 1)
272       {
273         maximumFractionDigits = maxFractionDigits;
274         maximumIntegerDigits = maxIntegerDigits;
275         minimumFractionDigits = minFractionDigits;
276         minimumIntegerDigits = minIntegerDigits;
277         serialVersionOnStream = 1;
278       }
279   }
280
281   private void writeObject(ObjectOutputStream stream) throws IOException
282   {
283     maxFractionDigits = maximumFractionDigits < Byte.MAX_VALUE ?
284       (byte) maximumFractionDigits : Byte.MAX_VALUE;
285     maxIntegerDigits = maximumIntegerDigits < Byte.MAX_VALUE ?
286       (byte) maximumIntegerDigits : Byte.MAX_VALUE;
287     minFractionDigits = minimumFractionDigits < Byte.MAX_VALUE ?
288       (byte) minimumFractionDigits : Byte.MAX_VALUE;
289     minIntegerDigits = minimumIntegerDigits < Byte.MAX_VALUE ?
290       (byte) minimumIntegerDigits : Byte.MAX_VALUE;
291     serialVersionOnStream = 1;
292     stream.defaultWriteObject();
293   }
294 }