Home | History | Annotate | Download | only in i18n 
      1 /*
      2  * Copyright (C) 2015, International Business Machines
      3  * Corporation and others.  All Rights Reserved.
      4  *
      5  * file name: digitformatter.cpp
      6  */
      7 
      8 #include "unicode/utypes.h"
      9 
     10 #if !UCONFIG_NO_FORMATTING
     11 
     12 #include "unicode/dcfmtsym.h"
     13 #include "unicode/unum.h"
     14 
     15 #include "digitformatter.h"
     16 #include "digitgrouping.h"
     17 #include "digitinterval.h"
     18 #include "digitlst.h"
     19 #include "fphdlimp.h"
     20 #include "smallintformatter.h"
     21 #include "unistrappender.h"
     22 #include "visibledigits.h"
     23 
     24 U_NAMESPACE_BEGIN
     25 
     26 DigitFormatter::DigitFormatter()
     27         : fGroupingSeparator(",", -1, US_INV), fDecimal(".", -1, US_INV),
     28           fNegativeSign("-", -1, US_INV), fPositiveSign("+", -1, US_INV),
     29           fIsStandardDigits(TRUE), fExponent("E", -1, US_INV) {
     30     for (int32_t i = 0; i < 10; ++i) {
     31         fLocalizedDigits[i] = (UChar32) (0x30 + i);
     32     }
     33     fInfinity.setTo(UnicodeString("Inf", -1, US_INV), UNUM_INTEGER_FIELD);
     34     fNan.setTo(UnicodeString("Nan", -1, US_INV), UNUM_INTEGER_FIELD);
     35 }
     36 
     37 DigitFormatter::DigitFormatter(const DecimalFormatSymbols &symbols) {
     38     setDecimalFormatSymbols(symbols);
     39 }
     40 
     41 void
     42 DigitFormatter::setOtherDecimalFormatSymbols(
     43         const DecimalFormatSymbols &symbols) {
     44     fLocalizedDigits[0] = symbols.getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0);
     45     fLocalizedDigits[1] = symbols.getConstSymbol(DecimalFormatSymbols::kOneDigitSymbol).char32At(0);
     46     fLocalizedDigits[2] = symbols.getConstSymbol(DecimalFormatSymbols::kTwoDigitSymbol).char32At(0);
     47     fLocalizedDigits[3] = symbols.getConstSymbol(DecimalFormatSymbols::kThreeDigitSymbol).char32At(0);
     48     fLocalizedDigits[4] = symbols.getConstSymbol(DecimalFormatSymbols::kFourDigitSymbol).char32At(0);
     49     fLocalizedDigits[5] = symbols.getConstSymbol(DecimalFormatSymbols::kFiveDigitSymbol).char32At(0);
     50     fLocalizedDigits[6] = symbols.getConstSymbol(DecimalFormatSymbols::kSixDigitSymbol).char32At(0);
     51     fLocalizedDigits[7] = symbols.getConstSymbol(DecimalFormatSymbols::kSevenDigitSymbol).char32At(0);
     52     fLocalizedDigits[8] = symbols.getConstSymbol(DecimalFormatSymbols::kEightDigitSymbol).char32At(0);
     53     fLocalizedDigits[9] = symbols.getConstSymbol(DecimalFormatSymbols::kNineDigitSymbol).char32At(0);
     54     fIsStandardDigits = isStandardDigits();
     55     fNegativeSign = symbols.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
     56     fPositiveSign = symbols.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
     57     fInfinity.setTo(symbols.getConstSymbol(DecimalFormatSymbols::kInfinitySymbol), UNUM_INTEGER_FIELD);
     58     fNan.setTo(symbols.getConstSymbol(DecimalFormatSymbols::kNaNSymbol), UNUM_INTEGER_FIELD);
     59     fExponent = symbols.getConstSymbol(DecimalFormatSymbols::kExponentialSymbol);
     60 }
     61 
     62 void
     63 DigitFormatter::setDecimalFormatSymbolsForMonetary(
     64         const DecimalFormatSymbols &symbols) {
     65     setOtherDecimalFormatSymbols(symbols);
     66     fGroupingSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol);
     67     fDecimal = symbols.getConstSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol);
     68 }
     69 
     70 void
     71 DigitFormatter::setDecimalFormatSymbols(
     72         const DecimalFormatSymbols &symbols) {
     73     setOtherDecimalFormatSymbols(symbols);
     74     fGroupingSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
     75     fDecimal = symbols.getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
     76 }
     77 
     78 static void appendField(
     79         int32_t fieldId,
     80         const UnicodeString &value,
     81         FieldPositionHandler &handler,
     82         UnicodeString &appendTo) {
     83     int32_t currentLength = appendTo.length();
     84     appendTo.append(value);
     85     handler.addAttribute(
     86             fieldId,
     87             currentLength,
     88             appendTo.length());
     89 }
     90 
     91 int32_t DigitFormatter::countChar32(
     92         const DigitGrouping &grouping,
     93         const DigitInterval &interval,
     94         const DigitFormatterOptions &options) const {
     95     int32_t result = interval.length();
     96 
     97     // We always emit '0' in lieu of no digits.
     98     if (result == 0) {
     99         result = 1;
    100     }
    101     if (options.fAlwaysShowDecimal || interval.getLeastSignificantInclusive() < 0) {
    102         result += fDecimal.countChar32();
    103     }
    104     result += grouping.getSeparatorCount(interval.getIntDigitCount()) * fGroupingSeparator.countChar32();
    105     return result;
    106 }
    107 
    108 int32_t
    109 DigitFormatter::countChar32(
    110         const VisibleDigits &digits,
    111         const DigitGrouping &grouping,
    112         const DigitFormatterOptions &options) const {
    113     if (digits.isNaN()) {
    114         return countChar32ForNaN();
    115     }
    116     if (digits.isInfinite()) {
    117         return countChar32ForInfinity();
    118     }
    119     return countChar32(
    120             grouping,
    121             digits.getInterval(),
    122             options);
    123 }
    124 
    125 int32_t
    126 DigitFormatter::countChar32(
    127         const VisibleDigitsWithExponent &digits,
    128         const SciFormatterOptions &options) const {
    129     if (digits.isNaN()) {
    130         return countChar32ForNaN();
    131     }
    132     if (digits.isInfinite()) {
    133         return countChar32ForInfinity();
    134     }
    135     const VisibleDigits *exponent = digits.getExponent();
    136     if (exponent == NULL) {
    137         DigitGrouping grouping;
    138         return countChar32(
    139                 grouping,
    140                 digits.getMantissa().getInterval(),
    141                 options.fMantissa);
    142     }
    143     return countChar32(
    144             *exponent, digits.getMantissa().getInterval(), options);
    145 }
    146 
    147 int32_t
    148 DigitFormatter::countChar32(
    149         const VisibleDigits &exponent,
    150         const DigitInterval &mantissaInterval,
    151         const SciFormatterOptions &options) const {
    152     DigitGrouping grouping;
    153     int32_t count = countChar32(
    154             grouping, mantissaInterval, options.fMantissa);
    155     count += fExponent.countChar32();
    156     count += countChar32ForExponent(
    157             exponent, options.fExponent);
    158     return count;
    159 }
    160 
    161 UnicodeString &DigitFormatter::format(
    162         const VisibleDigits &digits,
    163         const DigitGrouping &grouping,
    164         const DigitFormatterOptions &options,
    165         FieldPositionHandler &handler,
    166         UnicodeString &appendTo) const {
    167     if (digits.isNaN()) {
    168         return formatNaN(handler, appendTo);
    169     }
    170     if (digits.isInfinite()) {
    171         return formatInfinity(handler, appendTo);
    172     }
    173 
    174     const DigitInterval &interval = digits.getInterval();
    175     int32_t digitsLeftOfDecimal = interval.getMostSignificantExclusive();
    176     int32_t lastDigitPos = interval.getLeastSignificantInclusive();
    177     int32_t intBegin = appendTo.length();
    178     int32_t fracBegin;
    179 
    180     // Emit "0" instead of empty string.
    181     if (digitsLeftOfDecimal == 0 && lastDigitPos == 0) {
    182         appendTo.append(fLocalizedDigits[0]);
    183         handler.addAttribute(UNUM_INTEGER_FIELD, intBegin, appendTo.length());
    184         if (options.fAlwaysShowDecimal) {
    185             appendField(
    186                     UNUM_DECIMAL_SEPARATOR_FIELD,
    187                     fDecimal,
    188                     handler,
    189                     appendTo);
    190         }
    191         return appendTo;
    192     }
    193     {
    194         UnicodeStringAppender appender(appendTo);
    195         for (int32_t i = interval.getMostSignificantExclusive() - 1;
    196                 i >= interval.getLeastSignificantInclusive(); --i) {
    197             if (i == -1) {
    198                 appender.flush();
    199                 appendField(
    200                         UNUM_DECIMAL_SEPARATOR_FIELD,
    201                         fDecimal,
    202                         handler,
    203                         appendTo);
    204                 fracBegin = appendTo.length();
    205             }
    206             appender.append(fLocalizedDigits[digits.getDigitByExponent(i)]);
    207             if (grouping.isSeparatorAt(digitsLeftOfDecimal, i)) {
    208                 appender.flush();
    209                 appendField(
    210                         UNUM_GROUPING_SEPARATOR_FIELD,
    211                         fGroupingSeparator,
    212                         handler,
    213                         appendTo);
    214             }
    215             if (i == 0) {
    216                 appender.flush();
    217                 if (digitsLeftOfDecimal > 0) {
    218                     handler.addAttribute(UNUM_INTEGER_FIELD, intBegin, appendTo.length());
    219                 }
    220             }
    221         }
    222         if (options.fAlwaysShowDecimal && lastDigitPos == 0) {
    223             appender.flush();
    224             appendField(
    225                     UNUM_DECIMAL_SEPARATOR_FIELD,
    226                     fDecimal,
    227                     handler,
    228                     appendTo);
    229         }
    230     }
    231     // lastDigitPos is never > 0 so we are guaranteed that kIntegerField
    232     // is already added.
    233     if (lastDigitPos < 0) {
    234         handler.addAttribute(UNUM_FRACTION_FIELD, fracBegin, appendTo.length());
    235     }
    236     return appendTo;
    237 }
    238 
    239 UnicodeString &
    240 DigitFormatter::format(
    241         const VisibleDigitsWithExponent &digits,
    242         const SciFormatterOptions &options,
    243         FieldPositionHandler &handler,
    244         UnicodeString &appendTo) const {
    245     DigitGrouping grouping;
    246     format(
    247             digits.getMantissa(),
    248             grouping,
    249             options.fMantissa,
    250             handler,
    251             appendTo);
    252     const VisibleDigits *exponent = digits.getExponent();
    253     if (exponent == NULL) {
    254         return appendTo;
    255     }
    256     int32_t expBegin = appendTo.length();
    257     appendTo.append(fExponent);
    258     handler.addAttribute(
    259             UNUM_EXPONENT_SYMBOL_FIELD, expBegin, appendTo.length());
    260     return formatExponent(
    261             *exponent,
    262             options.fExponent,
    263             UNUM_EXPONENT_SIGN_FIELD,
    264             UNUM_EXPONENT_FIELD,
    265             handler,
    266             appendTo);
    267 }
    268 
    269 static int32_t formatInt(
    270         int32_t value, uint8_t *digits) {
    271     int32_t idx = 0;
    272     while (value > 0) {
    273         digits[idx++] = (uint8_t) (value % 10);
    274         value /= 10;
    275     }
    276     return idx;
    277 }
    278 
    279 UnicodeString &
    280 DigitFormatter::formatDigits(
    281         const uint8_t *digits,
    282         int32_t count,
    283         const IntDigitCountRange &range,
    284         int32_t intField,
    285         FieldPositionHandler &handler,
    286         UnicodeString &appendTo) const {
    287     int32_t i = range.pin(count) - 1;
    288     int32_t begin = appendTo.length();
    289 
    290     // Always emit '0' as placeholder for empty string.
    291     if (i == -1) {
    292         appendTo.append(fLocalizedDigits[0]);
    293         handler.addAttribute(intField, begin, appendTo.length());
    294         return appendTo;
    295     }
    296     {
    297         UnicodeStringAppender appender(appendTo);
    298         for (; i >= count; --i) {
    299             appender.append(fLocalizedDigits[0]);
    300         }
    301         for (; i >= 0; --i) {
    302             appender.append(fLocalizedDigits[digits[i]]);
    303         }
    304     }
    305     handler.addAttribute(intField, begin, appendTo.length());
    306     return appendTo;
    307 }
    308 
    309 UnicodeString &
    310 DigitFormatter::formatExponent(
    311         const VisibleDigits &digits,
    312         const DigitFormatterIntOptions &options,
    313         int32_t signField,
    314         int32_t intField,
    315         FieldPositionHandler &handler,
    316         UnicodeString &appendTo) const {
    317     UBool neg = digits.isNegative();
    318     if (neg || options.fAlwaysShowSign) {
    319         appendField(
    320                 signField,
    321                 neg ? fNegativeSign : fPositiveSign,
    322                 handler,
    323                 appendTo);
    324     }
    325     int32_t begin = appendTo.length();
    326     DigitGrouping grouping;
    327     DigitFormatterOptions expOptions;
    328     FieldPosition fpos(FieldPosition::DONT_CARE);
    329     FieldPositionOnlyHandler noHandler(fpos);
    330     format(
    331             digits,
    332             grouping,
    333             expOptions,
    334             noHandler,
    335             appendTo);
    336     handler.addAttribute(intField, begin, appendTo.length());
    337     return appendTo;
    338 }
    339 
    340 int32_t
    341 DigitFormatter::countChar32ForExponent(
    342         const VisibleDigits &exponent,
    343         const DigitFormatterIntOptions &options) const {
    344     int32_t result = 0;
    345     UBool neg = exponent.isNegative();
    346     if (neg || options.fAlwaysShowSign) {
    347         result += neg ? fNegativeSign.countChar32() : fPositiveSign.countChar32();
    348     }
    349     DigitGrouping grouping;
    350     DigitFormatterOptions expOptions;
    351     result += countChar32(grouping, exponent.getInterval(), expOptions);
    352     return result;
    353 }
    354 
    355 UnicodeString &
    356 DigitFormatter::formatPositiveInt32(
    357         int32_t positiveValue,
    358         const IntDigitCountRange &range,
    359         FieldPositionHandler &handler,
    360         UnicodeString &appendTo) const {
    361     // super fast path
    362     if (fIsStandardDigits && SmallIntFormatter::canFormat(positiveValue, range)) {
    363         int32_t begin = appendTo.length();
    364         SmallIntFormatter::format(positiveValue, range, appendTo);
    365         handler.addAttribute(UNUM_INTEGER_FIELD, begin, appendTo.length());
    366         return appendTo;
    367     }
    368     uint8_t digits[10];
    369     int32_t count = formatInt(positiveValue, digits);
    370     return formatDigits(
    371             digits,
    372             count,
    373             range,
    374             UNUM_INTEGER_FIELD,
    375             handler,
    376             appendTo);
    377 }
    378 
    379 UBool DigitFormatter::isStandardDigits() const {
    380     UChar32 cdigit = 0x30;
    381     for (int32_t i = 0; i < UPRV_LENGTHOF(fLocalizedDigits); ++i) {
    382         if (fLocalizedDigits[i] != cdigit) {
    383             return FALSE;
    384         }
    385         ++cdigit;
    386     }
    387     return TRUE;
    388 }
    389 
    390 UBool
    391 DigitFormatter::equals(const DigitFormatter &rhs) const {
    392     UBool result = (fGroupingSeparator == rhs.fGroupingSeparator) &&
    393                    (fDecimal == rhs.fDecimal) &&
    394                    (fNegativeSign == rhs.fNegativeSign) &&
    395                    (fPositiveSign == rhs.fPositiveSign) &&
    396                    (fInfinity.equals(rhs.fInfinity)) &&
    397                    (fNan.equals(rhs.fNan)) &&
    398                    (fIsStandardDigits == rhs.fIsStandardDigits) &&
    399                    (fExponent == rhs.fExponent);
    400 
    401     if (!result) {
    402         return FALSE;
    403     }
    404     for (int32_t i = 0; i < UPRV_LENGTHOF(fLocalizedDigits); ++i) {
    405         if (fLocalizedDigits[i] != rhs.fLocalizedDigits[i]) {
    406             return FALSE;
    407         }
    408     }
    409     return TRUE;
    410 }
    411 
    412 
    413 U_NAMESPACE_END
    414 
    415 #endif /* #if !UCONFIG_NO_FORMATTING */
    416