Home | History | Annotate | Download | only in i18n 
      1 /*
      2  *******************************************************************************
      3  * Copyright (C) 2009-2011, International Business Machines Corporation and
      4  * others. All Rights Reserved.
      5  *******************************************************************************
      6  */
      7 
      8 #include "unicode/currpinf.h"
      9 
     10 #if !UCONFIG_NO_FORMATTING
     11 
     12 //#define CURRENCY_PLURAL_INFO_DEBUG 1
     13 
     14 #ifdef CURRENCY_PLURAL_INFO_DEBUG
     15 #include <iostream>
     16 #endif
     17 
     18 
     19 #include "unicode/locid.h"
     20 #include "unicode/plurrule.h"
     21 #include "unicode/ures.h"
     22 #include "unicode/numsys.h"
     23 #include "cstring.h"
     24 #include "hash.h"
     25 #include "uresimp.h"
     26 #include "ureslocs.h"
     27 
     28 U_NAMESPACE_BEGIN
     29 
     30 
     31 static const UChar gNumberPatternSeparator = 0x3B; // ;
     32 
     33 U_CDECL_BEGIN
     34 
     35 /**
     36  * @internal ICU 4.2
     37  */
     38 static UBool U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2);
     39 
     40 UBool
     41 U_CALLCONV ValueComparator(UHashTok val1, UHashTok val2) {
     42     const UnicodeString* affix_1 = (UnicodeString*)val1.pointer;
     43     const UnicodeString* affix_2 = (UnicodeString*)val2.pointer;
     44     return  *affix_1 == *affix_2;
     45 }
     46 
     47 U_CDECL_END
     48 
     49 
     50 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CurrencyPluralInfo)
     51 
     52 static const UChar gDefaultCurrencyPluralPattern[] = {'0', '.', '#', '#', ' ', 0xA4, 0xA4, 0xA4, 0};
     53 static const UChar gTripleCurrencySign[] = {0xA4, 0xA4, 0xA4, 0};
     54 static const UChar gPluralCountOther[] = {0x6F, 0x74, 0x68, 0x65, 0x72, 0};
     55 static const UChar gPart0[] = {0x7B, 0x30, 0x7D, 0};
     56 static const UChar gPart1[] = {0x7B, 0x31, 0x7D, 0};
     57 
     58 static const char gNumberElementsTag[]="NumberElements";
     59 static const char gLatnTag[]="latn";
     60 static const char gPatternsTag[]="patterns";
     61 static const char gDecimalFormatTag[]="decimalFormat";
     62 static const char gCurrUnitPtnTag[]="CurrencyUnitPatterns";
     63 
     64 CurrencyPluralInfo::CurrencyPluralInfo(UErrorCode& status)
     65 :   fPluralCountToCurrencyUnitPattern(NULL),
     66     fPluralRules(NULL),
     67     fLocale(NULL) {
     68     initialize(Locale::getDefault(), status);
     69 }
     70 
     71 CurrencyPluralInfo::CurrencyPluralInfo(const Locale& locale, UErrorCode& status)
     72 :   fPluralCountToCurrencyUnitPattern(NULL),
     73     fPluralRules(NULL),
     74     fLocale(NULL) {
     75     initialize(locale, status);
     76 }
     77 
     78 CurrencyPluralInfo::CurrencyPluralInfo(const CurrencyPluralInfo& info)
     79 :   UObject(info),
     80     fPluralCountToCurrencyUnitPattern(NULL),
     81     fPluralRules(NULL),
     82     fLocale(NULL) {
     83     *this = info;
     84 }
     85 
     86 
     87 CurrencyPluralInfo&
     88 CurrencyPluralInfo::operator=(const CurrencyPluralInfo& info) {
     89     if (this == &info) {
     90         return *this;
     91     }
     92 
     93     deleteHash(fPluralCountToCurrencyUnitPattern);
     94     UErrorCode status = U_ZERO_ERROR;
     95     fPluralCountToCurrencyUnitPattern = initHash(status);
     96     copyHash(info.fPluralCountToCurrencyUnitPattern,
     97              fPluralCountToCurrencyUnitPattern, status);
     98     if ( U_FAILURE(status) ) {
     99         return *this;
    100     }
    101 
    102     delete fPluralRules;
    103     delete fLocale;
    104     if (info.fPluralRules) {
    105         fPluralRules = info.fPluralRules->clone();
    106     } else {
    107         fPluralRules = NULL;
    108     }
    109     if (info.fLocale) {
    110         fLocale = info.fLocale->clone();
    111     } else {
    112         fLocale = NULL;
    113     }
    114     return *this;
    115 }
    116 
    117 
    118 CurrencyPluralInfo::~CurrencyPluralInfo() {
    119     deleteHash(fPluralCountToCurrencyUnitPattern);
    120     fPluralCountToCurrencyUnitPattern = NULL;
    121     delete fPluralRules;
    122     delete fLocale;
    123     fPluralRules = NULL;
    124     fLocale = NULL;
    125 }
    126 
    127 UBool
    128 CurrencyPluralInfo::operator==(const CurrencyPluralInfo& info) const {
    129 #ifdef CURRENCY_PLURAL_INFO_DEBUG
    130     if (*fPluralRules == *info.fPluralRules) {
    131         std::cout << "same plural rules\n";
    132     }
    133     if (*fLocale == *info.fLocale) {
    134         std::cout << "same locale\n";
    135     }
    136     if (fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern)) {
    137         std::cout << "same pattern\n";
    138     }
    139 #endif
    140     return *fPluralRules == *info.fPluralRules &&
    141            *fLocale == *info.fLocale &&
    142            fPluralCountToCurrencyUnitPattern->equals(*info.fPluralCountToCurrencyUnitPattern);
    143 }
    144 
    145 
    146 CurrencyPluralInfo*
    147 CurrencyPluralInfo::clone() const {
    148     return new CurrencyPluralInfo(*this);
    149 }
    150 
    151 const PluralRules*
    152 CurrencyPluralInfo::getPluralRules() const {
    153     return fPluralRules;
    154 }
    155 
    156 UnicodeString&
    157 CurrencyPluralInfo::getCurrencyPluralPattern(const UnicodeString&  pluralCount,
    158                                              UnicodeString& result) const {
    159     const UnicodeString* currencyPluralPattern =
    160         (UnicodeString*)fPluralCountToCurrencyUnitPattern->get(pluralCount);
    161     if (currencyPluralPattern == NULL) {
    162         // fall back to "other"
    163         if (pluralCount.compare(gPluralCountOther, 5)) {
    164             currencyPluralPattern =
    165                 (UnicodeString*)fPluralCountToCurrencyUnitPattern->get(UnicodeString(TRUE, gPluralCountOther, 5));
    166         }
    167         if (currencyPluralPattern == NULL) {
    168             // no currencyUnitPatterns defined,
    169             // fallback to predefined defult.
    170             // This should never happen when ICU resource files are
    171             // available, since currencyUnitPattern of "other" is always
    172             // defined in root.
    173             result = UnicodeString(gDefaultCurrencyPluralPattern);
    174             return result;
    175         }
    176     }
    177     result = *currencyPluralPattern;
    178     return result;
    179 }
    180 
    181 const Locale&
    182 CurrencyPluralInfo::getLocale() const {
    183     return *fLocale;
    184 }
    185 
    186 void
    187 CurrencyPluralInfo::setPluralRules(const UnicodeString& ruleDescription,
    188                                    UErrorCode& status) {
    189     if (U_SUCCESS(status)) {
    190         if (fPluralRules) {
    191             delete fPluralRules;
    192         }
    193         fPluralRules = PluralRules::createRules(ruleDescription, status);
    194     }
    195 }
    196 
    197 
    198 void
    199 CurrencyPluralInfo::setCurrencyPluralPattern(const UnicodeString& pluralCount,
    200                                              const UnicodeString& pattern,
    201                                              UErrorCode& status) {
    202     if (U_SUCCESS(status)) {
    203         fPluralCountToCurrencyUnitPattern->put(pluralCount, new UnicodeString(pattern), status);
    204     }
    205 }
    206 
    207 
    208 void
    209 CurrencyPluralInfo::setLocale(const Locale& loc, UErrorCode& status) {
    210     initialize(loc, status);
    211 }
    212 
    213 
    214 void
    215 CurrencyPluralInfo::initialize(const Locale& loc, UErrorCode& status) {
    216     if (U_FAILURE(status)) {
    217         return;
    218     }
    219     delete fLocale;
    220     fLocale = loc.clone();
    221     if (fPluralRules) {
    222         delete fPluralRules;
    223     }
    224     fPluralRules = PluralRules::forLocale(loc, status);
    225     setupCurrencyPluralPattern(loc, status);
    226 }
    227 
    228 
    229 void
    230 CurrencyPluralInfo::setupCurrencyPluralPattern(const Locale& loc, UErrorCode& status) {
    231     if (U_FAILURE(status)) {
    232         return;
    233     }
    234 
    235     if (fPluralCountToCurrencyUnitPattern) {
    236         deleteHash(fPluralCountToCurrencyUnitPattern);
    237     }
    238     fPluralCountToCurrencyUnitPattern = initHash(status);
    239     if (U_FAILURE(status)) {
    240         return;
    241     }
    242 
    243     NumberingSystem *ns = NumberingSystem::createInstance(loc,status);
    244     UErrorCode ec = U_ZERO_ERROR;
    245     UResourceBundle *rb = ures_open(NULL, loc.getName(), &ec);
    246     UResourceBundle *numElements = ures_getByKeyWithFallback(rb, gNumberElementsTag, NULL, &ec);
    247     rb = ures_getByKeyWithFallback(numElements, ns->getName(), rb, &ec);
    248     rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec);
    249     int32_t ptnLen;
    250     const UChar* numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec);
    251     // Fall back to "latn" if num sys specific pattern isn't there.
    252     if ( ec == U_MISSING_RESOURCE_ERROR && uprv_strcmp(ns->getName(),gLatnTag)) {
    253         ec = U_ZERO_ERROR;
    254         rb = ures_getByKeyWithFallback(numElements, gLatnTag, rb, &ec);
    255         rb = ures_getByKeyWithFallback(rb, gPatternsTag, rb, &ec);
    256         numberStylePattern = ures_getStringByKeyWithFallback(rb, gDecimalFormatTag, &ptnLen, &ec);
    257     }
    258     int32_t numberStylePatternLen = ptnLen;
    259     const UChar* negNumberStylePattern = NULL;
    260     int32_t negNumberStylePatternLen = 0;
    261     // TODO: Java
    262     // parse to check whether there is ";" separator in the numberStylePattern
    263     UBool hasSeparator = false;
    264     if (U_SUCCESS(ec)) {
    265         for (int32_t styleCharIndex = 0; styleCharIndex < ptnLen; ++styleCharIndex) {
    266             if (numberStylePattern[styleCharIndex] == gNumberPatternSeparator) {
    267                 hasSeparator = true;
    268                 // split the number style pattern into positive and negative
    269                 negNumberStylePattern = numberStylePattern + styleCharIndex + 1;
    270                 negNumberStylePatternLen = ptnLen - styleCharIndex - 1;
    271                 numberStylePatternLen = styleCharIndex;
    272             }
    273         }
    274     }
    275 
    276     ures_close(numElements);
    277     ures_close(rb);
    278     delete ns;
    279 
    280     if (U_FAILURE(ec)) {
    281         return;
    282     }
    283 
    284     UResourceBundle *currRb = ures_open(U_ICUDATA_CURR, loc.getName(), &ec);
    285     UResourceBundle *currencyRes = ures_getByKeyWithFallback(currRb, gCurrUnitPtnTag, NULL, &ec);
    286 
    287 #ifdef CURRENCY_PLURAL_INFO_DEBUG
    288     std::cout << "in set up\n";
    289 #endif
    290     StringEnumeration* keywords = fPluralRules->getKeywords(ec);
    291     if (U_SUCCESS(ec)) {
    292         const char* pluralCount;
    293         while ((pluralCount = keywords->next(NULL, ec)) != NULL) {
    294             if ( U_SUCCESS(ec) ) {
    295                 int32_t ptnLen;
    296                 UErrorCode err = U_ZERO_ERROR;
    297                 const UChar* patternChars = ures_getStringByKeyWithFallback(
    298                     currencyRes, pluralCount, &ptnLen, &err);
    299                 if (U_SUCCESS(err) && ptnLen > 0) {
    300                     UnicodeString* pattern = new UnicodeString(patternChars, ptnLen);
    301 #ifdef CURRENCY_PLURAL_INFO_DEBUG
    302                     char result_1[1000];
    303                     pattern->extract(0, pattern->length(), result_1, "UTF-8");
    304                     std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n";
    305 #endif
    306                     pattern->findAndReplace(UnicodeString(TRUE, gPart0, 3),
    307                       UnicodeString(numberStylePattern, numberStylePatternLen));
    308                     pattern->findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3));
    309 
    310                     if (hasSeparator) {
    311                         UnicodeString negPattern(patternChars, ptnLen);
    312                         negPattern.findAndReplace(UnicodeString(TRUE, gPart0, 3),
    313                           UnicodeString(negNumberStylePattern, negNumberStylePatternLen));
    314                         negPattern.findAndReplace(UnicodeString(TRUE, gPart1, 3), UnicodeString(TRUE, gTripleCurrencySign, 3));
    315                         pattern->append(gNumberPatternSeparator);
    316                         pattern->append(negPattern);
    317                     }
    318 #ifdef CURRENCY_PLURAL_INFO_DEBUG
    319                     pattern->extract(0, pattern->length(), result_1, "UTF-8");
    320                     std::cout << "pluralCount: " << pluralCount << "; pattern: " << result_1 << "\n";
    321 #endif
    322 
    323                     fPluralCountToCurrencyUnitPattern->put(UnicodeString(pluralCount, -1, US_INV), pattern, status);
    324                 }
    325             }
    326         }
    327     }
    328     delete keywords;
    329     ures_close(currencyRes);
    330     ures_close(currRb);
    331 }
    332 
    333 
    334 
    335 void
    336 CurrencyPluralInfo::deleteHash(Hashtable* hTable)
    337 {
    338     if ( hTable == NULL ) {
    339         return;
    340     }
    341     int32_t pos = -1;
    342     const UHashElement* element = NULL;
    343     while ( (element = hTable->nextElement(pos)) != NULL ) {
    344         const UHashTok valueTok = element->value;
    345         const UnicodeString* value = (UnicodeString*)valueTok.pointer;
    346         delete value;
    347     }
    348     delete hTable;
    349     hTable = NULL;
    350 }
    351 
    352 
    353 Hashtable*
    354 CurrencyPluralInfo::initHash(UErrorCode& status) {
    355     if ( U_FAILURE(status) ) {
    356         return NULL;
    357     }
    358     Hashtable* hTable;
    359     if ( (hTable = new Hashtable(TRUE, status)) == NULL ) {
    360         status = U_MEMORY_ALLOCATION_ERROR;
    361         return NULL;
    362     }
    363     if ( U_FAILURE(status) ) {
    364         delete hTable;
    365         return NULL;
    366     }
    367     hTable->setValueComparator(ValueComparator);
    368     return hTable;
    369 }
    370 
    371 
    372 void
    373 CurrencyPluralInfo::copyHash(const Hashtable* source,
    374                            Hashtable* target,
    375                            UErrorCode& status) {
    376     if ( U_FAILURE(status) ) {
    377         return;
    378     }
    379     int32_t pos = -1;
    380     const UHashElement* element = NULL;
    381     if ( source ) {
    382         while ( (element = source->nextElement(pos)) != NULL ) {
    383             const UHashTok keyTok = element->key;
    384             const UnicodeString* key = (UnicodeString*)keyTok.pointer;
    385             const UHashTok valueTok = element->value;
    386             const UnicodeString* value = (UnicodeString*)valueTok.pointer;
    387             UnicodeString* copy = new UnicodeString(*value);
    388             target->put(UnicodeString(*key), copy, status);
    389             if ( U_FAILURE(status) ) {
    390                 return;
    391             }
    392         }
    393     }
    394 }
    395 
    396 
    397 U_NAMESPACE_END
    398 
    399 #endif
    400