icuSources/i18n/digitaffixesandpadding.cpp

   1 /*
   2  * Copyright (C) 2015, International Business Machines
   3  * Corporation and others.  All Rights Reserved.
   4  *
   5  * file name: digitaffixesandpadding.cpp
   6  */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include "unicode/plurrule.h"
  13 #include "charstr.h"
  14 #include "digitaffix.h"
  15 #include "digitaffixesandpadding.h"
  16 #include "digitlst.h"
  17 #include "uassert.h"
  18 #include "valueformatter.h"
  19 #include "visibledigits.h"
  20
  21 U_NAMESPACE_BEGIN
  22
  23 UBool
  24 DigitAffixesAndPadding::needsPluralRules() const {
  25     return (
  26             fPositivePrefix.hasMultipleVariants() ||
  27             fPositiveSuffix.hasMultipleVariants() ||
  28             fNegativePrefix.hasMultipleVariants() ||
  29             fNegativeSuffix.hasMultipleVariants());
  30 }
  31
  32 UnicodeString &
  33 DigitAffixesAndPadding::formatInt32(
  34         int32_t value,
  35         const ValueFormatter &formatter,
  36         FieldPositionHandler &handler,
  37         const PluralRules *optPluralRules,
  38         UnicodeString &appendTo,
  39         UErrorCode &status) const {
  40     if (U_FAILURE(status)) {
  41         return appendTo;
  42     }
  43     if (optPluralRules != NULL || fWidth > 0 || !formatter.isFastFormattable(value)) {
  44         VisibleDigitsWithExponent digits;
  45         formatter.toVisibleDigitsWithExponent(
  46                 (int64_t) value, digits, status);
  47         return format(
  48                 digits,
  49                 formatter,
  50                 handler,
  51                 optPluralRules,
  52                 appendTo,
  53                 status);
  54     }
  55     UBool bPositive = value >= 0;
  56     const DigitAffix *prefix = bPositive ? &fPositivePrefix.getOtherVariant() : &fNegativePrefix.getOtherVariant();
  57     const DigitAffix *suffix = bPositive ? &fPositiveSuffix.getOtherVariant() : &fNegativeSuffix.getOtherVariant();
  58     if (value < 0) {
  59         value = -value;
  60     }
  61     prefix->format(handler, appendTo);
  62     formatter.formatInt32(value, handler, appendTo);
  63     return suffix->format(handler, appendTo);
  64 }
  65
  66 static UnicodeString &
  67 formatAffix(
  68         const DigitAffix *affix,
  69         FieldPositionHandler &handler,
  70         UnicodeString &appendTo) {
  71     if (affix) {
  72         affix->format(handler, appendTo);
  73     }
  74     return appendTo;
  75 }
  76
  77 static int32_t
  78 countAffixChar32(const DigitAffix *affix) {
  79     if (affix) {
  80         return affix->countChar32();
  81     }
  82     return 0;
  83 }
  84
  85 UnicodeString &
  86 DigitAffixesAndPadding::format(
  87         const VisibleDigitsWithExponent &digits,
  88         const ValueFormatter &formatter,
  89         FieldPositionHandler &handler,
  90         const PluralRules *optPluralRules,
  91         UnicodeString &appendTo,
  92         UErrorCode &status) const {
  93     if (U_FAILURE(status)) {
  94         return appendTo;
  95     }
  96     const DigitAffix *prefix = NULL;
  97     const DigitAffix *suffix = NULL;
  98     if (!digits.isNaN()) {
  99         UBool bPositive = !digits.isNegative();
 100         const PluralAffix *pluralPrefix = bPositive ? &fPositivePrefix : &fNegativePrefix;
 101         const PluralAffix *pluralSuffix = bPositive ? &fPositiveSuffix : &fNegativeSuffix;
 102         if (optPluralRules == NULL || digits.isInfinite()) {
 103             prefix = &pluralPrefix->getOtherVariant();
 104             suffix = &pluralSuffix->getOtherVariant();
 105         } else {
 106             UnicodeString count(optPluralRules->select(digits));
 107             prefix = &pluralPrefix->getByCategory(count);
 108             suffix = &pluralSuffix->getByCategory(count);
 109         }
 110     }
 111     if (fWidth <= 0) {
 112         formatAffix(prefix, handler, appendTo);
 113         formatter.format(digits, handler, appendTo);
 114         return formatAffix(suffix, handler, appendTo);
 115     }
 116     int32_t codePointCount = countAffixChar32(prefix) + formatter.countChar32(digits) + countAffixChar32(suffix);
 117     int32_t paddingCount = fWidth - codePointCount;
 118     switch (fPadPosition) {
 119     case kPadBeforePrefix:
 120         appendPadding(paddingCount, appendTo);
 121         formatAffix(prefix, handler, appendTo);
 122         formatter.format(digits, handler, appendTo);
 123         return formatAffix(suffix, handler, appendTo);
 124     case kPadAfterPrefix:
 125         formatAffix(prefix, handler, appendTo);
 126         appendPadding(paddingCount, appendTo);
 127         formatter.format(digits, handler, appendTo);
 128         return formatAffix(suffix, handler, appendTo);
 129     case kPadBeforeSuffix:
 130         formatAffix(prefix, handler, appendTo);
 131         formatter.format(digits, handler, appendTo);
 132         appendPadding(paddingCount, appendTo);
 133         return formatAffix(suffix, handler, appendTo);
 134     case kPadAfterSuffix:
 135         formatAffix(prefix, handler, appendTo);
 136         formatter.format(digits, handler, appendTo);
 137         formatAffix(suffix, handler, appendTo);
 138         return appendPadding(paddingCount, appendTo);
 139     default:
 140         U_ASSERT(FALSE);
 141         return appendTo;
 142     }
 143 }
 144
 145 UnicodeString &
 146 DigitAffixesAndPadding::format(
 147         DigitList &value,
 148         const ValueFormatter &formatter,
 149         FieldPositionHandler &handler,
 150         const PluralRules *optPluralRules,
 151         UnicodeString &appendTo,
 152         UErrorCode &status) const {
 153     VisibleDigitsWithExponent digits;
 154     formatter.toVisibleDigitsWithExponent(
 155             value, digits, status);
 156     if (U_FAILURE(status)) {
 157         return appendTo;
 158     }
 159     return format(
 160             digits, formatter, handler, optPluralRules, appendTo, status);
 161 }
 162
 163 UnicodeString &
 164 DigitAffixesAndPadding::appendPadding(int32_t paddingCount, UnicodeString &appendTo) const {
 165     for (int32_t i = 0; i < paddingCount; ++i) {
 166         appendTo.append(fPadChar);
 167     }
 168     return appendTo;
 169 }
 170
 171
 172 U_NAMESPACE_END
 173 #endif /* #if !UCONFIG_NO_FORMATTING */