The Tor Browser: intl/icu/source/i18n/currpinf.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/currpinf.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/currpinf.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
  *******************************************************************************
  * Copyright (C) 2009-2011, 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 = -1;
     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 = -1;
     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

The Tor Browser / annotate

intl/icu/source/i18n/currpinf.cpp@fc2d59ddac77 (annotated)

intl/icu/source/i18n/currpinf.cpp