/*

 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.util;

import java.io.BufferedInputStream;

import java.io.DataInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.Serializable;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.logging.Level;

import java.util.regex.Pattern;

import java.util.regex.Matcher;

import java.util.spi.CurrencyNameProvider;

import java.util.spi.LocaleServiceProvider;

import sun.util.LocaleServiceProviderPool;

import sun.util.logging.PlatformLogger;

import sun.util.resources.LocaleData;

import sun.util.resources.OpenListResourceBundle;

/**

 * Represents a currency. Currencies are identified by their ISO 4217 currency

 * codes. Visit the <a href="http://www.iso.org/iso/en/prods-services/popstds/currencycodes.html">

 * ISO web site</a> for more information, including a table of

 * currency codes.

 * <p>

 * The class is designed so that there's never more than one

 * <code>Currency</code> instance for any given currency. Therefore, there's

 * no public constructor. You obtain a <code>Currency</code> instance using

 * the <code>getInstance</code> methods.

 * <p>

 * Users can supersede the Java runtime currency data by creating a properties

 * file named <code>&lt;JAVA_HOME&gt;/lib/currency.properties</code>.  The contents

 * of the properties file are key/value pairs of the ISO 3166 country codes

 * and the ISO 4217 currency data respectively.  The value part consists of

 * three ISO 4217 values of a currency, i.e., an alphabetic code, a numeric

 * code, and a minor unit.  Those three ISO 4217 values are separated by commas.

 * The lines which start with '#'s are considered comment lines.  For example,

 * <p>

 * <code>

 * #Sample currency properties<br>

 * JP=JPZ,999,0

 * </code>

 * <p>

 * will supersede the currency data for Japan.

 *

 * @since 1.4

 */

public final class Currency implements Serializable {

    private static final long serialVersionUID = -158308464356906721L;

    /**

     * ISO 4217 currency code for this currency.

     *

     * @serial

     */

    private final String currencyCode;

    /**

     * Default fraction digits for this currency.

     * Set from currency data tables.

     */

    transient private final int defaultFractionDigits;

    /**

     * ISO 4217 numeric code for this currency.

     * Set from currency data tables.

     */

    transient private final int numericCode;

    // class data: instance map

    private static HashMap<String, Currency> instances = new HashMap<String, Currency>(7);

    private static HashSet<Currency> available;

    // Class data: currency data obtained from currency.data file.

    // Purpose:

    // - determine valid country codes

    // - determine valid currency codes

    // - map country codes to currency codes

    // - obtain default fraction digits for currency codes

    //

    // sc = special case; dfd = default fraction digits

    // Simple countries are those where the country code is a prefix of the

    // currency code, and there are no known plans to change the currency.

    //

    // table formats:

    // - mainTable:

    //   - maps country code to 32-bit int

    //   - 26*26 entries, corresponding to [A-Z]*[A-Z]

    //   - \u007F -> not valid country

    //   - bits 18-31: unused

    //   - bits 8-17: numeric code (0 to 1023)

    //   - bit 7: 1 - special case, bits 0-4 indicate which one

    //            0 - simple country, bits 0-4 indicate final char of currency code

    //   - bits 5-6: fraction digits for simple countries, 0 for special cases

    //   - bits 0-4: final char for currency code for simple country, or ID of special case

    // - special case IDs:

    //   - 0: country has no currency

    //   - other: index into sc* arrays + 1

    // - scCutOverTimes: cut-over time in millis as returned by

    //   System.currentTimeMillis for special case countries that are changing

    //   currencies; Long.MAX_VALUE for countries that are not changing currencies

    // - scOldCurrencies: old currencies for special case countries

    // - scNewCurrencies: new currencies for special case countries that are

    //   changing currencies; null for others

    // - scOldCurrenciesDFD: default fraction digits for old currencies

    // - scNewCurrenciesDFD: default fraction digits for new currencies, 0 for

    //   countries that are not changing currencies

    // - otherCurrencies: concatenation of all currency codes that are not the

    //   main currency of a simple country, separated by "-"

    // - otherCurrenciesDFD: decimal format digits for currencies in otherCurrencies, same order

    static int formatVersion;

    static int dataVersion;

    static int[] mainTable;

    static long[] scCutOverTimes;

    static String[] scOldCurrencies;

    static String[] scNewCurrencies;

    static int[] scOldCurrenciesDFD;

    static int[] scNewCurrenciesDFD;

    static int[] scOldCurrenciesNumericCode;

    static int[] scNewCurrenciesNumericCode;

    static String otherCurrencies;

    static int[] otherCurrenciesDFD;

    static int[] otherCurrenciesNumericCode;

    // handy constants - must match definitions in GenerateCurrencyData

    // magic number

    private static final int MAGIC_NUMBER = 0x43757244;

    // number of characters from A to Z

    private static final int A_TO_Z = ('Z' - 'A') + 1;

    // entry for invalid country codes

    private static final int INVALID_COUNTRY_ENTRY = 0x007F;

    // entry for countries without currency

    private static final int COUNTRY_WITHOUT_CURRENCY_ENTRY = 0x0080;

    // mask for simple case country entries

    private static final int SIMPLE_CASE_COUNTRY_MASK = 0x0000;

    // mask for simple case country entry final character

    private static final int SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK = 0x001F;

    // mask for simple case country entry default currency digits

    private static final int SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK = 0x0060;

    // shift count for simple case country entry default currency digits

    private static final int SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT = 5;

    // mask for special case country entries

    private static final int SPECIAL_CASE_COUNTRY_MASK = 0x0080;

    // mask for special case country index

    private static final int SPECIAL_CASE_COUNTRY_INDEX_MASK = 0x001F;

    // delta from entry index component in main table to index into special case tables

    private static final int SPECIAL_CASE_COUNTRY_INDEX_DELTA = 1;

    // mask for distinguishing simple and special case countries

    private static final int COUNTRY_TYPE_MASK = SIMPLE_CASE_COUNTRY_MASK | SPECIAL_CASE_COUNTRY_MASK;

    // mask for the numeric code of the currency

    private static final int NUMERIC_CODE_MASK = 0x0003FF00;

    // shift count for the numeric code of the currency

    private static final int NUMERIC_CODE_SHIFT = 8;

    // Currency data format version

    private static final int VALID_FORMAT_VERSION = 1;

    static {

        AccessController.doPrivileged(new PrivilegedAction() {

            public Object run() {

                String homeDir = System.getProperty("java.home");

                try {

                    String dataFile = homeDir + File.separator +

                            "lib" + File.separator + "currency.data";

                    DataInputStream dis = new DataInputStream(

                        new BufferedInputStream(

                        new FileInputStream(dataFile)));

                    if (dis.readInt() != MAGIC_NUMBER) {

                        throw new InternalError("Currency data is possibly corrupted");

                    }

                    formatVersion = dis.readInt();

                    if (formatVersion != VALID_FORMAT_VERSION) {

                        throw new InternalError("Currency data format is incorrect");

                    }

                    dataVersion = dis.readInt();

                    mainTable = readIntArray(dis, A_TO_Z * A_TO_Z);

                    int scCount = dis.readInt();

                    scCutOverTimes = readLongArray(dis, scCount);

                    scOldCurrencies = readStringArray(dis, scCount);

                    scNewCurrencies = readStringArray(dis, scCount);

                    scOldCurrenciesDFD = readIntArray(dis, scCount);

                    scNewCurrenciesDFD = readIntArray(dis, scCount);

                    scOldCurrenciesNumericCode = readIntArray(dis, scCount);

                    scNewCurrenciesNumericCode = readIntArray(dis, scCount);

                    int ocCount = dis.readInt();

                    otherCurrencies = dis.readUTF();

                    otherCurrenciesDFD = readIntArray(dis, ocCount);

                    otherCurrenciesNumericCode = readIntArray(dis, ocCount);

                    dis.close();

                } catch (IOException e) {

                    InternalError ie = new InternalError();

                    ie.initCause(e);

                    throw ie;

                }

                // look for the properties file for overrides

                try {

                    File propFile = new File(homeDir + File.separator +

                                             "lib" + File.separator +

                                             "currency.properties");

                    if (propFile.exists()) {

                        Properties props = new Properties();

                        try (FileReader fr = new FileReader(propFile)) {

                            props.load(fr);

                        }

                        Set<String> keys = props.stringPropertyNames();

                        Pattern propertiesPattern =

                            Pattern.compile("([A-Z]{3})\\s*,\\s*(\\d{3})\\s*,\\s*([0-3])");

                        for (String key : keys) {

                           replaceCurrencyData(propertiesPattern,

                               key.toUpperCase(Locale.ROOT),

                               props.getProperty(key).toUpperCase(Locale.ROOT));

                        }

                    }

                } catch (IOException e) {

                    info("currency.properties is ignored because of an IOException", e);

                }

                return null;

            }

        });

    }

    /**

     * Constants for retrieving localized names from the name providers.

     */

    private static final int SYMBOL = 0;

    private static final int DISPLAYNAME = 1;

    /**

     * Constructs a <code>Currency</code> instance. The constructor is private

     * so that we can insure that there's never more than one instance for a

     * given currency.

     */

    private Currency(String currencyCode, int defaultFractionDigits, int numericCode) {

        this.currencyCode = currencyCode;

        this.defaultFractionDigits = defaultFractionDigits;

        this.numericCode = numericCode;

    }

    /**

     * Returns the <code>Currency</code> instance for the given currency code.

     *

     * @param currencyCode the ISO 4217 code of the currency

     * @return the <code>Currency</code> instance for the given currency code

     * @exception NullPointerException if <code>currencyCode</code> is null

     * @exception IllegalArgumentException if <code>currencyCode</code> is not

     * a supported ISO 4217 code.

     */

    public static Currency getInstance(String currencyCode) {

        return getInstance(currencyCode, Integer.MIN_VALUE, 0);

    }

    private static Currency getInstance(String currencyCode, int defaultFractionDigits,

        int numericCode) {

        synchronized (instances) {

            // Try to look up the currency code in the instances table.

            // This does the null pointer check as a side effect.

            // Also, if there already is an entry, the currencyCode must be valid.

            Currency instance = instances.get(currencyCode);

            if (instance != null) {

                return instance;

            }

            if (defaultFractionDigits == Integer.MIN_VALUE) {

                // Currency code not internally generated, need to verify first

                // A currency code must have 3 characters and exist in the main table

                // or in the list of other currencies.

                if (currencyCode.length() != 3) {

                    throw new IllegalArgumentException();

                }

                char char1 = currencyCode.charAt(0);

                char char2 = currencyCode.charAt(1);

                int tableEntry = getMainTableEntry(char1, char2);

                if ((tableEntry & COUNTRY_TYPE_MASK) == SIMPLE_CASE_COUNTRY_MASK

                        && tableEntry != INVALID_COUNTRY_ENTRY

                        && currencyCode.charAt(2) - 'A' == (tableEntry & SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK)) {

                    defaultFractionDigits = (tableEntry & SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK) >> SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT;

                    numericCode = (tableEntry & NUMERIC_CODE_MASK) >> NUMERIC_CODE_SHIFT;

                } else {

                    // Check for '-' separately so we don't get false hits in the table.

                    if (currencyCode.charAt(2) == '-') {

                        throw new IllegalArgumentException();

                    }

                    int index = otherCurrencies.indexOf(currencyCode);

                    if (index == -1) {

                        throw new IllegalArgumentException();

                    }

                    defaultFractionDigits = otherCurrenciesDFD[index / 4];

                    numericCode = otherCurrenciesNumericCode[index / 4];

                }

            }

            instance = new Currency(currencyCode, defaultFractionDigits, numericCode);

            instances.put(currencyCode, instance);

            return instance;

        }

    }

    /**

     * Returns the <code>Currency</code> instance for the country of the

     * given locale. The language and variant components of the locale

     * are ignored. The result may vary over time, as countries change their

     * currencies. For example, for the original member countries of the

     * European Monetary Union, the method returns the old national currencies

     * until December 31, 2001, and the Euro from January 1, 2002, local time

     * of the respective countries.

     * <p>

     * The method returns <code>null</code> for territories that don't

     * have a currency, such as Antarctica.

     *

     * @param locale the locale for whose country a <code>Currency</code>

     * instance is needed

     * @return the <code>Currency</code> instance for the country of the given

     * locale, or null

     * @exception NullPointerException if <code>locale</code> or its country

     * code is null

     * @exception IllegalArgumentException if the country of the given locale

     * is not a supported ISO 3166 country code.

     */

    public static Currency getInstance(Locale locale) {

        String country = locale.getCountry();

        if (country == null) {

            throw new NullPointerException();

        }

        if (country.length() != 2) {

            throw new IllegalArgumentException();

        }

        char char1 = country.charAt(0);

        char char2 = country.charAt(1);

        int tableEntry = getMainTableEntry(char1, char2);

        if ((tableEntry & COUNTRY_TYPE_MASK) == SIMPLE_CASE_COUNTRY_MASK

                    && tableEntry != INVALID_COUNTRY_ENTRY) {

            char finalChar = (char) ((tableEntry & SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK) + 'A');

            int defaultFractionDigits = (tableEntry & SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK) >> SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT;

            int numericCode = (tableEntry & NUMERIC_CODE_MASK) >> NUMERIC_CODE_SHIFT;

            StringBuffer sb = new StringBuffer(country);

            sb.append(finalChar);

            return getInstance(sb.toString(), defaultFractionDigits, numericCode);

        } else {

            // special cases

            if (tableEntry == INVALID_COUNTRY_ENTRY) {

                throw new IllegalArgumentException();

            }

            if (tableEntry == COUNTRY_WITHOUT_CURRENCY_ENTRY) {

                return null;

            } else {

                int index = (tableEntry & SPECIAL_CASE_COUNTRY_INDEX_MASK) - SPECIAL_CASE_COUNTRY_INDEX_DELTA;

                if (scCutOverTimes[index] == Long.MAX_VALUE || System.currentTimeMillis() < scCutOverTimes[index]) {

                    return getInstance(scOldCurrencies[index], scOldCurrenciesDFD[index],

                        scOldCurrenciesNumericCode[index]);

                } else {

                    return getInstance(scNewCurrencies[index], scNewCurrenciesDFD[index],

                        scNewCurrenciesNumericCode[index]);

                }

            }

        }

    }

    /**

     * Gets the set of available currencies.  The returned set of currencies

     * contains all of the available currencies, which may include currencies

     * that represent obsolete ISO 4217 codes.  The set can be modified

     * without affecting the available currencies in the runtime.

     *

     * @return the set of available currencies.  If there is no currency

     *    available in the runtime, the returned set is empty.

     * @since 1.7

     */

    public static Set<Currency> getAvailableCurrencies() {

        synchronized(Currency.class) {

            if (available == null) {

                available = new HashSet<Currency>(256);

                // Add simple currencies first

                for (char c1 = 'A'; c1 <= 'Z'; c1 ++) {

                    for (char c2 = 'A'; c2 <= 'Z'; c2 ++) {

                        int tableEntry = getMainTableEntry(c1, c2);

                        if ((tableEntry & COUNTRY_TYPE_MASK) == SIMPLE_CASE_COUNTRY_MASK

                             && tableEntry != INVALID_COUNTRY_ENTRY) {

                            char finalChar = (char) ((tableEntry & SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK) + 'A');

                            int defaultFractionDigits = (tableEntry & SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK) >> SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT;

                            int numericCode = (tableEntry & NUMERIC_CODE_MASK) >> NUMERIC_CODE_SHIFT;

                            StringBuilder sb = new StringBuilder();

                            sb.append(c1);

                            sb.append(c2);

                            sb.append(finalChar);

                            available.add(getInstance(sb.toString(), defaultFractionDigits, numericCode));

                        }

                    }

                }

                // Now add other currencies

                StringTokenizer st = new StringTokenizer(otherCurrencies, "-");

                while (st.hasMoreElements()) {

                    available.add(getInstance((String)st.nextElement()));

                }

            }

        }

        return (Set<Currency>) available.clone();

    }

    /**

     * Gets the ISO 4217 currency code of this currency.

     *

     * @return the ISO 4217 currency code of this currency.

     */

    public String getCurrencyCode() {

        return currencyCode;

    }

    /**

     * Gets the symbol of this currency for the default locale.

     * For example, for the US Dollar, the symbol is "$" if the default

     * locale is the US, while for other locales it may be "US$". If no

     * symbol can be determined, the ISO 4217 currency code is returned.

     *

     * @return the symbol of this currency for the default locale

     */

    public String getSymbol() {

        return getSymbol(Locale.getDefault(Locale.Category.DISPLAY));

    }

    /**

     * Gets the symbol of this currency for the specified locale.

     * For example, for the US Dollar, the symbol is "$" if the specified

     * locale is the US, while for other locales it may be "US$". If no

     * symbol can be determined, the ISO 4217 currency code is returned.

     *

     * @param locale the locale for which a display name for this currency is

     * needed

     * @return the symbol of this currency for the specified locale

     * @exception NullPointerException if <code>locale</code> is null

     */

    public String getSymbol(Locale locale) {

        try {

            // Check whether a provider can provide an implementation that's closer

            // to the requested locale than what the Java runtime itself can provide.

            LocaleServiceProviderPool pool =

                LocaleServiceProviderPool.getPool(CurrencyNameProvider.class);

            if (pool.hasProviders()) {

                // Assuming that all the country locales include necessary currency

                // symbols in the Java runtime's resources,  so there is no need to

                // examine whether Java runtime's currency resource bundle is missing

                // names.  Therefore, no resource bundle is provided for calling this

                // method.

                String symbol = pool.getLocalizedObject(

                                    CurrencyNameGetter.INSTANCE,

                                    locale, (OpenListResourceBundle)null,

                                    currencyCode, SYMBOL);

                if (symbol != null) {

                    return symbol;

                }

            }

            ResourceBundle bundle = LocaleData.getCurrencyNames(locale);

            return bundle.getString(currencyCode);

        } catch (MissingResourceException e) {

            // use currency code as symbol of last resort

            return currencyCode;

        }

    }

    /**

     * Gets the default number of fraction digits used with this currency.

     * For example, the default number of fraction digits for the Euro is 2,

     * while for the Japanese Yen it's 0.

     * In the case of pseudo-currencies, such as IMF Special Drawing Rights,

     * -1 is returned.

     *

     * @return the default number of fraction digits used with this currency

     */

    public int getDefaultFractionDigits() {

        return defaultFractionDigits;

    }

    /**

     * Returns the ISO 4217 numeric code of this currency.

     *

     * @return the ISO 4217 numeric code of this currency

     * @since 1.7

     */

    public int getNumericCode() {

        return numericCode;

    }

    /**

     * Gets the name that is suitable for displaying this currency for

     * the default locale.  If there is no suitable display name found

     * for the default locale, the ISO 4217 currency code is returned.

     *

     * @return the display name of this currency for the default locale

     * @since 1.7

     */

    public String getDisplayName() {

        return getDisplayName(Locale.getDefault(Locale.Category.DISPLAY));

    }

    /**

     * Gets the name that is suitable for displaying this currency for

     * the specified locale.  If there is no suitable display name found

     * for the specified locale, the ISO 4217 currency code is returned.

     *

     * @param locale the locale for which a display name for this currency is

     * needed

     * @return the display name of this currency for the specified locale

     * @exception NullPointerException if <code>locale</code> is null

     * @since 1.7

     */

    public String getDisplayName(Locale locale) {

        try {

            OpenListResourceBundle bundle = LocaleData.getCurrencyNames(locale);

            String result = null;

            String bundleKey = currencyCode.toLowerCase(Locale.ROOT);

            // Check whether a provider can provide an implementation that's closer

            // to the requested locale than what the Java runtime itself can provide.

            LocaleServiceProviderPool pool =

                LocaleServiceProviderPool.getPool(CurrencyNameProvider.class);

            if (pool.hasProviders()) {

                result = pool.getLocalizedObject(

                                    CurrencyNameGetter.INSTANCE,

                                    locale, bundleKey, bundle, currencyCode, DISPLAYNAME);

            }

            if (result == null) {

                result = bundle.getString(bundleKey);

            }

            if (result != null) {

                return result;

            }

        } catch (MissingResourceException e) {

            // fall through

        }

        // use currency code as symbol of last resort

        return currencyCode;

    }

    /**

     * Returns the ISO 4217 currency code of this currency.

     *

     * @return the ISO 4217 currency code of this currency

     */

    public String toString() {

        return currencyCode;

    }

    /**

     * Resolves instances being deserialized to a single instance per currency.

     */

    private Object readResolve() {

        return getInstance(currencyCode);

    }

    /**

     * Gets the main table entry for the country whose country code consists

     * of char1 and char2.

     */

    private static int getMainTableEntry(char char1, char char2) {

        if (char1 < 'A' || char1 > 'Z' || char2 < 'A' || char2 > 'Z') {

            throw new IllegalArgumentException();

        }

        return mainTable[(char1 - 'A') * A_TO_Z + (char2 - 'A')];

    }

    /**

     * Sets the main table entry for the country whose country code consists

     * of char1 and char2.

     */

    private static void setMainTableEntry(char char1, char char2, int entry) {

        if (char1 < 'A' || char1 > 'Z' || char2 < 'A' || char2 > 'Z') {

            throw new IllegalArgumentException();

        }

        mainTable[(char1 - 'A') * A_TO_Z + (char2 - 'A')] = entry;

    }

    /**

     * Obtains a localized currency names from a CurrencyNameProvider

     * implementation.

     */

    private static class CurrencyNameGetter

        implements LocaleServiceProviderPool.LocalizedObjectGetter<CurrencyNameProvider,

                                                                   String> {

        private static final CurrencyNameGetter INSTANCE = new CurrencyNameGetter();

        public String getObject(CurrencyNameProvider currencyNameProvider,

                                Locale locale,

                                String key,

                                Object... params) {

            assert params.length == 1;

            int type = (Integer)params[0];

            switch(type) {

            case SYMBOL:

                return currencyNameProvider.getSymbol(key, locale);

            case DISPLAYNAME:

                return currencyNameProvider.getDisplayName(key, locale);

            default:

                assert false; // shouldn't happen

            }

            return null;

        }

    }

    private static int[] readIntArray(DataInputStream dis, int count) throws IOException {

        int[] ret = new int[count];

        for (int i = 0; i < count; i++) {

            ret[i] = dis.readInt();

        }

        return ret;

    }

    private static long[] readLongArray(DataInputStream dis, int count) throws IOException {

        long[] ret = new long[count];

        for (int i = 0; i < count; i++) {

            ret[i] = dis.readLong();

        }

        return ret;

    }

    private static String[] readStringArray(DataInputStream dis, int count) throws IOException {

        String[] ret = new String[count];

        for (int i = 0; i < count; i++) {

            ret[i] = dis.readUTF();

        }

        return ret;

    }

    /**

     * Replaces currency data found in the currencydata.properties file

     *

     * @param pattern regex pattern for the properties

     * @param ctry country code

     * @param data currency data.  This is a comma separated string that

     *    consists of "three-letter alphabet code", "three-digit numeric code",

     *    and "one-digit (0,1,2, or 3) default fraction digit".

     *    For example, "JPZ,392,0".

     * @throws

     */

    private static void replaceCurrencyData(Pattern pattern, String ctry, String curdata) {

        if (ctry.length() != 2) {

            // ignore invalid country code

            String message = new StringBuilder()

                .append("The entry in currency.properties for ")

                .append(ctry).append(" is ignored because of the invalid country code.")

                .toString();

            info(message, null);

            return;

        }

        Matcher m = pattern.matcher(curdata);

        if (!m.find()) {

            // format is not recognized.  ignore the data

            String message = new StringBuilder()

                .append("The entry in currency.properties for ")

                .append(ctry)

                .append(" is ignored because the value format is not recognized.")

                .toString();

            info(message, null);

            return;

        }

        String code = m.group(1);

        int numeric = Integer.parseInt(m.group(2));

        int fraction = Integer.parseInt(m.group(3));

        int entry = numeric << NUMERIC_CODE_SHIFT;

        int index;

        for (index = 0; index < scOldCurrencies.length; index++) {

            if (scOldCurrencies[index].equals(code)) {

                break;

            }

        }

        if (index == scOldCurrencies.length) {

            // simple case

            entry |= (fraction << SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT) |

                     (code.charAt(2) - 'A');

        } else {

            // special case

            entry |= SPECIAL_CASE_COUNTRY_MASK |

                     (index + SPECIAL_CASE_COUNTRY_INDEX_DELTA);

        }

        setMainTableEntry(ctry.charAt(0), ctry.charAt(1), entry);

    }

    private static void info(String message, Throwable t) {

        PlatformLogger logger = PlatformLogger.getLogger("java.util.Currency");

        if (logger.isLoggable(PlatformLogger.INFO)) {

            if (t != null) {

                logger.info(message, t);

            } else {

                logger.info(message);

            }

        }

    }

}