Update ICU to 54.1 step 1

source/i18n/ucurr.cpp

 /*
 **********************************************************************
-* Copyright (c) 2002-2013, International Business Machines
+* Copyright (c) 2002-2014, International Business Machines
 * Corporation and others.  All Rights Reserved.
 **********************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/ucurr.h"
 #include "unicode/locid.h"
@@ skipping 98 matching lines @@
 static const UChar EUR_STR[] = {0x0045,0x0055,0x0052,0};
 
 // ISO codes mapping table
 static const UHashtable* gIsoCodes = NULL;
 static icu::UInitOnce gIsoCodesInitOnce = U_INITONCE_INITIALIZER;
 
 // Currency symbol equivalances
 static const icu::Hashtable* gCurrSymbolsEquiv = NULL;
 static icu::UInitOnce gCurrSymbolsEquivInitOnce = U_INITONCE_INITIALIZER;
 
+U_NAMESPACE_BEGIN
+
 // EquivIterator iterates over all strings that are equivalent to a given
 // string, s. Note that EquivIterator will never yield s itself.
 class EquivIterator : icu::UMemory {
 public:
     // Constructor. hash stores the equivalence relationships; s is the string
     // for which we find equivalent strings.
     inline EquivIterator(const icu::Hashtable& hash, const icu::UnicodeString& s)
         : _hash(hash) { 
         _start = _current = &s;
     }
@@ skipping 15 matching lines @@
         U_ASSERT(_current == _start);
         return NULL;
     }
     if (*_next == *_start) {
         return NULL;
     }
     _current = _next;
     return _next;
 }
 
+U_NAMESPACE_END
+
 // makeEquivalent makes lhs and rhs equivalent by updating the equivalence
 // relations in hash accordingly.
 static void makeEquivalent(
     const icu::UnicodeString &lhs,
     const icu::UnicodeString &rhs,
     icu::Hashtable* hash, UErrorCode &status) {
     if (U_FAILURE(status)) {
         return;
     }
     if (lhs == rhs) {
         // already equivalent
         return;
     }
-    EquivIterator leftIter(*hash, lhs);
-    EquivIterator rightIter(*hash, rhs);
+    icu::EquivIterator leftIter(*hash, lhs);
+    icu::EquivIterator rightIter(*hash, rhs);
     const icu::UnicodeString *firstLeft = leftIter.next();
     const icu::UnicodeString *firstRight = rightIter.next();
     const icu::UnicodeString *nextLeft = firstLeft;
     const icu::UnicodeString *nextRight = firstRight;
     while (nextLeft != NULL && nextRight != NULL) {
         if (*nextLeft == rhs || *nextRight == lhs) {
             // Already equivalent
             return;
         }
         nextLeft = leftIter.next();
@@ skipping 31 matching lines @@
     }
     hash->put(lhs, (void *) newFirstLeft, status);
     hash->put(rhs, (void *) newFirstRight, status);
 }
 
 // countEquivalent counts how many strings are equivalent to s.
 // hash stores all the equivalnce relations.
 // countEquivalent does not include s itself in the count.
 static int32_t countEquivalent(const icu::Hashtable &hash, const icu::UnicodeString &s) {
     int32_t result = 0;
-    EquivIterator iter(hash, s);
+    icu::EquivIterator iter(hash, s);
     while (iter.next() != NULL) {
         ++result;
     }
 #ifdef UCURR_DEBUG_EQUIV
  {
    char tmp[200];
    s.extract(0,s.length(),tmp, "UTF-8");
    printf("CountEquivalent('%s') = %d\n", tmp, result);
  }
 #endif
@@ skipping 826 matching lines @@
                     (*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = length;
                 }
             } else {
                 // Add currency symbol.
                 (*currencySymbols)[*total_currency_symbol_count].IsoCode = iso;
                 (*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*)s;
                 (*currencySymbols)[*total_currency_symbol_count].flag = 0;
                 (*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = len;
                 // Add equivalent symbols
                 if (currencySymbolsEquiv != NULL) {
-                    EquivIterator iter(*currencySymbolsEquiv, UnicodeString(TRUE, s, len));
+                  icu::EquivIterator iter(*currencySymbolsEquiv, UnicodeString(TRUE, s, len));
                     const UnicodeString *symbol;
                     while ((symbol = iter.next()) != NULL) {
                         (*currencySymbols)[*total_currency_symbol_count].IsoCode = iso;
                         (*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*) symbol->getBuffer();
                         (*currencySymbols)[*total_currency_symbol_count].flag = 0;
                         (*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = symbol->length();
                     }
                 }
             }
 
@@ skipping 528 matching lines @@
                 result.setTo(iso, -1);
             }
         } else {
             result.setTo(currname, -1);
         }
     }
 }
 
 U_CAPI int32_t U_EXPORT2
 ucurr_getDefaultFractionDigits(const UChar* currency, UErrorCode* ec) {
-    return (_findMetaData(currency, *ec))[0];
+    return ucurr_getDefaultFractionDigitsForUsage(currency,UCURR_USAGE_STANDARD,ec);
+}
+
+U_DRAFT int32_t U_EXPORT2
+ucurr_getDefaultFractionDigitsForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) {
+    int32_t fracDigits = 0;
+    if (U_SUCCESS(*ec)) {
+        switch (usage) {
+            case UCURR_USAGE_STANDARD:
+                fracDigits = (_findMetaData(currency, *ec))[0];
+                break;
+            case UCURR_USAGE_CASH:
+                fracDigits = (_findMetaData(currency, *ec))[2];
+                break;
+            default:
+                *ec = U_UNSUPPORTED_ERROR;
+        }
+    }
+    return fracDigits;
 }
 
 U_CAPI double U_EXPORT2
 ucurr_getRoundingIncrement(const UChar* currency, UErrorCode* ec) {
+    return ucurr_getRoundingIncrementForUsage(currency, UCURR_USAGE_STANDARD, ec);
+}
+
+U_DRAFT double U_EXPORT2
+ucurr_getRoundingIncrementForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) {
+    double result = 0.0;
+
     const int32_t *data = _findMetaData(currency, *ec);
+    if (U_SUCCESS(*ec)) {
+        int32_t fracDigits;
+        int32_t increment;
+        switch (usage) {
+            case UCURR_USAGE_STANDARD:
+                fracDigits = data[0];
+                increment = data[1];
+                break;
+            case UCURR_USAGE_CASH:
+                fracDigits = data[2];
+                increment = data[3];
+                break;
+            default:
+                *ec = U_UNSUPPORTED_ERROR;
+                return result;
+        }
 
-    // If the meta data is invalid, return 0.0.
-    if (data[0] < 0 || data[0] > MAX_POW10) {
-        if (U_SUCCESS(*ec)) {
+        // If the meta data is invalid, return 0.0
+        if (fracDigits < 0 || fracDigits > MAX_POW10) {
             *ec = U_INVALID_FORMAT_ERROR;
+        } else {
+            // A rounding value of 0 or 1 indicates no rounding.
+            if (increment >= 2) {
+                // Return (increment) / 10^(fracDigits).  The only actual rounding data,
+                // as of this writing, is CHF { 2, 5 }.
+                result = double(increment) / POW10[fracDigits];
+            }
         }
-        return 0.0;
     }
 
-    // If there is no rounding, return 0.0 to indicate no rounding.  A
-    // rounding value (data[1]) of 0 or 1 indicates no rounding.
-    if (data[1] < 2) {
-        return 0.0;
-    }
-
-    // Return data[1] / 10^(data[0]).  The only actual rounding data,
-    // as of this writing, is CHF { 2, 5 }.
-    return double(data[1]) / POW10[data[0]];
+    return result;
 }
 
 U_CDECL_BEGIN
 
 typedef struct UCurrencyContext {
     uint32_t currType; /* UCurrCurrencyType */
     uint32_t listIdx;
 } UCurrencyContext;
 
 /*
@@ skipping 831 matching lines @@
 
 U_CAPI UEnumeration *U_EXPORT2 ucurr_getKeywordValuesForLocale(const char *key, const char *locale, UBool commonlyUsed, UErrorCode* status) {
     // Resolve region
     char prefRegion[ULOC_FULLNAME_CAPACITY] = "";
     int32_t prefRegionLength = 0;
     prefRegionLength = uloc_getCountry(locale, prefRegion, sizeof(prefRegion), status);
     if (prefRegionLength == 0) {
         char loc[ULOC_FULLNAME_CAPACITY] = "";
         uloc_addLikelySubtags(locale, loc, sizeof(loc), status);
         
-        prefRegionLength = uloc_getCountry(loc, prefRegion, sizeof(prefRegion), status);
+        /*prefRegionLength = */ uloc_getCountry(loc, prefRegion, sizeof(prefRegion), status);
     }
     
     // Read value from supplementalData
     UList *values = ulist_createEmptyList(status);
     UList *otherValues = ulist_createEmptyList(status);
     UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration));
     if (U_FAILURE(*status) || en == NULL) {
         if (en == NULL) {
             *status = U_MEMORY_ALLOCATION_ERROR;
         } else {
@@ skipping 143 matching lines @@
                 code = tmpCode;
             }
         }
         ures_close(bundle);
     }
     return code;
 }
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 //eof