/*
*******************************************************************************
* Copyright (C) 2009-2010, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import java.lang.ref.SoftReference;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import com.ibm.icu.impl.CurrencyData.CurrencyDisplayInfo;
import com.ibm.icu.impl.CurrencyData.CurrencyDisplayInfoProvider;
import com.ibm.icu.impl.CurrencyData.CurrencyFormatInfo;
import com.ibm.icu.impl.CurrencyData.CurrencySpacingInfo;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.UResourceBundle;
public class ICUCurrencyDisplayInfoProvider implements CurrencyDisplayInfoProvider {
public ICUCurrencyDisplayInfoProvider() {
}
public CurrencyDisplayInfo getInstance(ULocale locale, boolean withFallback) {
ICUResourceBundle rb = (ICUResourceBundle) UResourceBundle.getBundleInstance(
ICUResourceBundle.ICU_CURR_BASE_NAME, locale);
if (!withFallback) {
int status = rb.getLoadingStatus();
if (status == ICUResourceBundle.FROM_DEFAULT || status == ICUResourceBundle.FROM_ROOT) {
return CurrencyData.DefaultInfo.getWithFallback(false);
}
}
return new ICUCurrencyDisplayInfo(rb, withFallback);
}
public boolean hasData() {
return true;
}
static class ICUCurrencyDisplayInfo extends CurrencyDisplayInfo {
private final boolean fallback;
private final ICUResourceBundle rb;
private final ICUResourceBundle currencies;
private final ICUResourceBundle plurals;
private SoftReference<Map<String, String>> _symbolMapRef;
private SoftReference<Map<String, String>> _nameMapRef;
public ICUCurrencyDisplayInfo(ICUResourceBundle rb, boolean fallback) {
this.fallback = fallback;
this.rb = rb;
this.currencies = rb.findTopLevel("Currencies");
this.plurals = rb.findTopLevel("CurrencyPlurals");
}
@Override
public ULocale getLocale() {
return rb.getULocale();
}
@Override
public String getName(String isoCode) {
return getName(isoCode, false);
}
@Override
public String getSymbol(String isoCode) {
return getName(isoCode, true);
}
private String getName(String isoCode, boolean symbolName) {
if (currencies != null) {
ICUResourceBundle result = currencies.findWithFallback(isoCode);
if (result != null) {
if (!fallback) {
int status = result.getLoadingStatus();
if (status == ICUResourceBundle.FROM_DEFAULT ||
status == ICUResourceBundle.FROM_ROOT) {
return null;
}
}
return result.getString(symbolName ? 0 : 1);
}
}
return fallback ? isoCode : null;
}
@Override
public String getPluralName(String isoCode, String pluralKey ) {
// See http://unicode.org/reports/tr35/#Currencies, especially the fallback rule.
if (plurals != null) {
ICUResourceBundle pluralsBundle = plurals.findWithFallback(isoCode);
if (pluralsBundle != null) {
ICUResourceBundle pluralBundle = pluralsBundle.findWithFallback(pluralKey);
if (pluralBundle == null) {
if (!fallback) {
return null;
}
pluralBundle = pluralsBundle.findWithFallback("other");
if (pluralBundle == null) {
return getName(isoCode);
}
}
return pluralBundle.getString();
}
}
return fallback ? getName(isoCode) : null;
}
@Override
public Map<String, String> symbolMap() {
Map<String, String> map = _symbolMapRef == null ? null : _symbolMapRef.get();
if (map == null) {
map = _createSymbolMap();
// atomic and idempotent
_symbolMapRef = new SoftReference<Map<String, String>>(map);
}
return map;
}
@Override
public Map<String, String> nameMap() {
Map<String, String> map = _nameMapRef == null ? null : _nameMapRef.get();
if (map == null) {
map = _createNameMap();
// atomic and idempotent
_nameMapRef = new SoftReference<Map<String, String>>(map);
}
return map;
}
@Override
public Map<String, String> getUnitPatterns() {
Map<String, String> result = new HashMap<String, String>();
ULocale locale = rb.getULocale();
for (;locale != null; locale = locale.getFallback()) {
ICUResourceBundle r = (ICUResourceBundle) UResourceBundle.getBundleInstance(
ICUResourceBundle.ICU_CURR_BASE_NAME, locale);
if (r == null) {
continue;
}
ICUResourceBundle cr = r.findWithFallback("CurrencyUnitPatterns");
if (cr == null) {
continue;
}
for (int index = 0, size = cr.getSize(); index < size; ++index) {
ICUResourceBundle b = (ICUResourceBundle) cr.get(index);
String key = b.getKey();
if (result.containsKey(key)) {
continue;
}
result.put(key, b.getString());
}
}
// Default result is the empty map. Callers who require a pattern will have to
// supply a default.
return Collections.unmodifiableMap(result);
}
@Override
public CurrencyFormatInfo getFormatInfo(String isoCode) {
ICUResourceBundle crb = currencies.findWithFallback(isoCode);
if (crb != null && crb.getSize() > 2) {
crb = crb.at(2);
if (crb != null) {
String pattern = crb.getString(0);
char separator = crb.getString(1).charAt(0);
char groupingSeparator = crb.getString(2).charAt(0);
return new CurrencyFormatInfo(pattern, separator, groupingSeparator);
}
}
return null;
}
@Override
public CurrencySpacingInfo getSpacingInfo() {
ICUResourceBundle srb = rb.findWithFallback("currencySpacing");
if (srb != null) {
ICUResourceBundle brb = srb.findWithFallback("beforeCurrency");
ICUResourceBundle arb = srb.findWithFallback("afterCurrency");
if (brb != null && brb != null) {
String beforeCurrencyMatch = brb.findWithFallback("currencyMatch").getString();
String beforeContextMatch = brb.findWithFallback("surroundingMatch").getString();
String beforeInsert = brb.findWithFallback("insertBetween").getString();
String afterCurrencyMatch = arb.findWithFallback("currencyMatch").getString();
String afterContextMatch = arb.findWithFallback("surroundingMatch").getString();
String afterInsert = arb.findWithFallback("insertBetween").getString();
return new CurrencySpacingInfo(
beforeCurrencyMatch, beforeContextMatch, beforeInsert,
afterCurrencyMatch, afterContextMatch, afterInsert);
}
}
return fallback ? CurrencySpacingInfo.DEFAULT : null;
}
private Map<String, String> _createSymbolMap() {
Map<String, String> result = new HashMap<String, String>();
for (ULocale locale = rb.getULocale(); locale != null; locale = locale.getFallback()) {
ICUResourceBundle bundle = (ICUResourceBundle)
UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_CURR_BASE_NAME, locale);
ICUResourceBundle curr = bundle.findTopLevel("Currencies");
if (curr == null) {
continue;
}
for (int i = 0; i < curr.getSize(); ++i) {
ICUResourceBundle item = curr.at(i);
String isoCode = item.getKey();
if (!result.containsKey(isoCode)) {
// put the code itself
result.put(isoCode, isoCode);
// 0 == symbol element
String symbol = item.getString(0);
result.put(symbol, isoCode);
}
}
}
return Collections.unmodifiableMap(result);
}
private Map<String, String> _createNameMap() {
// ignore case variants
Map<String, String> result = new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER);
Set<String> visited = new HashSet<String>();
Map<String, Set<String>> visitedPlurals = new HashMap<String, Set<String>>();
for (ULocale locale = rb.getULocale(); locale != null; locale = locale.getFallback()) {
ICUResourceBundle bundle = (ICUResourceBundle)
UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_CURR_BASE_NAME, locale);
ICUResourceBundle curr = bundle.findTopLevel("Currencies");
if (curr != null) {
for (int i = 0; i < curr.getSize(); ++i) {
ICUResourceBundle item = curr.at(i);
String isoCode = item.getKey();
if (!visited.contains(isoCode)) {
visited.add(isoCode);
// 1 == name element
String name = item.getString(1);
result.put(name, isoCode);
}
}
}
ICUResourceBundle plurals = bundle.findTopLevel("CurrencyPlurals");
if (plurals != null) {
for (int i = 0; i < plurals.getSize(); ++i) {
ICUResourceBundle item = plurals.at(i);
String isoCode = item.getKey();
Set<String> pluralSet = visitedPlurals.get(isoCode);
if (pluralSet == null) {
pluralSet = new HashSet<String>();
visitedPlurals.put(isoCode, pluralSet);
}
for (int j = 0; j < item.getSize(); ++j) {
ICUResourceBundle plural = item.at(j);
String pluralType = plural.getKey();
if (!pluralSet.contains(pluralType)) {
String pluralName = plural.getString();
result.put(pluralName, isoCode);
pluralSet.add(pluralType);
}
}
}
}
}
return Collections.unmodifiableMap(result);
}
}
}