[kaffe] CVS kaffe (robilad): Resynced with GNU Classpath: allow XXX for currency
Kaffe CVS
cvs-commits at kaffe.org
Tue Apr 19 13:40:42 PDT 2005
PatchSet 5727
Date: 2005/04/19 20:36:13
Author: robilad
Branch: HEAD
Tag: (none)
Log:
Resynced with GNU Classpath: allow XXX for currency
2005-04-19 Dalibor Topic <robilad at kaffe.org>
Resynced with GNU Classpath.
2005-04-15 Andrew John Hughes <gnu_andrew at member.fsf.org>
* java/text/DecimalFormatSymbols.java:
Added retrieval of XXX instance in place of null.
* java/util/Currency.java,
(Currency(String)): New constructor for the XXX special case.
(getInstance(String)): Allow special case of XXX.
Members:
ChangeLog:1.3894->1.3895
libraries/javalib/java/text/DecimalFormatSymbols.java:INITIAL->1.21
libraries/javalib/java/util/Currency.java:INITIAL->1.16
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.3894 kaffe/ChangeLog:1.3895
--- kaffe/ChangeLog:1.3894 Tue Apr 19 20:28:30 2005
+++ kaffe/ChangeLog Tue Apr 19 20:36:13 2005
@@ -2,6 +2,18 @@
Resynced with GNU Classpath.
+ 2005-04-15 Andrew John Hughes <gnu_andrew at member.fsf.org>
+
+ * java/text/DecimalFormatSymbols.java:
+ Added retrieval of "XXX" instance in place of null.
+ * java/util/Currency.java,
+ (Currency(String)): New constructor for the XXX special case.
+ (getInstance(String)): Allow special case of "XXX".
+
+2005-04-19 Dalibor Topic <robilad at kaffe.org>
+
+ Resynced with GNU Classpath.
+
2005-04-15 Sven de Marothy <sven at physto.se>
* java/io/InputStreamReader.java,
===================================================================
Checking out kaffe/libraries/javalib/java/text/DecimalFormatSymbols.java
RCS: /home/cvs/kaffe/kaffe/libraries/javalib/java/text/DecimalFormatSymbols.java,v
VERS: 1.21
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/javalib/java/text/DecimalFormatSymbols.java Tue Apr 19 20:40:42 2005
@@ -0,0 +1,688 @@
+/* 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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
+ * for a particular locale. These are
+ * normally handled automatically, but an application can override
+ * values as desired using this class.
+ *
+ * @author Tom Tromey (tromey at cygnus.com)
+ * @author Aaron M. Renn (arenn at urbanophile.com)
+ * @author Andrew John Hughes (gnu_andrew at member.fsf.org)
+ * @date February 24, 1999
+ * @see java.text.DecimalFormat
+ */
+/* 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());
+ }
+
+ /**
+ * Retrieves a valid string, either using the supplied resource
+ * bundle or the default value.
+ *
+ * @param bundle the resource bundle to use to find the string.
+ * @param name key for the string in the resource bundle.
+ * @param def default value for the string.
+ */
+ 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.
+ * <strong>Note</strong>: if the locale does not have an associated
+ * <code>Currency</code> instance, the currency symbol and
+ * international currency symbol will be set to the strings "?"
+ * and "XXX" respectively. This generally happens with language
+ * locales (those with no specified country), such as
+ * <code>Locale.ENGLISH</code>.
+ *
+ * @param locale The local to load symbols for.
+ * @throws NullPointerException if the locale is null.
+ */
+ public DecimalFormatSymbols (Locale loc)
+ {
+ ResourceBundle res;
+
+ currency = Currency.getInstance("XXX");
+ currencySymbol = "?";
+ intlCurrencySymbol = "XXX";
+ try
+ {
+ res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
+ loc, ClassLoader.getSystemClassLoader());
+ }
+ catch (MissingResourceException x)
+ {
+ res = null;
+ }
+ try
+ {
+ Currency localeCurrency = Currency.getInstance(loc);
+ if (localeCurrency != null)
+ {
+ setCurrency(localeCurrency);
+ }
+ }
+ catch(IllegalArgumentException exception)
+ {
+ /* Locale has an invalid currency */
+ }
+ decimalSeparator = safeGetChar (res, "decimalSeparator", '.');
+ digit = safeGetChar (res, "digit", '#');
+ exponential = safeGetChar (res, "exponential", 'E');
+ groupingSeparator = safeGetChar (res, "groupingSeparator", ',');
+ infinity = safeGetString (res, "infinity", "\u221e");
+ 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 this instance of <code>DecimalFormatSymbols</code>.
+ *
+ * @return An instance of <code>Currency</code> which matches
+ * the currency used, or null if there is no corresponding
+ * instance.
+ */
+ public Currency getCurrency ()
+ {
+ return currency;
+ }
+
+ /**
+ * 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 method returns the character used to represent the exponential
+ * format. This is a GNU Classpath extension.
+ *
+ * @return the character used to represent an exponential in a format
+ * pattern string.
+ */
+ 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 ISO 4217 currency code for
+ * the currency used.
+ *
+ * @return the ISO 4217 currency code.
+ */
+ 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 symbol and ISO 4217 currency
+ * code to the values obtained from the supplied currency.
+ *
+ * @param currency the currency from which to obtain the values.
+ * @throws NullPointerException if the currency is null.
+ */
+ public void setCurrency (Currency currency)
+ {
+ intlCurrencySymbol = currency.getCurrencyCode();
+ currencySymbol = currency.getSymbol();
+ this.currency = currency;
+ }
+
+ /**
+ * This method sets the currency symbol to the specified value.
+ *
+ * @param currencySymbol The new currency symbol
+ */
+ public void setCurrencySymbol (String currency)
+ {
+ currencySymbol = currency;
+ }
+
+ /**
+ * This method sets the decimal point character to the specified value.
+ *
+ * @param decimalSeparator 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 method sets the exponential character used in the format string to
+ * the specified value. This is a GNU Classpath extension.
+ *
+ * @param exp the character used for the exponential in a format pattern.
+ */
+ void setExponential (char exp)
+ {
+ exponential = exp;
+ }
+
+ /**
+ * This method sets the character used to separate groups of digits.
+ *
+ * @param groupingSeparator 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 symbol to the
+ * specified value. If a valid <code>Currency</code> instance
+ * exists for the international currency code, then this is
+ * used for the currency attribute, and the currency symbol
+ * is set to the corresponding value from this instance.
+ * Otherwise, the currency attribute is set to null and the
+ * symbol is left unmodified.
+ *
+ * @param currencyCode The new international currency symbol.
+ */
+ public void setInternationalCurrencySymbol (String currencyCode)
+ {
+ intlCurrencySymbol = currencyCode;
+ try
+ {
+ currency = Currency.getInstance(currencyCode);
+ }
+ catch (IllegalArgumentException exception)
+ {
+ currency = null;
+ }
+ if (currency != null)
+ {
+ setCurrencySymbol(currency.getSymbol(locale));
+ }
+ }
+
+ /**
+ * 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 monetarySeparator 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 patternSeparator 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;
+
+ /**
+ * The currency used for the symbols in this instance.
+ * This is stored temporarily for efficiency reasons,
+ * as well as to ensure that the correct instance
+ * is restored from the currency code.
+ *
+ * @serial Ignored.
+ */
+ private transient Currency currency;
+
+ 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;
+ }
+}
===================================================================
Checking out kaffe/libraries/javalib/java/util/Currency.java
RCS: /home/cvs/kaffe/kaffe/libraries/javalib/java/util/Currency.java,v
VERS: 1.16
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/javalib/java/util/Currency.java Tue Apr 19 20:40:42 2005
@@ -0,0 +1,437 @@
+/* Currency.java -- Representation of a currency
+ Copyright (C) 2003, 2004, 2005 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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.util;
+
+import gnu.java.locale.LocaleHelper;
+
+import java.io.IOException;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+/**
+ * Representation of a currency for a particular locale. Each currency
+ * is identified by its ISO 4217 code, and only one instance of this
+ * class exists per currency. As a result, instances are created
+ * via the <code>getInstance()</code> methods rather than by using
+ * a constructor.
+ *
+ * @see java.util.Locale
+ * @author Guilhem Lavaux (guilhem.lavaux at free.fr)
+ * @author Dalibor Topic (robilad at kaffe.org)
+ * @author Bryce McKinlay (mckinlay at redhat.com)
+ * @author Andrew John Hughes (gnu_andrew at member.fsf.org)
+ * @since 1.4
+ */
+public final class Currency
+ implements Serializable
+{
+ /**
+ * For compatability with Sun's JDK
+ */
+ static final long serialVersionUID = -158308464356906721L;
+
+ /**
+ * The set of properties which map a currency to
+ * the currency information such as the ISO 4217
+ * currency code and the number of decimal points.
+ *
+ * @see #getCurrencyCode()
+ * @serial ignored.
+ */
+ private static transient Properties properties;
+
+ /**
+ * The ISO 4217 currency code associated with this
+ * particular instance.
+ *
+ * @see #getCurrencyCode()
+ * @serial the ISO 4217 currency code
+ */
+ private String currencyCode;
+
+ /**
+ * The number of fraction digits associated with this
+ * particular instance.
+ *
+ * @see #getDefaultFractionDigits()
+ * @serial the number of fraction digits
+ */
+ private transient int fractionDigits;
+
+ /**
+ * A cached map of country codes
+ * instances to international currency code
+ * <code>String</code>s. Seperating this
+ * from the <code>Currency</code> instances
+ * ensures we have a common lookup between
+ * the two <code>getInstance()</code> methods.
+ *
+ * @see #getInstance(java.util.Locale)
+ * @serial ignored.
+ */
+ private static transient Map countryMap;
+
+ /**
+ * A cache of <code>Currency</code> instances to
+ * ensure the singleton nature of this class. The key
+ * is the international currency code.
+ *
+ * @see #getInstance(java.util.Locale)
+ * @see #getInstance(java.lang.String)
+ * @see #readResolve()
+ * @serial ignored.
+ */
+ private static transient Map cache;
+
+ /**
+ * Instantiates the cache and reads in the properties.
+ */
+ static
+ {
+ /* Create a hash map for the locale mappings */
+ countryMap = new HashMap();
+ /* Create a hash map for the cache */
+ cache = new HashMap();
+ /* Create the properties object */
+ properties = new Properties();
+ /* Try and load the properties from our iso4217.properties resource */
+ try
+ {
+ properties.load(Currency.class.getResourceAsStream("iso4217.properties"));
+ }
+ catch (IOException exception)
+ {
+ System.out.println("Failed to load currency resource: " + exception);
+ }
+ }
+
+ /**
+ * Default constructor for deserialization
+ */
+ private Currency()
+ {
+ }
+
+ /**
+ * Constructor to create a <code>Currency</code> object
+ * for a particular <code>Locale</code>.
+ * All components of the given locale, other than the
+ * country code, are ignored. The results of calling this
+ * method may vary over time, as the currency associated with
+ * a particular country changes. For countries without
+ * a given currency (e.g. Antarctica), the result is null.
+ *
+ * @param loc the locale for the new currency, or null if
+ * there is no country code specified or a currency
+ * for this country.
+ */
+ private Currency(Locale loc)
+ {
+ String countryCode;
+ String currencyKey;
+ String fractionDigitsKey;
+ int commaPosition;
+
+ /* Retrieve the country code from the locale */
+ countryCode = loc.getCountry();
+ /* If there is no country code, return */
+ if (countryCode.equals(""))
+ {
+ throw new
+ IllegalArgumentException("Invalid (empty) country code for locale:"
+ + loc);
+ }
+ /* Construct the key for the currency */
+ currencyKey = countryCode + ".currency";
+ /* Construct the key for the fraction digits */
+ fractionDigitsKey = countryCode + ".fractionDigits";
+ /* Retrieve the currency */
+ currencyCode = properties.getProperty(currencyKey);
+ /* Return if the currency code is null */
+ if (currencyCode == null)
+ {
+ return;
+ }
+ /* Split off the first currency code (we only use the first for now) */
+ commaPosition = currencyCode.indexOf(",");
+ if (commaPosition != -1)
+ {
+ currencyCode = currencyCode.substring(0, commaPosition);
+ }
+ /* Retrieve the fraction digits */
+ fractionDigits = Integer.parseInt(properties.getProperty(fractionDigitsKey));
+ }
+
+ /**
+ * Constructor for the "XXX" special case. This allows
+ * a Currency to be constructed from an assumed good
+ * currency code.
+ *
+ * @param code the code to use.
+ */
+ private Currency(String code)
+ {
+ currencyCode = code;
+ fractionDigits = -1; /* Pseudo currency */
+ }
+
+ /**
+ * Returns the ISO4217 currency code of this currency.
+ *
+ * @return a <code>String</code> containing currency code.
+ */
+ public String getCurrencyCode()
+ {
+ return currencyCode;
+ }
+
+ /**
+ * Returns the number of digits which occur after the decimal point
+ * for this particular currency. For example, currencies such
+ * as the U.S. dollar, the Euro and the Great British pound have two
+ * digits following the decimal point to indicate the value which exists
+ * in the associated lower-valued coinage (cents in the case of the first
+ * two, pennies in the latter). Some currencies such as the Japanese
+ * Yen have no digits after the decimal point. In the case of pseudo
+ * currencies, such as IMF Special Drawing Rights, -1 is returned.
+ *
+ * @return the number of digits after the decimal separator for this currency.
+ */
+ public int getDefaultFractionDigits()
+ {
+ return fractionDigits;
+ }
+
+ /**
+ * Builds a new currency instance for this locale.
+ * All components of the given locale, other than the
+ * country code, are ignored. The results of calling this
+ * method may vary over time, as the currency associated with
+ * a particular country changes. For countries without
+ * a given currency (e.g. Antarctica), the result is null.
+ *
*** Patch too long, truncated ***
More information about the kaffe
mailing list