| /* |
| ******************************************************************************* |
| * Copyright (C) 2009-2014, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ******************************************************************************* |
| */ |
| |
| #include "unicode/currpinf.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| //#define CURRENCY_PLURAL_INFO_DEBUG 1 |
| |
| #ifdef CURRENCY_PLURAL_INFO_DEBUG |
| #include <iostream> |
| #endif |
| |
| |
| #include "unicode/locid.h" |
| #include "unicode/plurrule.h" |
| #include "unicode/ures.h" |
| #include "unicode/numsys.h" |
| #include "cstring.h" |
| #include "hash.h" |
| #include "uresimp.h" |
| #include "ureslocs.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| |
| static const UChar gNumberPatternSeparator = 0x3B; // ; |
| |
| U_CDECL_BEGIN |
| |
| /** |
| * @internal ICU 4.2 |
| */ |
| static UBool U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2); |
| |
| UBool |
| U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2) { |
| const UnicodeString* affix_1 = (UnicodeString*)val1.pointer; |
| const UnicodeString* affix_2 = (UnicodeString*)val2.pointer; |
| return *affix_1 == *affix_2; |
| } |
| |
| U_CDECL_END |
| |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CurrencyPluralInfo) |
| |
| static const UChar gDefaultCurrencyPluralPattern[] = {'0', '.', '#', '#', ' ', 0xA4, 0xA4, 0xA4, 0}; |
| static const UChar gTripleCurrencySign[] = {0xA4, 0xA4, 0xA4, 0}; |
| static const UChar gPluralCountOther[] = {0x6F, 0x74, 0x68, 0x65, 0x72, 0}; |
| static const UChar gPart0[] = {0x7B, 0x30, 0x7D, 0}; |
| static const UChar gPart1[] = {0x7B, 0x31, 0x7D, 0}; |
| |
| static const char gNumberElementsTag[]="NumberElements"; |
| static const char gLatnTag[]="latn"; |
| static const char gPatternsTag[]="patterns"; |
| static const char gDecimalFormatTag[]="decimalFormat"; |
| static const char gCurrUnitPtnTag[]="CurrencyUnitPatterns"; |
| |
| CurrencyPluralInfo::CurrencyPluralInfo(UErrorCode& status) |
| : fPluralCountToCurrencyUnitPattern(NULL), |
| fPluralRules(NULL), |
| fLocale(NULL) { |
| initialize(Locale::getDefault(), status); |
| } |
| |
| CurrencyPluralInfo::CurrencyPluralInfo(const Locale& locale, UErrorCode& status) |
| : fPluralCountToCurrencyUnitPattern(NULL), |
| fPluralRules(NULL), |
| fLocale(NULL) { |
| initialize(locale, status); |
| } |
| |
| CurrencyPluralInfo::CurrencyPluralInfo(const CurrencyPluralInfo& info) |
| : UObject(info), |
| fPluralCountToCurrencyUnitPattern(NULL), |
| fPluralRules(NULL), |
| fLocale(NULL) { |
| *this = info; |
| } |
| |
| |
| CurrencyPluralInfo& |
| CurrencyPluralInfo::operator=(const CurrencyPluralInfo& info) { |
| if (this == &info) { |
| return *this; |
| } |
| |
| deleteHash(fPluralCountToCurrencyUnitPattern); |
| UErrorCode status = U_ZERO_ERROR; |
| fPluralCountToCurrencyUnitPattern = initHash(status); |
| copyHash(info.fPluralCountToCurrencyUnitPattern, |
| fPluralCountToCurrencyUnitPattern, status); |
| if ( U_FAILURE(status) ) { |
| return *this; |
| } |
| |
| delete fPluralRules; |
| delete fLocale; |
| if (info.fPluralRules) { |
| fPluralRules = info.fPluralRules->clone(); |
| } else { |
| fPluralRules = NULL; |
| } |
| if (info.fLocale) { |
| fLocale = info.fLocale->clone(); |
| } else { |
| fLocale = NULL; |
| } |
| return *this; |
| } |
| |
| |
| CurrencyPluralInfo::~CurrencyPluralInfo() { |
| deleteHash(fPluralCountToCurrencyUnitPattern); |
| fPluralCountToCurrencyUnitPattern = NULL; |
| delete fPluralRules; |
| delete fLocale; |
| fPluralRules = NULL; |
| fLocale = NULL; |
| } |
| |
| UBool |
| CurrencyPluralInfo::operator==(const CurrencyPluralInfo& info) const { |
| #ifdef CURRENCY_PLURAL_INFO_DEBUG |
| if (*fPluralRules == *info.fPluralRules) { |
| std::cout << "same plural rules\n"; |
| } |
| if (*fLocale == *info.fLocale) { |
| std::cout << "same locale\n"; |
| } |
| if (fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern)) { |
| std::cout << "same pattern\n"; |
| } |
| #endif |
| return *fPluralRules == *info.fPluralRules && |
| *fLocale == *info.fLocale && |
| fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern); |
| } |
| |
| |
| CurrencyPluralInfo* |
| CurrencyPluralInfo::clone() const { |
| return new CurrencyPluralInfo(*this); |
| } |
| |
| const PluralRules* |
| CurrencyPluralInfo::getPluralRules() const { |
| return fPluralRules; |
| } |
| |
| UnicodeString& |
| CurrencyPluralInfo::getCurrencyPluralPattern(const UnicodeString& pluralCount, |
| UnicodeString& result) const { |
| const UnicodeString* currencyPluralPattern = |
| (UnicodeString*)fPluralCountToCurrencyUnitPattern->get(pluralCount); |
| if (currencyPluralPattern == NULL) { |
| // fall back to "other" |
| if (pluralCount.compare(gPluralCountOther, 5)) { |
| currencyPluralPattern = |
| (UnicodeString*)fPluralCountToCurrencyUnitPattern->get(UnicodeString(TRUE, gPluralCountOther, 5)); |
| } |
| if (currencyPluralPattern == NULL) { |
| // no currencyUnitPatterns defined, |
| // fallback to predefined defult. |
| // This should never happen when ICU resource files are |
| // available, since currencyUnitPattern of "other" is always |
| // defined in root. |
| result = UnicodeString(gDefaultCurrencyPluralPattern); |
| return result; |
| } |
| } |
| result = *currencyPluralPattern; |
| return result; |
| } |
| |
| const Locale& |
| CurrencyPluralInfo::getLocale() const { |
| return *fLocale; |
| } |
| |
| void |
| CurrencyPluralInfo::setPluralRules(const UnicodeString& ruleDescription, |
| UErrorCode& status) { |
| if (U_SUCCESS(status)) { |
| if (fPluralRules) { |
| delete fPluralRules; |
| } |
| fPluralRules = PluralRules::createRules(ruleDescription, status); |
| } |
| } |
| |
| |
| void |
| CurrencyPluralInfo::setCurrencyPluralPattern(const UnicodeString& pluralCount, |
| const UnicodeString& pattern, |
| UErrorCode& status) { |
| if (U_SUCCESS(status)) { |
| fPluralCountToCurrencyUnitPattern->put(pluralCount, new UnicodeString(pattern), status); |
| } |
| } |
| |
| |
| void |
| CurrencyPluralInfo::setLocale(const Locale& loc, UErrorCode& status) { |
| initialize(loc, status); |
| } |
| |
| |
| void |
| CurrencyPluralInfo::initialize(const Locale& loc, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| delete fLocale; |
| fLocale = loc.clone(); |
| if (fPluralRules) { |
| delete fPluralRules; |
| } |
| fPluralRules = PluralRules::forLocale(loc, status); |
| setupCurrencyPluralPattern(loc, status); |
| } |
| |
| |
| void |
| CurrencyPluralInfo::setupCurrencyPluralPattern(const Locale& loc, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| if (fPluralCountToCurrencyUnitPattern) { |
| deleteHash(fPluralCountToCurrencyUnitPattern); |
| } |
| fPluralCountToCurrencyUnitPattern = initHash(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| NumberingSystem *ns = NumberingSystem::createInstance(loc,status); |
| UErrorCode ec = U_ZERO_ERROR; |
| UResourceBundle *rb = ures_open(NULL, loc.getName(), &ec); |
| UResourceBundle *numElements = ures_getByKeyWithFallback(rb, gNumberElementsTag, NULL, &ec); |
| rb = ures_getByKeyWithFallback(numElements, ns->getName(), rb, &ec); |
| rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec); |
| int32_t ptnLen; |
| const UChar* numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec); |
| // Fall back to "latn" if num sys specific pattern isn't there. |
| if ( ec == U_MISSING_RESOURCE_ERROR && uprv_strcmp(ns->getName(),gLatnTag)) { |
| ec = U_ZERO_ERROR; |
| rb = ures_getByKeyWithFallback(numElements, gLatnTag, rb, &ec); |
| rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec); |
| numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec); |
| } |
| int32_t numberStylePatternLen = ptnLen; |
| const UChar* negNumberStylePattern = NULL; |
| int32_t negNumberStylePatternLen = 0; |
| // TODO: Java |
| // parse to check whether there is ";" separator in the numberStylePattern |
| UBool hasSeparator = false; |
| if (U_SUCCESS(ec)) { |
| for (int32_t styleCharIndex = 0; styleCharIndex < ptnLen; ++styleCharIndex) { |
| if (numberStylePattern[styleCharIndex] == gNumberPatternSeparator) { |
| hasSeparator = true; |
| // split the number style pattern into positive and negative |
| negNumberStylePattern = numberStylePattern + styleCharIndex + 1; |
| negNumberStylePatternLen = ptnLen - styleCharIndex - 1; |
| numberStylePatternLen = styleCharIndex; |
| } |
| } |
| } |
| |
| ures_close(numElements); |
| ures_close(rb); |
| delete ns; |
| |
| if (U_FAILURE(ec)) { |
| return; |
| } |
| |
| UResourceBundle *currRb = ures_open(U_ICUDATA_CURR, loc.getName(), &ec); |
| UResourceBundle *currencyRes = ures_getByKeyWithFallback(currRb, gCurrUnitPtnTag, NULL, &ec); |
| |
| #ifdef CURRENCY_PLURAL_INFO_DEBUG |
| std::cout << "in set up\n"; |
| #endif |
| StringEnumeration* keywords = fPluralRules->getKeywords(ec); |
| if (U_SUCCESS(ec)) { |
| const char* pluralCount; |
| while ((pluralCount = keywords->next(NULL, ec)) != NULL) { |
| if ( U_SUCCESS(ec) ) { |
| int32_t ptnLen; |
| UErrorCode err = U_ZERO_ERROR; |
| const UChar* patternChars = ures_getStringByKeyWithFallback( |
| currencyRes, pluralCount, &ptnLen, &err); |
| if (U_SUCCESS(err) && ptnLen > 0) { |
| UnicodeString* pattern = new UnicodeString(patternChars, ptnLen); |
| #ifdef CURRENCY_PLURAL_INFO_DEBUG |
| char result_1[1000]; |
| pattern->extract(0, pattern->length(), result_1, "UTF-8"); |
| std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n"; |
| #endif |
| pattern->findAndReplace(UnicodeString(TRUE, gPart0, 3), |
| UnicodeString(numberStylePattern, numberStylePatternLen)); |
| pattern->findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3)); |
| |
| if (hasSeparator) { |
| UnicodeString negPattern(patternChars, ptnLen); |
| negPattern.findAndReplace(UnicodeString(TRUE, gPart0, 3), |
| UnicodeString(negNumberStylePattern, negNumberStylePatternLen)); |
| negPattern.findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3)); |
| pattern->append(gNumberPatternSeparator); |
| pattern->append(negPattern); |
| } |
| #ifdef CURRENCY_PLURAL_INFO_DEBUG |
| pattern->extract(0, pattern->length(), result_1, "UTF-8"); |
| std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n"; |
| #endif |
| |
| fPluralCountToCurrencyUnitPattern->put(UnicodeString(pluralCount, -1, US_INV), pattern, status); |
| } |
| } |
| } |
| } |
| delete keywords; |
| ures_close(currencyRes); |
| ures_close(currRb); |
| } |
| |
| |
| |
| void |
| CurrencyPluralInfo::deleteHash(Hashtable* hTable) |
| { |
| if ( hTable == NULL ) { |
| return; |
| } |
| int32_t pos = UHASH_FIRST; |
| const UHashElement* element = NULL; |
| while ( (element = hTable->nextElement(pos)) != NULL ) { |
| const UHashTok valueTok = element->value; |
| const UnicodeString* value = (UnicodeString*)valueTok.pointer; |
| delete value; |
| } |
| delete hTable; |
| hTable = NULL; |
| } |
| |
| |
| Hashtable* |
| CurrencyPluralInfo::initHash(UErrorCode& status) { |
| if ( U_FAILURE(status) ) { |
| return NULL; |
| } |
| Hashtable* hTable; |
| if ( (hTable = new Hashtable(TRUE, status)) == NULL ) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| if ( U_FAILURE(status) ) { |
| delete hTable; |
| return NULL; |
| } |
| hTable->setValueComparator(ValueComparator); |
| return hTable; |
| } |
| |
| |
| void |
| CurrencyPluralInfo::copyHash(const Hashtable* source, |
| Hashtable* target, |
| UErrorCode& status) { |
| if ( U_FAILURE(status) ) { |
| return; |
| } |
| int32_t pos = UHASH_FIRST; |
| const UHashElement* element = NULL; |
| if ( source ) { |
| while ( (element = source->nextElement(pos)) != NULL ) { |
| const UHashTok keyTok = element->key; |
| const UnicodeString* key = (UnicodeString*)keyTok.pointer; |
| const UHashTok valueTok = element->value; |
| const UnicodeString* value = (UnicodeString*)valueTok.pointer; |
| UnicodeString* copy = new UnicodeString(*value); |
| target->put(UnicodeString(*key), copy, status); |
| if ( U_FAILURE(status) ) { |
| return; |
| } |
| } |
| } |
| } |
| |
| |
| U_NAMESPACE_END |
| |
| #endif |
