mirror of git://gcc.gnu.org/git/gcc.git
614 lines
16 KiB
Java
614 lines
16 KiB
Java
/* DecimalFormatSymbols.java -- Format symbols used by DecimalFormat
|
|
Copyright (C) 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package java.text;
|
|
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.Serializable;
|
|
import java.util.Currency;
|
|
import java.util.Locale;
|
|
import java.util.MissingResourceException;
|
|
import java.util.ResourceBundle;
|
|
|
|
/**
|
|
* This class is a container for the symbols used by
|
|
* <code>DecimalFormat</code> to format numbers and currency. These are
|
|
* normally handled automatically, but an application can override
|
|
* values as desired using this class.
|
|
*
|
|
* @author Tom Tromey (tromey@cygnus.com)
|
|
* @author Aaron M. Renn (arenn@urbanophile.com)
|
|
* @date February 24, 1999
|
|
*/
|
|
/* Written using "Java Class Libraries", 2nd edition, plus online
|
|
* API docs for JDK 1.2 from http://www.javasoft.com.
|
|
* Status: Believed complete and correct to 1.2.
|
|
*/
|
|
public final class DecimalFormatSymbols implements Cloneable, Serializable
|
|
{
|
|
public Object clone ()
|
|
{
|
|
try
|
|
{
|
|
return super.clone ();
|
|
}
|
|
catch(CloneNotSupportedException e)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method initializes a new instance of
|
|
* <code>DecimalFormatSymbols</code> for the default locale.
|
|
*/
|
|
public DecimalFormatSymbols ()
|
|
{
|
|
this (Locale.getDefault());
|
|
}
|
|
|
|
private String safeGetString(ResourceBundle bundle,
|
|
String name, String def)
|
|
{
|
|
if (bundle != null)
|
|
{
|
|
try
|
|
{
|
|
return bundle.getString(name);
|
|
}
|
|
catch (MissingResourceException x)
|
|
{
|
|
}
|
|
}
|
|
return def;
|
|
}
|
|
|
|
private char safeGetChar(ResourceBundle bundle,
|
|
String name, char def)
|
|
{
|
|
String r = null;
|
|
if (bundle != null)
|
|
{
|
|
try
|
|
{
|
|
r = bundle.getString(name);
|
|
}
|
|
catch (MissingResourceException x)
|
|
{
|
|
}
|
|
}
|
|
if (r == null || r.length() < 1)
|
|
return def;
|
|
return r.charAt(0);
|
|
}
|
|
|
|
/**
|
|
* This method initializes a new instance of
|
|
* <code>DecimalFormatSymbols</code> for the specified locale.
|
|
*
|
|
* @param loc The local to load symbols for.
|
|
*/
|
|
public DecimalFormatSymbols (Locale loc)
|
|
{
|
|
ResourceBundle res;
|
|
try
|
|
{
|
|
res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
|
|
loc, ClassLoader.getSystemClassLoader());
|
|
}
|
|
catch (MissingResourceException x)
|
|
{
|
|
res = null;
|
|
}
|
|
currencySymbol = safeGetString (res, "currencySymbol", "$");
|
|
decimalSeparator = safeGetChar (res, "decimalSeparator", '.');
|
|
digit = safeGetChar (res, "digit", '#');
|
|
exponential = safeGetChar (res, "exponential", 'E');
|
|
groupingSeparator = safeGetChar (res, "groupingSeparator", ',');
|
|
infinity = safeGetString (res, "infinity", "\u221e");
|
|
// FIXME: default?
|
|
intlCurrencySymbol = safeGetString (res, "intlCurrencySymbol", "$");
|
|
try
|
|
{
|
|
monetarySeparator = safeGetChar (res, "monetarySeparator", '.');
|
|
}
|
|
catch (MissingResourceException x)
|
|
{
|
|
monetarySeparator = decimalSeparator;
|
|
}
|
|
minusSign = safeGetChar (res, "minusSign", '-');
|
|
NaN = safeGetString (res, "NaN", "\ufffd");
|
|
patternSeparator = safeGetChar (res, "patternSeparator", ';');
|
|
percent = safeGetChar (res, "percent", '%');
|
|
perMill = safeGetChar (res, "perMill", '\u2030');
|
|
zeroDigit = safeGetChar (res, "zeroDigit", '0');
|
|
locale = loc;
|
|
}
|
|
|
|
/**
|
|
* This method this this object for equality against the specified object.
|
|
* This will be true if and only if the following criteria are met with
|
|
* regard to the specified object:
|
|
* <p>
|
|
* <ul>
|
|
* <li>It is not <code>null</code>.</li>
|
|
* <li>It is an instance of <code>DecimalFormatSymbols</code>.</li>
|
|
* <li>All of its symbols are identical to the symbols in this object.</li>
|
|
* </ul>
|
|
*
|
|
* @return <code>true</code> if the specified object is equal to this
|
|
* object, <code>false</code> otherwise.
|
|
*/
|
|
public boolean equals (Object obj)
|
|
{
|
|
if (! (obj instanceof DecimalFormatSymbols))
|
|
return false;
|
|
DecimalFormatSymbols dfs = (DecimalFormatSymbols) obj;
|
|
return (currencySymbol.equals(dfs.currencySymbol)
|
|
&& decimalSeparator == dfs.decimalSeparator
|
|
&& digit == dfs.digit
|
|
&& exponential == dfs.exponential
|
|
&& groupingSeparator == dfs.groupingSeparator
|
|
&& infinity.equals(dfs.infinity)
|
|
&& intlCurrencySymbol.equals(dfs.intlCurrencySymbol)
|
|
&& minusSign == dfs.minusSign
|
|
&& monetarySeparator == dfs.monetarySeparator
|
|
&& NaN.equals(dfs.NaN)
|
|
&& patternSeparator == dfs.patternSeparator
|
|
&& percent == dfs.percent
|
|
&& perMill == dfs.perMill
|
|
&& zeroDigit == dfs.zeroDigit);
|
|
}
|
|
|
|
/**
|
|
* Returns the currency corresponding to the currency symbol stored
|
|
* in the instance of <code>DecimalFormatSymbols</code>.
|
|
*
|
|
* @return A new instance of <code>Currency</code> if
|
|
* the currency code matches a known one.
|
|
*/
|
|
public Currency getCurrency ()
|
|
{
|
|
return Currency.getInstance (currencySymbol);
|
|
}
|
|
|
|
/**
|
|
* This method returns the currency symbol in local format. For example,
|
|
* "$" for Canadian dollars.
|
|
*
|
|
* @return The currency symbol in local format.
|
|
*/
|
|
public String getCurrencySymbol ()
|
|
{
|
|
return currencySymbol;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used as the decimal point.
|
|
*
|
|
* @return The character used as the decimal point.
|
|
*/
|
|
public char getDecimalSeparator ()
|
|
{
|
|
return decimalSeparator;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used to represent a digit in a
|
|
* format pattern string.
|
|
*
|
|
* @return The character used to represent a digit in a format
|
|
* pattern string.
|
|
*/
|
|
public char getDigit ()
|
|
{
|
|
return digit;
|
|
}
|
|
|
|
// This is our own extension.
|
|
char getExponential ()
|
|
{
|
|
return exponential;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used to separate groups of digits. For
|
|
* example, the United States uses a comma (,) to separate thousands in
|
|
* a number.
|
|
*
|
|
* @return The character used to separate groups of digits.
|
|
*/
|
|
public char getGroupingSeparator ()
|
|
{
|
|
return groupingSeparator;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used to represent infinity.
|
|
*
|
|
* @return The character used to represent infinity.
|
|
*/
|
|
public String getInfinity ()
|
|
{
|
|
return infinity;
|
|
}
|
|
|
|
/**
|
|
* This method returns the currency symbol in international format. For
|
|
* example, "C$" for Canadian dollars.
|
|
*
|
|
* @return The currency symbol in international format.
|
|
*/
|
|
public String getInternationalCurrencySymbol ()
|
|
{
|
|
return intlCurrencySymbol;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used to represent the minus sign.
|
|
*
|
|
* @return The character used to represent the minus sign.
|
|
*/
|
|
public char getMinusSign ()
|
|
{
|
|
return minusSign;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used to represent the decimal
|
|
* point for currency values.
|
|
*
|
|
* @return The decimal point character used in currency values.
|
|
*/
|
|
public char getMonetaryDecimalSeparator ()
|
|
{
|
|
return monetarySeparator;
|
|
}
|
|
|
|
/**
|
|
* This method returns the string used to represent the NaN (not a number)
|
|
* value.
|
|
*
|
|
* @return The string used to represent NaN
|
|
*/
|
|
public String getNaN ()
|
|
{
|
|
return NaN;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used to separate positive and negative
|
|
* subpatterns in a format pattern.
|
|
*
|
|
* @return The character used to separate positive and negative subpatterns
|
|
* in a format pattern.
|
|
*/
|
|
public char getPatternSeparator ()
|
|
{
|
|
return patternSeparator;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used as the percent sign.
|
|
*
|
|
* @return The character used as the percent sign.
|
|
*/
|
|
public char getPercent ()
|
|
{
|
|
return percent;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used as the per mille character.
|
|
*
|
|
* @return The per mille character.
|
|
*/
|
|
public char getPerMill ()
|
|
{
|
|
return perMill;
|
|
}
|
|
|
|
/**
|
|
* This method returns the character used to represent the digit zero.
|
|
*
|
|
* @return The character used to represent the digit zero.
|
|
*/
|
|
public char getZeroDigit ()
|
|
{
|
|
return zeroDigit;
|
|
}
|
|
|
|
/**
|
|
* This method returns a hash value for this object.
|
|
*
|
|
* @return A hash value for this object.
|
|
*/
|
|
public int hashCode ()
|
|
{
|
|
// Compute based on zero digit, grouping separator, and decimal
|
|
// separator -- JCL book. This probably isn't a very good hash
|
|
// code.
|
|
return zeroDigit << 16 + groupingSeparator << 8 + decimalSeparator;
|
|
}
|
|
|
|
/**
|
|
* This method sets the currency to the specified value.
|
|
*
|
|
* @param currency The new currency
|
|
*/
|
|
public void setCurrency (Currency currency)
|
|
{
|
|
setCurrencySymbol (currency.getSymbol());
|
|
}
|
|
|
|
/**
|
|
* This method sets the currency symbol to the specified value.
|
|
*
|
|
* @param currency The new currency symbol
|
|
*/
|
|
public void setCurrencySymbol (String currency)
|
|
{
|
|
currencySymbol = currency;
|
|
}
|
|
|
|
/**
|
|
* This method sets the decimal point character to the specified value.
|
|
*
|
|
* @param decimalSep The new decimal point character
|
|
*/
|
|
public void setDecimalSeparator (char decimalSep)
|
|
{
|
|
decimalSeparator = decimalSep;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used to represents a digit in a format
|
|
* string to the specified value.
|
|
*
|
|
* @param digit The character used to represent a digit in a format pattern.
|
|
*/
|
|
public void setDigit (char digit)
|
|
{
|
|
this.digit = digit;
|
|
}
|
|
|
|
// This is our own extension.
|
|
void setExponential (char exp)
|
|
{
|
|
exponential = exp;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used to separate groups of digits.
|
|
*
|
|
* @param groupSep The character used to separate groups of digits.
|
|
*/
|
|
public void setGroupingSeparator (char groupSep)
|
|
{
|
|
groupingSeparator = groupSep;
|
|
}
|
|
|
|
/**
|
|
* This method sets the string used to represents infinity.
|
|
*
|
|
* @param infinity The string used to represent infinity.
|
|
*/
|
|
public void setInfinity (String infinity)
|
|
{
|
|
this.infinity = infinity;
|
|
}
|
|
|
|
/**
|
|
* This method sets the international currency symbols to the
|
|
* specified value.
|
|
*
|
|
* @param intlCurrencySymbol The new international currency symbol.
|
|
*/
|
|
public void setInternationalCurrencySymbol (String currency)
|
|
{
|
|
intlCurrencySymbol = currency;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used to represent the minus sign.
|
|
*
|
|
* @param minusSign The character used to represent the minus sign.
|
|
*/
|
|
public void setMinusSign (char minusSign)
|
|
{
|
|
this.minusSign = minusSign;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used for the decimal point in currency
|
|
* values.
|
|
*
|
|
* @param decimalSep The decimal point character used in currency values.
|
|
*/
|
|
public void setMonetaryDecimalSeparator (char decimalSep)
|
|
{
|
|
monetarySeparator = decimalSep;
|
|
}
|
|
|
|
/**
|
|
* This method sets the string used to represent the NaN (not a
|
|
* number) value.
|
|
*
|
|
* @param nan The string used to represent NaN
|
|
*/
|
|
public void setNaN (String nan)
|
|
{
|
|
NaN = nan;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used to separate positive and negative
|
|
* subpatterns in a format pattern.
|
|
*
|
|
* @param patternSep The character used to separate positive and
|
|
* negative subpatterns in a format pattern.
|
|
*/
|
|
public void setPatternSeparator (char patternSep)
|
|
{
|
|
patternSeparator = patternSep;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used as the percent sign.
|
|
*
|
|
* @param percent The character used as the percent sign.
|
|
*/
|
|
public void setPercent (char percent)
|
|
{
|
|
this.percent = percent;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used as the per mille character.
|
|
*
|
|
* @param perMill The per mille character.
|
|
*/
|
|
public void setPerMill (char perMill)
|
|
{
|
|
this.perMill = perMill;
|
|
}
|
|
|
|
/**
|
|
* This method sets the character used to represent the digit zero.
|
|
*
|
|
* @param zeroDigit The character used to represent the digit zero.
|
|
*/
|
|
public void setZeroDigit (char zeroDigit)
|
|
{
|
|
this.zeroDigit = zeroDigit;
|
|
}
|
|
|
|
/**
|
|
* @serial A string used for the local currency
|
|
*/
|
|
private String currencySymbol;
|
|
/**
|
|
* @serial The <code>char</code> used to separate decimals in a number.
|
|
*/
|
|
private char decimalSeparator;
|
|
/**
|
|
* @serial This is the <code>char</code> used to represent a digit in
|
|
* a format specification.
|
|
*/
|
|
private char digit;
|
|
/**
|
|
* @serial This is the <code>char</code> used to represent the exponent
|
|
* separator in exponential notation.
|
|
*/
|
|
private char exponential;
|
|
/**
|
|
* @serial This separates groups of thousands in numbers.
|
|
*/
|
|
private char groupingSeparator;
|
|
/**
|
|
* @serial This string represents infinity.
|
|
*/
|
|
private String infinity;
|
|
/**
|
|
* @serial This string represents the local currency in an international
|
|
* context, eg, "C$" for Canadian dollars.
|
|
*/
|
|
private String intlCurrencySymbol;
|
|
/**
|
|
* @serial This is the character used to represent the minus sign.
|
|
*/
|
|
private char minusSign;
|
|
/**
|
|
* @serial This character is used to separate decimals when formatting
|
|
* currency values.
|
|
*/
|
|
private char monetarySeparator;
|
|
/**
|
|
* @serial This string is used the represent the Java NaN value for
|
|
* "not a number".
|
|
*/
|
|
private String NaN;
|
|
/**
|
|
* @serial This is the character used to separate positive and negative
|
|
* subpatterns in a format pattern.
|
|
*/
|
|
private char patternSeparator;
|
|
/**
|
|
* @serial This is the percent symbols
|
|
*/
|
|
private char percent;
|
|
/**
|
|
* @serial This character is used for the mille percent sign.
|
|
*/
|
|
private char perMill;
|
|
/**
|
|
* @serial This value represents the type of object being de-serialized.
|
|
* 0 indicates a pre-Java 1.1.6 version, 1 indicates 1.1.6 or later.
|
|
* 0 indicates a pre-Java 1.1.6 version, 1 indicates 1.1.6 or later,
|
|
* 2 indicates 1.4 or later
|
|
*/
|
|
private int serialVersionOnStream = 2;
|
|
/**
|
|
* @serial This is the character used to represent 0.
|
|
*/
|
|
private char zeroDigit;
|
|
|
|
/**
|
|
* @serial The locale of these currency symbols.
|
|
*/
|
|
private Locale locale;
|
|
|
|
private static final long serialVersionUID = 5772796243397350300L;
|
|
|
|
private void readObject(ObjectInputStream stream)
|
|
throws IOException, ClassNotFoundException
|
|
{
|
|
stream.defaultReadObject();
|
|
if (serialVersionOnStream < 1)
|
|
{
|
|
monetarySeparator = decimalSeparator;
|
|
exponential = 'E';
|
|
}
|
|
if (serialVersionOnStream < 2)
|
|
locale = Locale.getDefault();
|
|
|
|
serialVersionOnStream = 2;
|
|
}
|
|
}
|