/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.text;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Currency;
import java.util.Locale;
import com.ibm.icu4jni.util.LocaleData;
/**
* Encapsulates the set of symbols (such as the decimal separator, the grouping
* separator, and so on) needed by {@code DecimalFormat} to format numbers.
* {@code DecimalFormat} internally creates an instance of
* {@code DecimalFormatSymbols} from its locale data. If you need to change any
* of these symbols, you can get the {@code DecimalFormatSymbols} object from
* your {@code DecimalFormat} and modify it.
*
* @see java.util.Locale
* @see DecimalFormat
*/
public final class DecimalFormatSymbols implements Cloneable, Serializable {
private static final long serialVersionUID = 5772796243397350300L;
private final int ZeroDigit = 0, Digit = 1, DecimalSeparator = 2,
GroupingSeparator = 3, PatternSeparator = 4, Percent = 5,
PerMill = 6, Exponent = 7, MonetaryDecimalSeparator = 8,
MinusSign = 9;
private transient char[] patternChars;
private transient Currency currency;
private transient Locale locale;
private String infinity, NaN, currencySymbol, intlCurrencySymbol;
/**
* Constructs a new {@code DecimalFormatSymbols} containing the symbols for
* the default locale. Best practice is to create a {@code DecimalFormat}
* and then to get the {@code DecimalFormatSymbols} from that object by
* calling {@link DecimalFormat#getDecimalFormatSymbols()}.
*/
public DecimalFormatSymbols() {
this(Locale.getDefault());
}
/**
* Constructs a new DecimalFormatSymbols containing the symbols for the
* specified Locale. Best practice is to create a {@code DecimalFormat}
* and then to get the {@code DecimalFormatSymbols} from that object by
* calling {@link DecimalFormat#getDecimalFormatSymbols()}.
*
* @param locale
* the locale.
*/
public DecimalFormatSymbols(Locale locale) {
// BEGIN android-changed
LocaleData localeData = com.ibm.icu4jni.util.Resources.getLocaleData(locale);
this.patternChars = localeData.decimalPatternChars.toCharArray();
this.infinity = localeData.infinity;
this.NaN = localeData.NaN;
this.locale = locale;
try {
currency = Currency.getInstance(locale);
currencySymbol = currency.getSymbol(locale);
intlCurrencySymbol = currency.getCurrencyCode();
} catch (IllegalArgumentException e) {
currency = Currency.getInstance("XXX"); //$NON-NLS-1$
currencySymbol = localeData.currencySymbol;
intlCurrencySymbol = localeData.internationalCurrencySymbol;
}
// END android-changed
}
/**
* Returns a new {@code DecimalFormatSymbols} with the same symbols as this
* {@code DecimalFormatSymbols}.
*
* @return a shallow copy of this {@code DecimalFormatSymbols}.
*
* @see java.lang.Cloneable
*/
@Override
public Object clone() {
try {
DecimalFormatSymbols symbols = (DecimalFormatSymbols) super.clone();
symbols.patternChars = patternChars.clone();
return symbols;
} catch (CloneNotSupportedException e) {
throw new AssertionError(e); // android-changed
}
}
/**
* Compares the specified object to this {@code DecimalFormatSymbols} and
* indicates if they are equal. In order to be equal, {@code object} must be
* an instance of {@code DecimalFormatSymbols} and contain the same symbols.
*
* @param object
* the object to compare with this object.
* @return {@code true} if the specified object is equal to this
* {@code DecimalFormatSymbols}; {@code false} otherwise.
* @see #hashCode
*/
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (!(object instanceof DecimalFormatSymbols)) {
return false;
}
DecimalFormatSymbols obj = (DecimalFormatSymbols) object;
return Arrays.equals(patternChars, obj.patternChars)
&& infinity.equals(obj.infinity) && NaN.equals(obj.NaN)
&& currencySymbol.equals(obj.currencySymbol)
&& intlCurrencySymbol.equals(obj.intlCurrencySymbol);
}
/**
* Returns the currency.
* <p>
* {@code null} is returned if {@code setInternationalCurrencySymbol()} has
* been previously called with a value that is not a valid ISO 4217 currency
* code.
* <p>
*
* @return the currency that was set in the constructor or by calling
* {@code setCurrency()} or {@code setInternationalCurrencySymbol()},
* or {@code null} if an invalid currency was set.
* @see #setCurrency(Currency)
* @see #setInternationalCurrencySymbol(String)
*/
public Currency getCurrency() {
return currency;
}
/**
* Returns the international currency symbol.
*
* @return the international currency symbol as string.
*/
public String getInternationalCurrencySymbol() {
return intlCurrencySymbol;
}
/**
* Returns the currency symbol.
*
* @return the currency symbol as string.
*/
public String getCurrencySymbol() {
return currencySymbol;
}
/**
* Returns the character which represents the decimal point in a number.
*
* @return the decimal separator character.
*/
public char getDecimalSeparator() {
return patternChars[DecimalSeparator];
}
/**
* Returns the character which represents a single digit in a format
* pattern.
*
* @return the digit pattern character.
*/
public char getDigit() {
return patternChars[Digit];
}
/**
* Returns the character used as the thousands separator in a number.
*
* @return the thousands separator character.
*/
public char getGroupingSeparator() {
return patternChars[GroupingSeparator];
}
/**
* Returns the string which represents infinity.
*
* @return the infinity symbol as a string.
*/
public String getInfinity() {
return infinity;
}
/**
* Returns the minus sign character.
*
* @return the minus sign as a character.
*/
public char getMinusSign() {
return patternChars[MinusSign];
}
/**
* Returns the character which represents the decimal point in a monetary
* value.
*
* @return the monetary decimal point as a character.
*/
public char getMonetaryDecimalSeparator() {
return patternChars[MonetaryDecimalSeparator];
}
/**
* Returns the string which represents NaN.
*
* @return the symbol NaN as a string.
*/
public String getNaN() {
return NaN;
}
/**
* Returns the character which separates the positive and negative patterns
* in a format pattern.
*
* @return the pattern separator character.
*/
public char getPatternSeparator() {
return patternChars[PatternSeparator];
}
/**
* Returns the percent character.
*
* @return the percent character.
*/
public char getPercent() {
return patternChars[Percent];
}
/**
* Returns the per mill sign character.
*
* @return the per mill sign character.
*/
public char getPerMill() {
return patternChars[PerMill];
}
/**
* Returns the character which represents zero.
*
* @return the zero character.
*/
public char getZeroDigit() {
return patternChars[ZeroDigit];
}
/*
* Returns the exponent as a character.
*/
char getExponential() {
return patternChars[Exponent];
}
@Override
public int hashCode() {
return new String(patternChars).hashCode() + infinity.hashCode()
+ NaN.hashCode() + currencySymbol.hashCode()
+ intlCurrencySymbol.hashCode();
}
/**
* Sets the currency.
* <p>
* The international currency symbol and the currency symbol are updated,
* but the min and max number of fraction digits stays the same.
* <p>
*
* @param currency
* the new currency.
* @throws NullPointerException
* if {@code currency} is {@code null}.
*/
public void setCurrency(Currency currency) {
if (currency == null) {
throw new NullPointerException();
}
if (currency == this.currency) {
return;
}
this.currency = currency;
intlCurrencySymbol = currency.getCurrencyCode();
currencySymbol = currency.getSymbol(locale);
}
/**
* Sets the international currency symbol.
* <p>
* The currency and currency symbol are also updated if {@code value} is a
* valid ISO4217 currency code.
* <p>
* The min and max number of fraction digits stay the same.
*
* @param value
* the currency code.
*/
public void setInternationalCurrencySymbol(String value) {
if (value == null) {
currency = null;
intlCurrencySymbol = null;
return;
}
if (value.equals(intlCurrencySymbol)) {
return;
}
try {
currency = Currency.getInstance(value);
currencySymbol = currency.getSymbol(locale);
} catch (IllegalArgumentException e) {
currency = null;
}
intlCurrencySymbol = value;
}
/**
* Sets the currency symbol.
*
* @param value
* the currency symbol.
*/
public void setCurrencySymbol(String value) {
currencySymbol = value;
}
/**
* Sets the character which represents the decimal point in a number.
*
* @param value
* the decimal separator character.
*/
public void setDecimalSeparator(char value) {
patternChars[DecimalSeparator] = value;
}
/**
* Sets the character which represents a single digit in a format pattern.
*
* @param value
* the digit character.
*/
public void setDigit(char value) {
patternChars[Digit] = value;
}
/**
* Sets the character used as the thousands separator in a number.
*
* @param value
* the grouping separator character.
*/
public void setGroupingSeparator(char value) {
patternChars[GroupingSeparator] = value;
}
/**
* Sets the string which represents infinity.
*
* @param value
* the string representing infinity.
*/
public void setInfinity(String value) {
infinity = value;
}
/**
* Sets the minus sign character.
*
* @param value
* the minus sign character.
*/
public void setMinusSign(char value) {
patternChars[MinusSign] = value;
}
/**
* Sets the character which represents the decimal point in a monetary
* value.
*
* @param value
* the monetary decimal separator character.
*/
public void setMonetaryDecimalSeparator(char value) {
patternChars[MonetaryDecimalSeparator] = value;
}
/**
* Sets the string which represents NaN.
*
* @param value
* the string representing NaN.
*/
public void setNaN(String value) {
NaN = value;
}
/**
* Sets the character which separates the positive and negative patterns in
* a format pattern.
*
* @param value
* the pattern separator character.
*/
public void setPatternSeparator(char value) {
patternChars[PatternSeparator] = value;
}
/**
* Sets the percent character.
*
* @param value
* the percent character.
*/
public void setPercent(char value) {
patternChars[Percent] = value;
}
/**
* Sets the per mill sign character.
*
* @param value
* the per mill character.
*/
public void setPerMill(char value) {
patternChars[PerMill] = value;
}
/**
* Sets the character which represents zero.
*
* @param value
* the zero digit character.
*/
public void setZeroDigit(char value) {
patternChars[ZeroDigit] = value;
}
/*
* Sets the exponent character.
*/
void setExponential(char value) {
patternChars[Exponent] = value;
}
private static final ObjectStreamField[] serialPersistentFields = {
new ObjectStreamField("currencySymbol", String.class), //$NON-NLS-1$
new ObjectStreamField("decimalSeparator", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("digit", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("exponential", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("groupingSeparator", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("infinity", String.class), //$NON-NLS-1$
new ObjectStreamField("intlCurrencySymbol", String.class), //$NON-NLS-1$
new ObjectStreamField("minusSign", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("monetarySeparator", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("NaN", String.class), //$NON-NLS-1$
new ObjectStreamField("patternSeparator", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("percent", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("perMill", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("serialVersionOnStream", Integer.TYPE), //$NON-NLS-1$
new ObjectStreamField("zeroDigit", Character.TYPE), //$NON-NLS-1$
new ObjectStreamField("locale", Locale.class), }; //$NON-NLS-1$
private void writeObject(ObjectOutputStream stream) throws IOException {
ObjectOutputStream.PutField fields = stream.putFields();
fields.put("currencySymbol", currencySymbol); //$NON-NLS-1$
fields.put("decimalSeparator", getDecimalSeparator()); //$NON-NLS-1$
fields.put("digit", getDigit()); //$NON-NLS-1$
fields.put("exponential", getExponential()); //$NON-NLS-1$
fields.put("groupingSeparator", getGroupingSeparator()); //$NON-NLS-1$
fields.put("infinity", infinity); //$NON-NLS-1$
fields.put("intlCurrencySymbol", intlCurrencySymbol); //$NON-NLS-1$
fields.put("minusSign", getMinusSign()); //$NON-NLS-1$
fields.put("monetarySeparator", getMonetaryDecimalSeparator()); //$NON-NLS-1$
fields.put("NaN", NaN); //$NON-NLS-1$
fields.put("patternSeparator", getPatternSeparator()); //$NON-NLS-1$
fields.put("percent", getPercent()); //$NON-NLS-1$
fields.put("perMill", getPerMill()); //$NON-NLS-1$
fields.put("serialVersionOnStream", 1); //$NON-NLS-1$
fields.put("zeroDigit", getZeroDigit()); //$NON-NLS-1$
fields.put("locale", locale); //$NON-NLS-1$
stream.writeFields();
}
private void readObject(ObjectInputStream stream) throws IOException,
ClassNotFoundException {
ObjectInputStream.GetField fields = stream.readFields();
patternChars = new char[10];
currencySymbol = (String) fields.get("currencySymbol", ""); //$NON-NLS-1$ //$NON-NLS-2$
setDecimalSeparator(fields.get("decimalSeparator", '.')); //$NON-NLS-1$
setDigit(fields.get("digit", '#')); //$NON-NLS-1$
setGroupingSeparator(fields.get("groupingSeparator", ',')); //$NON-NLS-1$
infinity = (String) fields.get("infinity", ""); //$NON-NLS-1$ //$NON-NLS-2$
intlCurrencySymbol = (String) fields.get("intlCurrencySymbol", ""); //$NON-NLS-1$ //$NON-NLS-2$
setMinusSign(fields.get("minusSign", '-')); //$NON-NLS-1$
NaN = (String) fields.get("NaN", ""); //$NON-NLS-1$ //$NON-NLS-2$
setPatternSeparator(fields.get("patternSeparator", ';')); //$NON-NLS-1$
setPercent(fields.get("percent", '%')); //$NON-NLS-1$
setPerMill(fields.get("perMill", '\u2030')); //$NON-NLS-1$
setZeroDigit(fields.get("zeroDigit", '0')); //$NON-NLS-1$
locale = (Locale) fields.get("locale", null); //$NON-NLS-1$
if (fields.get("serialVersionOnStream", 0) == 0) { //$NON-NLS-1$
setMonetaryDecimalSeparator(getDecimalSeparator());
setExponential('E');
} else {
setMonetaryDecimalSeparator(fields.get("monetarySeparator", '.')); //$NON-NLS-1$
setExponential(fields.get("exponential", 'E')); //$NON-NLS-1$
}
try {
currency = Currency.getInstance(intlCurrencySymbol);
} catch (IllegalArgumentException e) {
currency = null;
}
}
}