1 /*
2 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
28 * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
29 *
30 * The original version of this source code and documentation is copyrighted
31 * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
32 * materials are provided under terms of a License Agreement between Taligent
33 * and Sun. This technology is protected by multiple US and International
34 * patents. This notice and attribution to Taligent may not be removed.
35 * Taligent is a registered trademark of Taligent, Inc.
36 *
37 */
38
39 package java.text;
40
41 import java.io.IOException;
42 import java.io.ObjectInputStream;
43 import java.io.Serializable;
44 import java.text.spi.DecimalFormatSymbolsProvider;
45 import java.util.ArrayList;
46 import java.util.Currency;
47 import java.util.List;
48 import java.util.Locale;
49 import java.util.MissingResourceException;
50 import java.util.ResourceBundle;
51 import java.util.concurrent.ConcurrentHashMap;
52 import java.util.concurrent.ConcurrentMap;
53 import sun.util.locale.provider.LocaleProviderAdapter;
54 import sun.util.locale.provider.LocaleServiceProviderPool;
55 import sun.util.locale.provider.ResourceBundleBasedAdapter;
56
57 /**
58 * This class represents the set of symbols (such as the decimal separator,
59 * the grouping separator, and so on) needed by <code>DecimalFormat</code>
60 * to format numbers. <code>DecimalFormat</code> creates for itself an instance of
61 * <code>DecimalFormatSymbols</code> from its locale data. If you need to change any
62 * of these symbols, you can get the <code>DecimalFormatSymbols</code> object from
63 * your <code>DecimalFormat</code> and modify it.
64 *
65 * @see java.util.Locale
66 * @see DecimalFormat
67 * @author Mark Davis
68 * @author Alan Liu
69 */
70
71 public class DecimalFormatSymbols implements Cloneable, Serializable {
72
73 /**
74 * Create a DecimalFormatSymbols object for the default
75 * {@link java.util.Locale.Category#FORMAT FORMAT} locale.
76 * This constructor can only construct instances for the locales
77 * supported by the Java runtime environment, not for those
78 * supported by installed
79 * {@link java.text.spi.DecimalFormatSymbolsProvider DecimalFormatSymbolsProvider}
80 * implementations. For full locale coverage, use the
81 * {@link #getInstance(Locale) getInstance} method.
82 * <p>This is equivalent to calling
83 * {@link #DecimalFormatSymbols(Locale)
84 * DecimalFormatSymbols(Locale.getDefault(Locale.Category.FORMAT))}.
85 * @see java.util.Locale#getDefault(java.util.Locale.Category)
86 * @see java.util.Locale.Category#FORMAT
87 */
88 public DecimalFormatSymbols() {
89 initialize( Locale.getDefault(Locale.Category.FORMAT) );
90 }
91
92 /**
93 * Create a DecimalFormatSymbols object for the given locale.
94 * This constructor can only construct instances for the locales
95 * supported by the Java runtime environment, not for those
96 * supported by installed
97 * {@link java.text.spi.DecimalFormatSymbolsProvider DecimalFormatSymbolsProvider}
98 * implementations. For full locale coverage, use the
99 * {@link #getInstance(Locale) getInstance} method.
100 * If the specified locale contains the {@link java.util.Locale#UNICODE_LOCALE_EXTENSION}
101 * for the numbering system, the instance is initialized with the specified numbering
102 * system if the JRE implementation supports it. For example,
103 * <pre>
104 * NumberFormat.getNumberInstance(Locale.forLanguageTag("th-TH-u-nu-thai"))
105 * </pre>
106 * This may return a {@code NumberFormat} instance with the Thai numbering system,
107 * instead of the Latin numbering system.
108 *
109 * @param locale the desired locale
110 * @exception NullPointerException if <code>locale</code> is null
111 */
112 public DecimalFormatSymbols( Locale locale ) {
113 initialize( locale );
114 }
115
116 /**
117 * Returns an array of all locales for which the
118 * <code>getInstance</code> methods of this class can return
119 * localized instances.
120 * The returned array represents the union of locales supported by the Java
121 * runtime and by installed
122 * {@link java.text.spi.DecimalFormatSymbolsProvider DecimalFormatSymbolsProvider}
123 * implementations. It must contain at least a <code>Locale</code>
124 * instance equal to {@link java.util.Locale#US Locale.US}.
125 *
126 * @return an array of locales for which localized
127 * <code>DecimalFormatSymbols</code> instances are available.
128 * @since 1.6
129 */
130 public static Locale[] getAvailableLocales() {
131 LocaleServiceProviderPool pool =
132 LocaleServiceProviderPool.getPool(DecimalFormatSymbolsProvider.class);
133 return pool.getAvailableLocales();
134 }
135
136 /**
137 * Gets the <code>DecimalFormatSymbols</code> instance for the default
138 * locale. This method provides access to <code>DecimalFormatSymbols</code>
139 * instances for locales supported by the Java runtime itself as well
140 * as for those supported by installed
141 * {@link java.text.spi.DecimalFormatSymbolsProvider
142 * DecimalFormatSymbolsProvider} implementations.
143 * <p>This is equivalent to calling
144 * {@link #getInstance(Locale)
145 * getInstance(Locale.getDefault(Locale.Category.FORMAT))}.
146 * @see java.util.Locale#getDefault(java.util.Locale.Category)
147 * @see java.util.Locale.Category#FORMAT
148 * @return a <code>DecimalFormatSymbols</code> instance.
149 * @since 1.6
150 */
151 public static final DecimalFormatSymbols getInstance() {
152 return getInstance(Locale.getDefault(Locale.Category.FORMAT));
153 }
154
155 /**
156 * Gets the <code>DecimalFormatSymbols</code> instance for the specified
157 * locale. This method provides access to <code>DecimalFormatSymbols</code>
158 * instances for locales supported by the Java runtime itself as well
159 * as for those supported by installed
160 * {@link java.text.spi.DecimalFormatSymbolsProvider
161 * DecimalFormatSymbolsProvider} implementations.
162 * If the specified locale contains the {@link java.util.Locale#UNICODE_LOCALE_EXTENSION}
163 * for the numbering system, the instance is initialized with the specified numbering
164 * system if the JRE implementation supports it. For example,
165 * <pre>
166 * NumberFormat.getNumberInstance(Locale.forLanguageTag("th-TH-u-nu-thai"))
167 * </pre>
168 * This may return a {@code NumberFormat} instance with the Thai numbering system,
169 * instead of the Latin numbering system.
170 *
171 * @param locale the desired locale.
172 * @return a <code>DecimalFormatSymbols</code> instance.
173 * @exception NullPointerException if <code>locale</code> is null
174 * @since 1.6
175 */
176 public static final DecimalFormatSymbols getInstance(Locale locale) {
177 LocaleProviderAdapter adapter;
178 adapter = LocaleProviderAdapter.getAdapter(DecimalFormatSymbolsProvider.class, locale);
179 DecimalFormatSymbolsProvider provider = adapter.getDecimalFormatSymbolsProvider();
180 DecimalFormatSymbols dfsyms = provider.getInstance(locale);
181 if (dfsyms == null) {
182 provider = LocaleProviderAdapter.forJRE().getDecimalFormatSymbolsProvider();
183 dfsyms = provider.getInstance(locale);
184 }
185 return dfsyms;
186 }
187
188 /**
189 * Gets the character used for zero. Different for Arabic, etc.
190 *
191 * @return the character used for zero
192 */
193 public char getZeroDigit() {
194 return zeroDigit;
195 }
196
197 /**
198 * Sets the character used for zero. Different for Arabic, etc.
199 *
200 * @param zeroDigit the character used for zero
201 */
202 public void setZeroDigit(char zeroDigit) {
203 this.zeroDigit = zeroDigit;
204 }
205
206 /**
207 * Gets the character used for thousands separator. Different for French, etc.
208 *
209 * @return the grouping separator
210 */
211 public char getGroupingSeparator() {
212 return groupingSeparator;
213 }
214
215 /**
216 * Sets the character used for thousands separator. Different for French, etc.
217 *
218 * @param groupingSeparator the grouping separator
219 */
220 public void setGroupingSeparator(char groupingSeparator) {
221 this.groupingSeparator = groupingSeparator;
222 }
223
224 /**
225 * Gets the character used for decimal sign. Different for French, etc.
226 *
227 * @return the character used for decimal sign
228 */
229 public char getDecimalSeparator() {
230 return decimalSeparator;
231 }
232
233 /**
234 * Sets the character used for decimal sign. Different for French, etc.
235 *
236 * @param decimalSeparator the character used for decimal sign
237 */
238 public void setDecimalSeparator(char decimalSeparator) {
239 this.decimalSeparator = decimalSeparator;
240 }
241
242 /**
243 * Gets the character used for per mille sign. Different for Arabic, etc.
244 *
245 * @return the character used for per mille sign
246 */
247 public char getPerMill() {
248 return perMill;
249 }
250
251 /**
252 * Sets the character used for per mille sign. Different for Arabic, etc.
253 *
254 * @param perMill the character used for per mille sign
255 */
256 public void setPerMill(char perMill) {
257 this.perMill = perMill;
258 }
259
260 /**
261 * Gets the character used for percent sign. Different for Arabic, etc.
262 *
263 * @return the character used for percent sign
264 */
265 public char getPercent() {
266 return percent;
267 }
268
269 /**
270 * Sets the character used for percent sign. Different for Arabic, etc.
271 *
272 * @param percent the character used for percent sign
273 */
274 public void setPercent(char percent) {
275 this.percent = percent;
276 }
277
278 /**
279 * Gets the character used for a digit in a pattern.
280 *
281 * @return the character used for a digit in a pattern
282 */
283 public char getDigit() {
284 return digit;
285 }
286
287 /**
288 * Sets the character used for a digit in a pattern.
289 *
290 * @param digit the character used for a digit in a pattern
291 */
292 public void setDigit(char digit) {
293 this.digit = digit;
294 }
295
296 /**
297 * Gets the character used to separate positive and negative subpatterns
298 * in a pattern.
299 *
300 * @return the pattern separator
301 */
302 public char getPatternSeparator() {
303 return patternSeparator;
304 }
305
306 /**
307 * Sets the character used to separate positive and negative subpatterns
308 * in a pattern.
309 *
310 * @param patternSeparator the pattern separator
311 */
312 public void setPatternSeparator(char patternSeparator) {
313 this.patternSeparator = patternSeparator;
314 }
315
316 /**
317 * Gets the string used to represent infinity. Almost always left
318 * unchanged.
319 *
320 * @return the string representing infinity
321 */
322 public String getInfinity() {
323 return infinity;
324 }
325
326 /**
327 * Sets the string used to represent infinity. Almost always left
328 * unchanged.
329 *
330 * @param infinity the string representing infinity
331 */
332 public void setInfinity(String infinity) {
333 this.infinity = infinity;
334 }
335
336 /**
337 * Gets the string used to represent "not a number". Almost always left
338 * unchanged.
339 *
340 * @return the string representing "not a number"
341 */
342 public String getNaN() {
343 return NaN;
344 }
345
346 /**
347 * Sets the string used to represent "not a number". Almost always left
348 * unchanged.
349 *
350 * @param NaN the string representing "not a number"
351 */
352 public void setNaN(String NaN) {
353 this.NaN = NaN;
354 }
355
356 /**
357 * Gets the character used to represent minus sign. If no explicit
358 * negative format is specified, one is formed by prefixing
359 * minusSign to the positive format.
360 *
361 * @return the character representing minus sign
362 */
363 public char getMinusSign() {
364 return minusSign;
365 }
366
367 /**
368 * Sets the character used to represent minus sign. If no explicit
369 * negative format is specified, one is formed by prefixing
370 * minusSign to the positive format.
371 *
372 * @param minusSign the character representing minus sign
373 */
374 public void setMinusSign(char minusSign) {
375 this.minusSign = minusSign;
376 }
377
378 /**
379 * Returns the currency symbol for the currency of these
380 * DecimalFormatSymbols in their locale.
381 *
382 * @return the currency symbol
383 * @since 1.2
384 */
385 public String getCurrencySymbol()
386 {
387 return currencySymbol;
388 }
389
390 /**
391 * Sets the currency symbol for the currency of these
392 * DecimalFormatSymbols in their locale.
393 *
394 * @param currency the currency symbol
395 * @since 1.2
396 */
397 public void setCurrencySymbol(String currency)
398 {
399 currencySymbol = currency;
400 }
401
402 /**
403 * Returns the ISO 4217 currency code of the currency of these
404 * DecimalFormatSymbols.
405 *
406 * @return the currency code
407 * @since 1.2
408 */
409 public String getInternationalCurrencySymbol()
410 {
411 return intlCurrencySymbol;
412 }
413
414 /**
415 * Sets the ISO 4217 currency code of the currency of these
416 * DecimalFormatSymbols.
417 * If the currency code is valid (as defined by
418 * {@link java.util.Currency#getInstance(java.lang.String) Currency.getInstance}),
419 * this also sets the currency attribute to the corresponding Currency
420 * instance and the currency symbol attribute to the currency's symbol
421 * in the DecimalFormatSymbols' locale. If the currency code is not valid,
422 * then the currency attribute is set to null and the currency symbol
423 * attribute is not modified.
424 *
425 * @param currencyCode the currency code
426 * @see #setCurrency
427 * @see #setCurrencySymbol
428 * @since 1.2
429 */
430 public void setInternationalCurrencySymbol(String currencyCode)
431 {
432 intlCurrencySymbol = currencyCode;
433 currency = null;
434 if (currencyCode != null) {
435 try {
436 currency = Currency.getInstance(currencyCode);
437 currencySymbol = currency.getSymbol();
438 } catch (IllegalArgumentException e) {
439 }
440 }
441 }
442
443 /**
444 * Gets the currency of these DecimalFormatSymbols. May be null if the
445 * currency symbol attribute was previously set to a value that's not
446 * a valid ISO 4217 currency code.
447 *
448 * @return the currency used, or null
449 * @since 1.4
450 */
451 public Currency getCurrency() {
452 return currency;
453 }
454
455 /**
456 * Sets the currency of these DecimalFormatSymbols.
457 * This also sets the currency symbol attribute to the currency's symbol
458 * in the DecimalFormatSymbols' locale, and the international currency
459 * symbol attribute to the currency's ISO 4217 currency code.
460 *
461 * @param currency the new currency to be used
462 * @exception NullPointerException if <code>currency</code> is null
463 * @since 1.4
464 * @see #setCurrencySymbol
465 * @see #setInternationalCurrencySymbol
466 */
467 public void setCurrency(Currency currency) {
468 if (currency == null) {
469 throw new NullPointerException();
470 }
471 this.currency = currency;
472 intlCurrencySymbol = currency.getCurrencyCode();
473 currencySymbol = currency.getSymbol(locale);
474 }
475
476
477 /**
478 * Returns the monetary decimal separator.
479 *
480 * @return the monetary decimal separator
481 * @since 1.2
482 */
483 public char getMonetaryDecimalSeparator()
484 {
485 return monetarySeparator;
486 }
487
488 /**
489 * Sets the monetary decimal separator.
490 *
491 * @param sep the monetary decimal separator
492 * @since 1.2
493 */
494 public void setMonetaryDecimalSeparator(char sep)
495 {
496 monetarySeparator = sep;
497 }
498
499 //------------------------------------------------------------
500 // BEGIN Package Private methods ... to be made public later
501 //------------------------------------------------------------
502
503 /**
504 * Returns the character used to separate the mantissa from the exponent.
505 */
506 char getExponentialSymbol()
507 {
508 return exponential;
509 }
510 /**
511 * Returns the string used to separate the mantissa from the exponent.
512 * Examples: "x10^" for 1.23x10^4, "E" for 1.23E4.
513 *
514 * @return the exponent separator string
515 * @see #setExponentSeparator(java.lang.String)
516 * @since 1.6
517 */
518 public String getExponentSeparator()
519 {
520 return exponentialSeparator;
521 }
522
523 /**
524 * Sets the character used to separate the mantissa from the exponent.
525 */
526 void setExponentialSymbol(char exp)
527 {
528 exponential = exp;
529 }
530
531 /**
532 * Sets the string used to separate the mantissa from the exponent.
533 * Examples: "x10^" for 1.23x10^4, "E" for 1.23E4.
534 *
535 * @param exp the exponent separator string
536 * @exception NullPointerException if <code>exp</code> is null
537 * @see #getExponentSeparator()
538 * @since 1.6
539 */
540 public void setExponentSeparator(String exp)
541 {
542 if (exp == null) {
543 throw new NullPointerException();
544 }
545 exponentialSeparator = exp;
546 }
547
548
549 //------------------------------------------------------------
550 // END Package Private methods ... to be made public later
551 //------------------------------------------------------------
552
553 /**
554 * Standard override.
555 */
556 @Override
557 public Object clone() {
558 try {
559 return (DecimalFormatSymbols)super.clone();
560 // other fields are bit-copied
561 } catch (CloneNotSupportedException e) {
562 throw new InternalError(e);
563 }
564 }
565
566 /**
567 * Override equals.
568 */
569 @Override
570 public boolean equals(Object obj) {
571 if (obj == null) return false;
572 if (this == obj) return true;
573 if (getClass() != obj.getClass()) return false;
574 DecimalFormatSymbols other = (DecimalFormatSymbols) obj;
575 return (zeroDigit == other.zeroDigit &&
576 groupingSeparator == other.groupingSeparator &&
577 decimalSeparator == other.decimalSeparator &&
578 percent == other.percent &&
579 perMill == other.perMill &&
580 digit == other.digit &&
581 minusSign == other.minusSign &&
582 patternSeparator == other.patternSeparator &&
583 infinity.equals(other.infinity) &&
584 NaN.equals(other.NaN) &&
585 currencySymbol.equals(other.currencySymbol) &&
586 intlCurrencySymbol.equals(other.intlCurrencySymbol) &&
587 currency == other.currency &&
588 monetarySeparator == other.monetarySeparator &&
589 exponentialSeparator.equals(other.exponentialSeparator) &&
590 locale.equals(other.locale));
591 }
592
593 /**
594 * Override hashCode.
595 */
596 @Override
597 public int hashCode() {
598 int result = zeroDigit;
599 result = result * 37 + groupingSeparator;
600 result = result * 37 + decimalSeparator;
601 return result;
602 }
603
604 /**
605 * Initializes the symbols from the FormatData resource bundle.
606 */
607 private void initialize( Locale locale ) {
608 this.locale = locale;
609
610 // get resource bundle data
611 LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(DecimalFormatSymbolsProvider.class, locale);
612 // Avoid potential recursions
613 if (!(adapter instanceof ResourceBundleBasedAdapter)) {
614 adapter = LocaleProviderAdapter.getResourceBundleBased();
615 }
616 Object[] data = adapter.getLocaleResources(locale).getDecimalFormatSymbolsData();
617 String[] numberElements = (String[]) data[0];
618
619 decimalSeparator = numberElements[0].charAt(0);
620 groupingSeparator = numberElements[1].charAt(0);
621 patternSeparator = numberElements[2].charAt(0);
622 percent = numberElements[3].charAt(0);
623 zeroDigit = numberElements[4].charAt(0); //different for Arabic,etc.
624 digit = numberElements[5].charAt(0);
625 minusSign = numberElements[6].charAt(0);
626 exponential = numberElements[7].charAt(0);
627 exponentialSeparator = numberElements[7]; //string representation new since 1.6
628 perMill = numberElements[8].charAt(0);
629 infinity = numberElements[9];
630 NaN = numberElements[10];
631
632 // Try to obtain the currency used in the locale's country.
633 // Check for empty country string separately because it's a valid
634 // country ID for Locale (and used for the C locale), but not a valid
635 // ISO 3166 country code, and exceptions are expensive.
636 if (locale.getCountry().length() > 0) {
637 try {
638 currency = Currency.getInstance(locale);
639 } catch (IllegalArgumentException e) {
640 // use default values below for compatibility
641 }
642 }
643 if (currency != null) {
644 intlCurrencySymbol = currency.getCurrencyCode();
645 if (data[1] != null && data[1] == intlCurrencySymbol) {
646 currencySymbol = (String) data[2];
647 } else {
648 currencySymbol = currency.getSymbol(locale);
649 data[1] = intlCurrencySymbol;
650 data[2] = currencySymbol;
651 }
652 } else {
653 // default values
654 intlCurrencySymbol = "XXX";
655 try {
656 currency = Currency.getInstance(intlCurrencySymbol);
657 } catch (IllegalArgumentException e) {
658 }
659 currencySymbol = "\u00A4";
660 }
661 // Currently the monetary decimal separator is the same as the
662 // standard decimal separator for all locales that we support.
663 // If that changes, add a new entry to NumberElements.
664 monetarySeparator = decimalSeparator;
665 }
666
667 /**
668 * Reads the default serializable fields, provides default values for objects
669 * in older serial versions, and initializes non-serializable fields.
670 * If <code>serialVersionOnStream</code>
671 * is less than 1, initializes <code>monetarySeparator</code> to be
672 * the same as <code>decimalSeparator</code> and <code>exponential</code>
673 * to be 'E'.
674 * If <code>serialVersionOnStream</code> is less than 2,
675 * initializes <code>locale</code>to the root locale, and initializes
676 * If <code>serialVersionOnStream</code> is less than 3, it initializes
677 * <code>exponentialSeparator</code> using <code>exponential</code>.
678 * Sets <code>serialVersionOnStream</code> back to the maximum allowed value so that
679 * default serialization will work properly if this object is streamed out again.
680 * Initializes the currency from the intlCurrencySymbol field.
681 *
682 * @since JDK 1.1.6
683 */
684 private void readObject(ObjectInputStream stream)
685 throws IOException, ClassNotFoundException {
686 stream.defaultReadObject();
687 if (serialVersionOnStream < 1) {
688 // Didn't have monetarySeparator or exponential field;
689 // use defaults.
690 monetarySeparator = decimalSeparator;
691 exponential = 'E';
692 }
693 if (serialVersionOnStream < 2) {
694 // didn't have locale; use root locale
695 locale = Locale.ROOT;
696 }
697 if (serialVersionOnStream < 3) {
698 // didn't have exponentialSeparator. Create one using exponential
699 exponentialSeparator = Character.toString(exponential);
700 }
701 serialVersionOnStream = currentSerialVersion;
702
703 if (intlCurrencySymbol != null) {
704 try {
705 currency = Currency.getInstance(intlCurrencySymbol);
706 } catch (IllegalArgumentException e) {
707 }
708 }
709 }
710
711 /**
712 * Character used for zero.
713 *
714 * @serial
715 * @see #getZeroDigit
716 */
717 private char zeroDigit;
718
719 /**
720 * Character used for thousands separator.
721 *
722 * @serial
723 * @see #getGroupingSeparator
724 */
725 private char groupingSeparator;
726
727 /**
728 * Character used for decimal sign.
729 *
730 * @serial
731 * @see #getDecimalSeparator
732 */
733 private char decimalSeparator;
734
735 /**
736 * Character used for per mille sign.
737 *
738 * @serial
739 * @see #getPerMill
740 */
741 private char perMill;
742
743 /**
744 * Character used for percent sign.
745 * @serial
746 * @see #getPercent
747 */
748 private char percent;
749
750 /**
751 * Character used for a digit in a pattern.
752 *
753 * @serial
754 * @see #getDigit
755 */
756 private char digit;
757
758 /**
759 * Character used to separate positive and negative subpatterns
760 * in a pattern.
761 *
762 * @serial
763 * @see #getPatternSeparator
764 */
765 private char patternSeparator;
766
767 /**
768 * String used to represent infinity.
769 * @serial
770 * @see #getInfinity
771 */
772 private String infinity;
773
774 /**
775 * String used to represent "not a number".
776 * @serial
777 * @see #getNaN
778 */
779 private String NaN;
780
781 /**
782 * Character used to represent minus sign.
783 * @serial
784 * @see #getMinusSign
785 */
786 private char minusSign;
787
788 /**
789 * String denoting the local currency, e.g. "$".
790 * @serial
791 * @see #getCurrencySymbol
792 */
793 private String currencySymbol;
794
795 /**
796 * ISO 4217 currency code denoting the local currency, e.g. "USD".
797 * @serial
798 * @see #getInternationalCurrencySymbol
799 */
800 private String intlCurrencySymbol;
801
802 /**
803 * The decimal separator used when formatting currency values.
804 * @serial
805 * @since JDK 1.1.6
806 * @see #getMonetaryDecimalSeparator
807 */
808 private char monetarySeparator; // Field new in JDK 1.1.6
809
810 /**
811 * The character used to distinguish the exponent in a number formatted
812 * in exponential notation, e.g. 'E' for a number such as "1.23E45".
813 * <p>
814 * Note that the public API provides no way to set this field,
815 * even though it is supported by the implementation and the stream format.
816 * The intent is that this will be added to the API in the future.
817 *
818 * @serial
819 * @since JDK 1.1.6
820 */
821 private char exponential; // Field new in JDK 1.1.6
822
823 /**
824 * The string used to separate the mantissa from the exponent.
825 * Examples: "x10^" for 1.23x10^4, "E" for 1.23E4.
826 * <p>
827 * If both <code>exponential</code> and <code>exponentialSeparator</code>
828 * exist, this <code>exponentialSeparator</code> has the precedence.
829 *
830 * @serial
831 * @since 1.6
832 */
833 private String exponentialSeparator; // Field new in JDK 1.6
834
835 /**
836 * The locale of these currency format symbols.
837 *
838 * @serial
839 * @since 1.4
840 */
841 private Locale locale;
842
843 // currency; only the ISO code is serialized.
844 private transient Currency currency;
845
846 // Proclaim JDK 1.1 FCS compatibility
847 static final long serialVersionUID = 5772796243397350300L;
848
849 // The internal serial version which says which version was written
850 // - 0 (default) for version up to JDK 1.1.5
851 // - 1 for version from JDK 1.1.6, which includes two new fields:
852 // monetarySeparator and exponential.
853 // - 2 for version from J2SE 1.4, which includes locale field.
854 // - 3 for version from J2SE 1.6, which includes exponentialSeparator field.
855 private static final int currentSerialVersion = 3;
856
857 /**
858 * Describes the version of <code>DecimalFormatSymbols</code> present on the stream.
859 * Possible values are:
860 * <ul>
861 * <li><b>0</b> (or uninitialized): versions prior to JDK 1.1.6.
862 *
863 * <li><b>1</b>: Versions written by JDK 1.1.6 or later, which include
864 * two new fields: <code>monetarySeparator</code> and <code>exponential</code>.
865 * <li><b>2</b>: Versions written by J2SE 1.4 or later, which include a
866 * new <code>locale</code> field.
867 * <li><b>3</b>: Versions written by J2SE 1.6 or later, which include a
868 * new <code>exponentialSeparator</code> field.
869 * </ul>
870 * When streaming out a <code>DecimalFormatSymbols</code>, the most recent format
871 * (corresponding to the highest allowable <code>serialVersionOnStream</code>)
872 * is always written.
873 *
874 * @serial
875 * @since JDK 1.1.6
876 */
877 private int serialVersionOnStream = currentSerialVersion;
878 }