@java.io.Serial

private static final long serialVersionUID = -158308464356906721L;

/**

private final String currencyCode;

/**

private final transient int defaultFractionDigits;

/**

private final transient int numericCode;

// class data: instance map

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

private static final LazyConstant<HashSet<Currency>> available =

LazyConstant.of(Currency::computeAllCurrencies);

// 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 20-31: unused

// - bits 10-19: numeric code (0 to 1023)

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

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

// - bits 5-8: 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 specialCasesList

static int formatVersion;

static int dataVersion;

static int[] mainTable;

static List<SpecialCaseEntry> specialCasesList;

static List<OtherCurrencyEntry> otherCurrenciesList;

// 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 = 0x0000007F;

// entry for countries without currency

private static final int COUNTRY_WITHOUT_CURRENCY_ENTRY = 0x00000200;

// mask for simple case country entries

private static final int SIMPLE_CASE_COUNTRY_MASK = 0x00000000;

// mask for simple case country entry final character

private static final int SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK = 0x0000001F;

// mask for simple case country entry default currency digits

private static final int SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK = 0x000001E0;

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

private static final int SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT = 5;

// maximum number for simple case country entry default currency digits

private static final int SIMPLE_CASE_COUNTRY_MAX_DEFAULT_DIGITS = 9;

// mask for special case country entries

private static final int SPECIAL_CASE_COUNTRY_MASK = 0x00000200;

// mask for special case country index

private static final int SPECIAL_CASE_COUNTRY_INDEX_MASK = 0x0000001F;

// 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 = 0x000FFC00;

// shift count for the numeric code of the currency

private static final int NUMERIC_CODE_SHIFT = 10;

// Currency data format version

private static final int VALID_FORMAT_VERSION = 3;

static {

initStatic();

}

private static void initStatic() {

try {

try (InputStream in = Currency.class.getResourceAsStream("/java/util/currency.data")) {

if (in == null) {

throw new InternalError("Currency data not found");

}

DataInputStream dis = new DataInputStream(new BufferedInputStream(in));

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();

specialCasesList = readSpecialCases(dis, scCount);

int ocCount = dis.readInt();

otherCurrenciesList = readOtherCurrencies(dis, ocCount);

}

} catch (IOException e) {

throw new InternalError(e);

}

// look for the properties file for overrides

String propsFile = System.getProperty("java.util.currency.data");

if (propsFile == null) {

propsFile = StaticProperty.javaHome() + File.separator + "lib" +

File.separator + "currency.properties";

}

try {

File propFile = new File(propsFile);

if (propFile.exists()) {

Properties props = new Properties();

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

props.load(fr);

}

Pattern propertiesPattern =

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

"(\\d+)\\s*,?\\s*(\\d{4}-\\d{2}-\\d{2}T\\d{2}:" +

"\\d{2}:\\d{2})?");

List<CurrencyProperty> currencyEntries

= getValidCurrencyData(props, propertiesPattern);

currencyEntries.forEach(Currency::replaceCurrencyData);

}

} catch (IOException e) {

CurrencyProperty.info("currency.properties is ignored"

+ " because of an IOException", e);

}

}

/**

private static final int SYMBOL = 0;

private static final int DISPLAYNAME = 1;

/**

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

this.currencyCode = currencyCode;

this.defaultFractionDigits = defaultFractionDigits;

this.numericCode = numericCode;

}

/**

public static Currency getInstance(String currencyCode) {

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

}

private static Currency getInstance(String currencyCode, int defaultFractionDigits,

int numericCode) {

// 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.

boolean found = false;

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

throw new IllegalArgumentException(

"The input currency code: \"%s\" must have a length of 3 characters".formatted(currencyCode));

}

char char1 = currencyCode.charAt(0);

char char2 = currencyCode.charAt(1);

if (!isValidCountryFormat(char1, char2)) {

throw new IllegalArgumentException(

"The country code: \"%c%c\" is not a valid ISO 3166 code".formatted(char1, char2));

}

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;

found = true;

} else { //special case

int[] fractionAndNumericCode = SpecialCaseEntry.findEntry(currencyCode);

if (fractionAndNumericCode != null) {

defaultFractionDigits = fractionAndNumericCode[0];

numericCode = fractionAndNumericCode[1];

found = true;

}

}

if (!found) {

OtherCurrencyEntry ocEntry = OtherCurrencyEntry.findEntry(currencyCode);

if (ocEntry == null) {

throw new IllegalArgumentException(

"The input currency code: \"%s\" is not a valid ISO 4217 code".formatted(currencyCode));

}

defaultFractionDigits = ocEntry.fraction;

numericCode = ocEntry.numericCode;

}

}

Currency currencyVal =

new Currency(currencyCode, defaultFractionDigits, numericCode);

instance = instances.putIfAbsent(currencyCode, currencyVal);

return (instance != null ? instance : currencyVal);

}

/**

public static Currency getInstance(Locale locale) {

// check for locale overrides

String override = locale.getUnicodeLocaleType("cu");

if (override != null) {

try {

return getInstance(override.toUpperCase(Locale.ROOT));

} catch (IllegalArgumentException iae) {

// override currency is invalid. Fall through.

}

}

String country = CalendarDataUtility.findRegionOverride(locale).getCountry();

char char1;

char char2;

if (country.length() != 2 || !isValidCountryFormat(char1 = country.charAt(0), char2 = country.charAt(1))) {

throw new IllegalArgumentException(

"The country of the input locale: \"%s\" is not a valid ISO 3166 country code".formatted(locale));

}

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;

StringBuilder sb = new StringBuilder(country);

sb.append(finalChar);

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

} else {

// special cases

if (tableEntry == INVALID_COUNTRY_ENTRY) {

throw new IllegalArgumentException(

"The country of the input locale: \"%s\" is not a valid ISO 3166 country code".formatted(locale));

}

if (tableEntry == COUNTRY_WITHOUT_CURRENCY_ENTRY) {

return null;

} else {

int index = SpecialCaseEntry.toIndex(tableEntry);

SpecialCaseEntry scEntry = specialCasesList.get(index);

if (scEntry.cutOverTime == Long.MAX_VALUE

|| System.currentTimeMillis() < scEntry.cutOverTime) {

return getInstance(scEntry.oldCurrency,

scEntry.oldCurrencyFraction,

scEntry.oldCurrencyNumericCode);

} else {

return getInstance(scEntry.newCurrency,

scEntry.newCurrencyFraction,

scEntry.newCurrencyNumericCode);

}

}

}

}

/**

public static Set<Currency> getAvailableCurrencies() {

return new HashSet<>(available.get());

}

/**

public static Stream<Currency> availableCurrencies() {

return available.get().stream();

}

// Builds and returns the set of available Currencies

private static HashSet<Currency> computeAllCurrencies() {

var sysTime = System.currentTimeMillis();

HashSet<Currency> available = HashSet.newHashSet(256);

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) {

// Simple Currencies

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));

} else if ((tableEntry & COUNTRY_TYPE_MASK) == SPECIAL_CASE_COUNTRY_MASK

&& tableEntry != INVALID_COUNTRY_ENTRY

&& tableEntry != COUNTRY_WITHOUT_CURRENCY_ENTRY) {

// Special Currencies

int index = SpecialCaseEntry.toIndex(tableEntry);

SpecialCaseEntry scEntry = specialCasesList.get(index);

if (scEntry.cutOverTime == Long.MAX_VALUE

|| sysTime < scEntry.cutOverTime) {

available.add(getInstance(scEntry.oldCurrency,

scEntry.oldCurrencyFraction,

scEntry.oldCurrencyNumericCode));

} else {

available.add(getInstance(scEntry.newCurrency,

scEntry.newCurrencyFraction,

scEntry.newCurrencyNumericCode));

}

}

}

}

// Other Currencies

for (OtherCurrencyEntry entry : otherCurrenciesList) {

available.add(getInstance(entry.currencyCode));

}

return available;

}

/**

public String getCurrencyCode() {

return currencyCode;

}

/**

public String getSymbol() {

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

}

/**

public String getSymbol(Locale locale) {

LocaleServiceProviderPool pool =

LocaleServiceProviderPool.getPool(CurrencyNameProvider.class);

locale = CalendarDataUtility.findRegionOverride(locale);

String symbol = pool.getLocalizedObject(

CurrencyNameGetter.INSTANCE,

locale, currencyCode, SYMBOL);

if (symbol != null) {

return symbol;

}

// use currency code as symbol of last resort

return currencyCode;

}

/**

public int getDefaultFractionDigits() {

return defaultFractionDigits;

}

/**

public int getNumericCode() {

return numericCode;

}

/**

public String getNumericCodeAsString() {

/* numeric code could be returned as a 3 digit string simply by using

if (numericCode < 100) {

StringBuilder sb = new StringBuilder();

sb.append('0');

if (numericCode < 10) {

sb.append('0');

}

return sb.append(numericCode).toString();

}

return String.valueOf(numericCode);

}

/**

public String getDisplayName() {

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

}

/**

public String getDisplayName(Locale locale) {

LocaleServiceProviderPool pool =

LocaleServiceProviderPool.getPool(CurrencyNameProvider.class);

String result = pool.getLocalizedObject(

CurrencyNameGetter.INSTANCE,

locale, currencyCode, DISPLAYNAME);

if (result != null) {

return result;

}

// use currency code as symbol of last resort

return currencyCode;

}

/**

@Override

public String toString() {

return currencyCode;

}

/**

@java.io.Serial

private Object readResolve() {

return getInstance(currencyCode);

}

/**

private static boolean isValidCountryFormat(char char1, char char2) {

return char1 >= 'A' && char1 <= 'Z' && char2 >= 'A' && char2 <= 'Z';

}

/**

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

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

}

/**

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

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

throw new IllegalArgumentException(

"The country code: \"%c%c\" is not a valid ISO 3166 code".formatted(char1, char2));

}

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

}

/**

private static class CurrencyNameGetter

implements LocaleServiceProviderPool.LocalizedObjectGetter<CurrencyNameProvider,

String> {

private static final CurrencyNameGetter INSTANCE = new CurrencyNameGetter();

@Override

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 List<SpecialCaseEntry> readSpecialCases(DataInputStream dis,

int count)

throws IOException {

List<SpecialCaseEntry> list = new ArrayList<>(count);

long cutOverTime;

String oldCurrency;

String newCurrency;

int oldCurrencyFraction;

int newCurrencyFraction;

int oldCurrencyNumericCode;

int newCurrencyNumericCode;

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

cutOverTime = dis.readLong();

oldCurrency = dis.readUTF();

newCurrency = dis.readUTF();

oldCurrencyFraction = dis.readInt();

newCurrencyFraction = dis.readInt();

oldCurrencyNumericCode = dis.readInt();

newCurrencyNumericCode = dis.readInt();

SpecialCaseEntry sc = new SpecialCaseEntry(cutOverTime,

oldCurrency, newCurrency,

oldCurrencyFraction, newCurrencyFraction,

oldCurrencyNumericCode, newCurrencyNumericCode);

list.add(sc);

}

return list;

}

private static List<OtherCurrencyEntry> readOtherCurrencies(DataInputStream dis,

int count)

throws IOException {

List<OtherCurrencyEntry> list = new ArrayList<>(count);

String currencyCode;

int fraction;

int numericCode;

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

currencyCode = dis.readUTF();

fraction = dis.readInt();

numericCode = dis.readInt();

OtherCurrencyEntry oc = new OtherCurrencyEntry(currencyCode,

fraction,

numericCode);

list.add(oc);

}

return list;

}

/**

private static List<CurrencyProperty> getValidCurrencyData(Properties props,

Pattern pattern) {

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

List<CurrencyProperty> propertyEntries = new ArrayList<>();

// remove all invalid entries and parse all valid currency properties

// entries to a group of CurrencyProperty, classified by currency code

Map<String, List<CurrencyProperty>> currencyCodeGroup = keys.stream()

.map(k -> CurrencyProperty

.getValidEntry(k.toUpperCase(Locale.ROOT),

props.getProperty(k).toUpperCase(Locale.ROOT),

pattern)).flatMap(o -> o.stream())

.collect(Collectors.groupingBy(entry -> entry.currencyCode));

// check each group for inconsistencies

currencyCodeGroup.forEach((curCode, list) -> {

boolean inconsistent = CurrencyProperty

.containsInconsistentInstances(list);

if (inconsistent) {

list.forEach(prop -> CurrencyProperty.info("The property"

+ " entry for " + prop.country + " is inconsistent."

+ " Ignored.", null));

} else {

propertyEntries.addAll(list);

}

});

return propertyEntries;

}

/**

private static void replaceCurrencyData(CurrencyProperty prop) {

String ctry = prop.country;

String code = prop.currencyCode;

int numeric = prop.numericCode;

int fraction = prop.fraction;

int entry = numeric << NUMERIC_CODE_SHIFT;

int index = SpecialCaseEntry.indexOf(code, fraction, numeric);

// If a new entry changes the numeric code/dfd of an existing

// currency code, update it in the sc list at the respective

// index and also change it in the other currencies list and

// main table (if that currency code is also used as a

// simple case).

// If all three components do not match with the new entry,

// but the currency code exists in the special case list

// update the sc entry with the new entry

int scCurrencyCodeIndex = -1;

if (index == -1) {

scCurrencyCodeIndex = SpecialCaseEntry.currencyCodeIndex(code);

if (scCurrencyCodeIndex != -1) {

//currency code exists in sc list, then update the old entry

specialCasesList.set(scCurrencyCodeIndex,

new SpecialCaseEntry(code, fraction, numeric));

// also update the entry in other currencies list

OtherCurrencyEntry oe = OtherCurrencyEntry.findEntry(code);

if (oe != null) {

int oIndex = otherCurrenciesList.indexOf(oe);

otherCurrenciesList.set(oIndex, new OtherCurrencyEntry(

code, fraction, numeric));

}

}

}

/* If a country switches from simple case to special case or

if (index == -1 && (ctry.charAt(0) != code.charAt(0)

|| ctry.charAt(1) != code.charAt(1))) {

if(scCurrencyCodeIndex == -1) {

specialCasesList.add(new SpecialCaseEntry(code, fraction,

numeric));

index = specialCasesList.size() - 1;

} else {

index = scCurrencyCodeIndex;

}

// update the entry in main table if it exists as a simple case

updateMainTableEntry(code, fraction, numeric);

}

if (index == -1) {

// 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);

}

// update the entry in maintable for any simple case found, if a new

// entry as a special case updates the entry in sc list with

// existing currency code

private static void updateMainTableEntry(String code, int fraction,

int numeric) {

// checking the existence of currency code in mainTable

int tableEntry = getMainTableEntry(code.charAt(0), code.charAt(1));

int entry = numeric << NUMERIC_CODE_SHIFT;

if ((tableEntry & COUNTRY_TYPE_MASK) == SIMPLE_CASE_COUNTRY_MASK

&& tableEntry != INVALID_COUNTRY_ENTRY

&& code.charAt(2) - 'A' == (tableEntry

& SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK)) {

int numericCode = (tableEntry & NUMERIC_CODE_MASK)

>> NUMERIC_CODE_SHIFT;

int defaultFractionDigits = (tableEntry

& SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK)

>> SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT;

if (numeric != numericCode || fraction != defaultFractionDigits) {

// update the entry in main table

entry |= (fraction << SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT)

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

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

}

}

}

/* Used to represent a special case currency entry

private static class SpecialCaseEntry {

private final long cutOverTime;

private final String oldCurrency;

private final String newCurrency;

private final int oldCurrencyFraction;

private final int newCurrencyFraction;

private final int oldCurrencyNumericCode;

private final int newCurrencyNumericCode;

private SpecialCaseEntry(long cutOverTime, String oldCurrency, String newCurrency,

int oldCurrencyFraction, int newCurrencyFraction,

int oldCurrencyNumericCode, int newCurrencyNumericCode) {

this.cutOverTime = cutOverTime;

this.oldCurrency = oldCurrency;

this.newCurrency = newCurrency;

this.oldCurrencyFraction = oldCurrencyFraction;

this.newCurrencyFraction = newCurrencyFraction;

this.oldCurrencyNumericCode = oldCurrencyNumericCode;

this.newCurrencyNumericCode = newCurrencyNumericCode;

}

private SpecialCaseEntry(String currencyCode, int fraction,

int numericCode) {

this(Long.MAX_VALUE, currencyCode, "", fraction, 0, numericCode, 0);