icuSources/i18n/number_compact.cpp

   1 // © 2017 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3
   4 #include "unicode/utypes.h"
   5
   6 #if !UCONFIG_NO_FORMATTING
   7
   8 #include "unicode/ustring.h"
   9 #include "unicode/ures.h"
  10 #include "cstring.h"
  11 #include "charstr.h"
  12 #include "resource.h"
  13 #include "number_compact.h"
  14 #include "number_microprops.h"
  15 #include "uresimp.h"
  16
  17 using namespace icu;
  18 using namespace icu::number;
  19 using namespace icu::number::impl;
  20
  21 namespace {
  22
  23 // A dummy object used when a "0" compact decimal entry is encountered. This is necessary
  24 // in order to prevent falling back to root. Object equality ("==") is intended.
  25 const UChar *USE_FALLBACK = u"<USE FALLBACK>";
  26
  27 /** Produces a string like "NumberElements/latn/patternsShort/decimalFormat". */
  28 void getResourceBundleKey(const char *nsName, CompactStyle compactStyle, CompactType compactType,
  29                                  CharString &sb, UErrorCode &status) {
  30     sb.clear();
  31     sb.append("NumberElements/", status);
  32     sb.append(nsName, status);
  33     sb.append(compactStyle == CompactStyle::UNUM_SHORT ? "/patternsShort" : "/patternsLong", status);
  34     sb.append(compactType == CompactType::TYPE_DECIMAL ? "/decimalFormat" : "/currencyFormat", status);
  35 }
  36
  37 int32_t getIndex(int32_t magnitude, StandardPlural::Form plural) {
  38     return magnitude * StandardPlural::COUNT + plural;
  39 }
  40
  41 int32_t countZeros(const UChar *patternString, int32_t patternLength) {
  42     // NOTE: This strategy for computing the number of zeros is a hack for efficiency.
  43     // It could break if there are any 0s that aren't part of the main pattern.
  44     int32_t numZeros = 0;
  45     for (int32_t i = 0; i < patternLength; i++) {
  46         if (patternString[i] == u'0') {
  47             numZeros++;
  48         } else if (numZeros > 0) {
  49             break; // zeros should always be contiguous
  50         }
  51     }
  52     return numZeros;
  53 }
  54
  55 } // namespace
  56
  57 // NOTE: patterns and multipliers both get zero-initialized.
  58 CompactData::CompactData() : patterns(), multipliers(), largestMagnitude(0), isEmpty(TRUE) {
  59 }
  60
  61 void CompactData::populate(const Locale &locale, const char *nsName, CompactStyle compactStyle,
  62                            CompactType compactType, UErrorCode &status) {
  63     CompactDataSink sink(*this);
  64     LocalUResourceBundlePointer rb(ures_open(nullptr, locale.getName(), &status));
  65     if (U_FAILURE(status)) { return; }
  66
  67     bool nsIsLatn = strcmp(nsName, "latn") == 0;
  68     bool compactIsShort = compactStyle == CompactStyle::UNUM_SHORT;
  69
  70     // Fall back to latn numbering system and/or short compact style.
  71     CharString resourceKey;
  72     getResourceBundleKey(nsName, compactStyle, compactType, resourceKey, status);
  73     UErrorCode localStatus = U_ZERO_ERROR;
  74     ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
  75     if (isEmpty && !nsIsLatn) {
  76         getResourceBundleKey("latn", compactStyle, compactType, resourceKey, status);
  77         localStatus = U_ZERO_ERROR;
  78         ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
  79     }
  80     if (isEmpty && !compactIsShort) {
  81         getResourceBundleKey(nsName, CompactStyle::UNUM_SHORT, compactType, resourceKey, status);
  82         localStatus = U_ZERO_ERROR;
  83         ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
  84     }
  85     if (isEmpty && !nsIsLatn && !compactIsShort) {
  86         getResourceBundleKey("latn", CompactStyle::UNUM_SHORT, compactType, resourceKey, status);
  87         localStatus = U_ZERO_ERROR;
  88         ures_getAllItemsWithFallback(rb.getAlias(), resourceKey.data(), sink, localStatus);
  89     }
  90
  91     // The last fallback should be guaranteed to return data.
  92     if (isEmpty) {
  93         status = U_INTERNAL_PROGRAM_ERROR;
  94     }
  95 }
  96
  97 int32_t CompactData::getMultiplier(int32_t magnitude) const {
  98     if (magnitude < 0) {
  99         return 0;
 100     }
 101     if (magnitude > largestMagnitude) {
 102         magnitude = largestMagnitude;
 103     }
 104     return multipliers[magnitude];
 105 }
 106
 107 const UChar *CompactData::getPattern(int32_t magnitude, StandardPlural::Form plural) const {
 108     if (magnitude < 0) {
 109         return nullptr;
 110     }
 111     if (magnitude > largestMagnitude) {
 112         magnitude = largestMagnitude;
 113     }
 114     const UChar *patternString = patterns[getIndex(magnitude, plural)];
 115     if (patternString == nullptr && plural != StandardPlural::OTHER) {
 116         // Fall back to "other" plural variant
 117         patternString = patterns[getIndex(magnitude, StandardPlural::OTHER)];
 118     }
 119     if (patternString == USE_FALLBACK) { // == is intended
 120         // Return null if USE_FALLBACK is present
 121         patternString = nullptr;
 122     }
 123     return patternString;
 124 }
 125
 126 void CompactData::getUniquePatterns(UVector &output, UErrorCode &status) const {
 127     U_ASSERT(output.isEmpty());
 128     // NOTE: In C++, this is done more manually with a UVector.
 129     // In Java, we can take advantage of JDK HashSet.
 130     for (auto pattern : patterns) {
 131         if (pattern == nullptr || pattern == USE_FALLBACK) {
 132             continue;
 133         }
 134
 135         // Insert pattern into the UVector if the UVector does not already contain the pattern.
 136         // Search the UVector from the end since identical patterns are likely to be adjacent.
 137         for (int32_t i = output.size() - 1; i >= 0; i--) {
 138             if (u_strcmp(pattern, static_cast<const UChar *>(output[i])) == 0) {
 139                 goto continue_outer;
 140             }
 141         }
 142
 143         // The string was not found; add it to the UVector.
 144         // ANDY: This requires a const_cast.  Why?
 145         output.addElement(const_cast<UChar *>(pattern), status);
 146
 147         continue_outer:
 148         continue;
 149     }
 150 }
 151
 152 void CompactData::CompactDataSink::put(const char *key, ResourceValue &value, UBool /*noFallback*/,
 153                                        UErrorCode &status) {
 154     // traverse into the table of powers of ten
 155     ResourceTable powersOfTenTable = value.getTable(status);
 156     if (U_FAILURE(status)) { return; }
 157     for (int i3 = 0; powersOfTenTable.getKeyAndValue(i3, key, value); ++i3) {
 158
 159         // Assumes that the keys are always of the form "10000" where the magnitude is the
 160         // length of the key minus one.  We expect magnitudes to be less than MAX_DIGITS.
 161         auto magnitude = static_cast<int8_t> (strlen(key) - 1);
 162         int8_t multiplier = data.multipliers[magnitude];
 163         U_ASSERT(magnitude < COMPACT_MAX_DIGITS);
 164
 165         // Iterate over the plural variants ("one", "other", etc)
 166         ResourceTable pluralVariantsTable = value.getTable(status);
 167         if (U_FAILURE(status)) { return; }
 168         for (int i4 = 0; pluralVariantsTable.getKeyAndValue(i4, key, value); ++i4) {
 169
 170             // Skip this magnitude/plural if we already have it from a child locale.
 171             // Note: This also skips USE_FALLBACK entries.
 172             StandardPlural::Form plural = StandardPlural::fromString(key, status);
 173             if (U_FAILURE(status)) { return; }
 174             if (data.patterns[getIndex(magnitude, plural)] != nullptr) {
 175                 continue;
 176             }
 177
 178             // The value "0" means that we need to use the default pattern and not fall back
 179             // to parent locales. Example locale where this is relevant: 'it'.
 180             int32_t patternLength;
 181             const UChar *patternString = value.getString(patternLength, status);
 182             if (U_FAILURE(status)) { return; }
 183             if (u_strcmp(patternString, u"0") == 0) {
 184                 patternString = USE_FALLBACK;
 185                 patternLength = 0;
 186             }
 187
 188             // Save the pattern string. We will parse it lazily.
 189             data.patterns[getIndex(magnitude, plural)] = patternString;
 190
 191             // If necessary, compute the multiplier: the difference between the magnitude
 192             // and the number of zeros in the pattern.
 193             if (multiplier == 0) {
 194                 int32_t numZeros = countZeros(patternString, patternLength);
 195                 if (numZeros > 0) { // numZeros==0 in certain cases, like Somali "Kun"
 196                     multiplier = static_cast<int8_t> (numZeros - magnitude - 1);
 197                 }
 198             }
 199         }
 200
 201         // Save the multiplier.
 202         if (data.multipliers[magnitude] == 0) {
 203             data.multipliers[magnitude] = multiplier;
 204             if (magnitude > data.largestMagnitude) {
 205                 data.largestMagnitude = magnitude;
 206             }
 207             data.isEmpty = false;
 208         } else {
 209             U_ASSERT(data.multipliers[magnitude] == multiplier);
 210         }
 211     }
 212 }
 213
 214 ///////////////////////////////////////////////////////////
 215 /// END OF CompactData.java; BEGIN CompactNotation.java ///
 216 ///////////////////////////////////////////////////////////
 217
 218 CompactHandler::CompactHandler(CompactStyle compactStyle, const Locale &locale, const char *nsName,
 219                                CompactType compactType, const PluralRules *rules,
 220                                MutablePatternModifier *buildReference, const MicroPropsGenerator *parent,
 221                                UErrorCode &status)
 222         : rules(rules), parent(parent) {
 223     data.populate(locale, nsName, compactStyle, compactType, status);
 224     if (buildReference != nullptr) {
 225         // Safe code path
 226         precomputeAllModifiers(*buildReference, status);
 227         safe = TRUE;
 228     } else {
 229         // Unsafe code path
 230         safe = FALSE;
 231     }
 232 }
 233
 234 CompactHandler::~CompactHandler() {
 235     for (int32_t i = 0; i < precomputedModsLength; i++) {
 236         delete precomputedMods[i].mod;
 237     }
 238 }
 239
 240 void CompactHandler::precomputeAllModifiers(MutablePatternModifier &buildReference, UErrorCode &status) {
 241     if (U_FAILURE(status)) { return; }
 242
 243     // Initial capacity of 12 for 0K, 00K, 000K, ...M, ...B, and ...T
 244     UVector allPatterns(12, status);
 245     if (U_FAILURE(status)) { return; }
 246     data.getUniquePatterns(allPatterns, status);
 247     if (U_FAILURE(status)) { return; }
 248
 249     // C++ only: ensure that precomputedMods has room.
 250     precomputedModsLength = allPatterns.size();
 251     if (precomputedMods.getCapacity() < precomputedModsLength) {
 252         precomputedMods.resize(allPatterns.size(), status);
 253         if (U_FAILURE(status)) { return; }
 254     }
 255
 256     for (int32_t i = 0; i < precomputedModsLength; i++) {
 257         auto patternString = static_cast<const UChar *>(allPatterns[i]);
 258         UnicodeString hello(patternString);
 259         CompactModInfo &info = precomputedMods[i];
 260         ParsedPatternInfo patternInfo;
 261         PatternParser::parseToPatternInfo(UnicodeString(patternString), patternInfo, status);
 262         if (U_FAILURE(status)) { return; }
 263         buildReference.setPatternInfo(&patternInfo);
 264         info.mod = buildReference.createImmutable(status);
 265         if (U_FAILURE(status)) { return; }
 266         info.patternString = patternString;
 267     }
 268 }
 269
 270 void CompactHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
 271                                      UErrorCode &status) const {
 272     parent->processQuantity(quantity, micros, status);
 273     if (U_FAILURE(status)) { return; }
 274
 275     // Treat zero as if it had magnitude 0
 276     int magnitude;
 277     if (quantity.isZero()) {
 278         magnitude = 0;
 279         micros.rounder.apply(quantity, status);
 280     } else {
 281         // TODO: Revisit chooseMultiplierAndApply
 282         int multiplier = micros.rounder.chooseMultiplierAndApply(quantity, data, status);
 283         magnitude = quantity.isZero() ? 0 : quantity.getMagnitude();
 284         magnitude -= multiplier;
 285     }
 286
 287     StandardPlural::Form plural = utils::getStandardPlural(rules, quantity);
 288     const UChar *patternString = data.getPattern(magnitude, plural);
 289     if (patternString == nullptr) {
 290         // Use the default (non-compact) modifier.
 291         // No need to take any action.
 292     } else if (safe) {
 293         // Safe code path.
 294         // Java uses a hash set here for O(1) lookup.  C++ uses a linear search.
 295         // TODO: Benchmark this and maybe change to a binary search or hash table.
 296         int32_t i = 0;
 297         for (; i < precomputedModsLength; i++) {
 298             const CompactModInfo &info = precomputedMods[i];
 299             if (u_strcmp(patternString, info.patternString) == 0) {
 300                 info.mod->applyToMicros(micros, quantity);
 301                 break;
 302             }
 303         }
 304         // It should be guaranteed that we found the entry.
 305         U_ASSERT(i < precomputedModsLength);
 306     } else {
 307         // Unsafe code path.
 308         // Overwrite the PatternInfo in the existing modMiddle.
 309         // C++ Note: Use unsafePatternInfo for proper lifecycle.
 310         ParsedPatternInfo &patternInfo = const_cast<CompactHandler *>(this)->unsafePatternInfo;
 311         PatternParser::parseToPatternInfo(UnicodeString(patternString), patternInfo, status);
 312         static_cast<MutablePatternModifier*>(const_cast<Modifier*>(micros.modMiddle))
 313             ->setPatternInfo(&patternInfo);
 314     }
 315
 316     // We already performed rounding. Do not perform it again.
 317     micros.rounder = RoundingImpl::passThrough();
 318 }
 319
 320 #endif /* #if !UCONFIG_NO_FORMATTING */