/* 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 modifyit under the terms of the GNU General Public License as published bythe 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, butWITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNUGeneral Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU Classpath; see the file COPYING.  If not, write to theFree Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA02110-1301 USA.Linking this library statically or dynamically with other modules ismaking a combined work based on this library.  Thus, the terms andconditions of the GNU General Public License cover the wholecombination.As a special exception, the copyright holders of this library give youpermission to link this library with independent modules to produce anexecutable, regardless of the license terms of these independentmodules, and to copy and distribute the resulting executable underterms of your choice, provided that you also meet, for each linkedindependent module, the terms and conditions of the license of thatmodule.  An independent module is a module which is not derived fromor based on this library.  If you modify this library, you may extendthis exception to your version of the library, but you are notobligated to do so.  If you do not wish to do so, delete thisexception 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@free.fr) * @author Dalibor Topic (robilad@kaffe.org) * @author Bryce McKinlay (mckinlay@redhat.com) * @author Andrew John Hughes (gnu_andrew@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.    *   * @param locale a <code>Locale</code> instance.   * @return a new <code>Currency</code> instance.   * @throws NullPointerException if the locale or its   *         country code is null.   * @throws IllegalArgumentException if the country of   *         the given locale is not a supported ISO3166 code.   */   public static Currency getInstance(Locale locale)  {    /**     * The new instance must be the only available instance     * for the currency it supports.  We ensure this happens,     * while maintaining a suitable performance level, by     * creating the appropriate object on the first call to     * this method, and returning the cached instance on     * later calls.     */    Currency newCurrency;    String country = locale.getCountry();    if (locale == null || country == null)      {	throw new	  NullPointerException("The locale or its country is null.");      }    /* Attempt to get the currency from the cache */    String code = (String) countryMap.get(country);    if (code == null)      {        /* Create the currency for this locale */        newCurrency = new Currency(locale);        /*          * If the currency code is null, then creation failed         * and we return null.         */	code = newCurrency.getCurrencyCode();        if (code == null)          {            return null;          }        else           {            /* Cache it */            countryMap.put(country, code);	    cache.put(code, newCurrency);          }      }    else      {	newCurrency = (Currency) cache.get(code);      }    /* Return the instance */    return newCurrency;  }  /**   * Builds the currency corresponding to the specified currency code.   *   * @param currencyCode a string representing a currency code.   * @return a new <code>Currency</code> instance.   * @throws NullPointerException if currencyCode is null.   * @throws IllegalArgumentException if the supplied currency code   *         is not a supported ISO 4217 code.   */  public static Currency getInstance(String currencyCode)  {    Locale[] allLocales;    /*      * Throw a null pointer exception explicitly if currencyCode is null.     * One is not thrown otherwise.  It results in an     * IllegalArgumentException.      */    if (currencyCode == null)      {        throw new NullPointerException("The supplied currency code is null.");      }    /* Nasty special case to allow an erroneous currency... blame Sun */    if (currencyCode.equals("XXX"))      return new Currency("XXX");    Currency newCurrency = (Currency) cache.get(currencyCode);    if (newCurrency == null)      {	/* Get all locales */	allLocales = Locale.getAvailableLocales();	/* Loop through each locale, looking for the code */	for (int i = 0;i < allLocales.length; i++)	  {	    try	      {		Currency testCurrency = getInstance (allLocales[i]);		if (testCurrency != null &&		    testCurrency.getCurrencyCode().equals(currencyCode))		  {		    return testCurrency;		  }	      }	    catch (IllegalArgumentException exception)	      {		/* Ignore locales without valid countries */	      }	  }	/* 	 * If we get this far, the code is not supported by any of	 * our locales.	 */	throw new IllegalArgumentException("The currency code, " + currencyCode +					   ", is not supported.");      }    else      {	return newCurrency;      }  }  /**   * This method returns the symbol which precedes or follows a   * value in this particular currency in the default locale.   * In cases where there is no such symbol for the currency,   * the ISO 4217 currency code is returned.   *   * @return the currency symbol, or the ISO 4217 currency code if   *         one doesn't exist.   */  public String getSymbol()  {    return getSymbol(Locale.getDefault());  }  /**   * <p>   * This method returns the symbol which precedes or follows a   * value in this particular currency.  The returned value is   * the symbol used to denote the currency in the specified locale.   * </p>   * <p>   * For example, a supplied locale may specify a different symbol   * for the currency, due to conflicts with its own currency.   * This would be the case with the American currency, the dollar.   * Locales that also use a dollar-based currency (e.g. Canada, Australia)   * need to differentiate the American dollar using 'US$' rather than '$'.   * So, supplying one of these locales to <code>getSymbol()</code> would   * return this value, rather than the standard '$'.   * </p>   * <p>   * In cases where there is no such symbol for a particular currency,   * the ISO 4217 currency code is returned.   * </p>   *   * @param locale the locale to express the symbol in.   * @return the currency symbol, or the ISO 4217 currency code if   *         one doesn't exist.   * @throws NullPointerException if the locale is null.   */  public String getSymbol(Locale locale)  {    return LocaleHelper.getLocalizedString(locale, currencyCode,					   "currenciesSymbol", false, true);  }  /**   * Returns the international ISO4217 currency code of this currency.   *   * @return a <code>String</code> containing the ISO4217 currency code.   */  public String toString()  {    return getCurrencyCode();  }  /**   * Resolves the deserialized object to the singleton instance for its   * particular currency.  The currency code of the deserialized instance   * is used to return the correct instance.   *   * @return the singleton instance for the currency specified by the   *         currency code of the deserialized object.  This replaces   *         the deserialized object as the returned object from   *         deserialization.   * @throws ObjectStreamException if a problem occurs with deserializing   *         the object.   */  private Object readResolve()    throws ObjectStreamException  {    return getInstance(currencyCode);  }}