icuSources/i18n/scientificnumberformatter.cpp

   1 /*
   2 **********************************************************************
   3 * Copyright (c) 2014, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 */
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_FORMATTING
  10
  11 #include "unicode/scientificnumberformatter.h"
  12 #include "unicode/dcfmtsym.h"
  13 #include "unicode/fpositer.h"
  14 #include "unicode/utf16.h"
  15 #include "unicode/uniset.h"
  16 #include "decfmtst.h"
  17 #include "unicode/decimfmt.h"
  18
  19 U_NAMESPACE_BEGIN
  20
  21 static const UChar kSuperscriptDigits[] = {
  22         0x2070,
  23         0xB9,
  24         0xB2,
  25         0xB3,
  26         0x2074,
  27         0x2075,
  28         0x2076,
  29         0x2077,
  30         0x2078,
  31         0x2079};
  32
  33 static const UChar kSuperscriptPlusSign = 0x207A;
  34 static const UChar kSuperscriptMinusSign = 0x207B;
  35
  36 static UBool copyAsSuperscript(
  37         const UnicodeString &s,
  38         int32_t beginIndex,
  39         int32_t endIndex,
  40         UnicodeString &result,
  41         UErrorCode &status) {
  42     if (U_FAILURE(status)) {
  43         return FALSE;
  44     }
  45     for (int32_t i = beginIndex; i < endIndex;) {
  46         UChar32 c = s.char32At(i);
  47         int32_t digit = u_charDigitValue(c);
  48         if (digit < 0) {
  49             status = U_INVALID_CHAR_FOUND;
  50             return FALSE;
  51         }
  52         result.append(kSuperscriptDigits[digit]);
  53         i += U16_LENGTH(c);
  54     }
  55     return TRUE;
  56 }
  57
  58 ScientificNumberFormatter *ScientificNumberFormatter::createSuperscriptInstance(
  59             DecimalFormat *fmtToAdopt, UErrorCode &status) {
  60     return createInstance(fmtToAdopt, new SuperscriptStyle(), status);
  61 }
  62
  63 ScientificNumberFormatter *ScientificNumberFormatter::createSuperscriptInstance(
  64             const Locale &locale, UErrorCode &status) {
  65     return createInstance(
  66             static_cast<DecimalFormat *>(
  67                     DecimalFormat::createScientificInstance(locale, status)),
  68             new SuperscriptStyle(),
  69             status);
  70 }
  71
  72 ScientificNumberFormatter *ScientificNumberFormatter::createMarkupInstance(
  73         DecimalFormat *fmtToAdopt,
  74         const UnicodeString &beginMarkup,
  75         const UnicodeString &endMarkup,
  76         UErrorCode &status) {
  77     return createInstance(
  78             fmtToAdopt,
  79             new MarkupStyle(beginMarkup, endMarkup),
  80             status);
  81 }
  82
  83 ScientificNumberFormatter *ScientificNumberFormatter::createMarkupInstance(
  84         const Locale &locale,
  85         const UnicodeString &beginMarkup,
  86         const UnicodeString &endMarkup,
  87         UErrorCode &status) {
  88     return createInstance(
  89             static_cast<DecimalFormat *>(
  90                     DecimalFormat::createScientificInstance(locale, status)),
  91             new MarkupStyle(beginMarkup, endMarkup),
  92             status);
  93 }
  94
  95 ScientificNumberFormatter *ScientificNumberFormatter::createInstance(
  96             DecimalFormat *fmtToAdopt,
  97             Style *styleToAdopt,
  98             UErrorCode &status) {
  99     LocalPointer<DecimalFormat> fmt(fmtToAdopt);
 100     LocalPointer<Style> style(styleToAdopt);
 101     if (U_FAILURE(status)) {
 102         return NULL;
 103     }
 104     ScientificNumberFormatter *result =
 105             new ScientificNumberFormatter(
 106                     fmt.getAlias(),
 107                     style.getAlias(),
 108                     status);
 109     if (result == NULL) {
 110         status = U_MEMORY_ALLOCATION_ERROR;
 111         return NULL;
 112     }
 113     fmt.orphan();
 114     style.orphan();
 115     if (U_FAILURE(status)) {
 116         delete result;
 117         return NULL;
 118     }
 119     return result;
 120 }
 121
 122 ScientificNumberFormatter::Style *ScientificNumberFormatter::SuperscriptStyle::clone() const {
 123     return new ScientificNumberFormatter::SuperscriptStyle(*this);
 124 }
 125
 126 UnicodeString &ScientificNumberFormatter::SuperscriptStyle::format(
 127         const UnicodeString &original,
 128         FieldPositionIterator &fpi,
 129         const UnicodeString &preExponent,
 130         const DecimalFormatStaticSets &staticSets,
 131         UnicodeString &appendTo,
 132         UErrorCode &status) const {
 133     if (U_FAILURE(status)) {
 134         return appendTo;
 135     }
 136     FieldPosition fp;
 137     int32_t copyFromOffset = 0;
 138     while (fpi.next(fp)) {
 139         switch (fp.getField()) {
 140         case UNUM_EXPONENT_SYMBOL_FIELD:
 141             appendTo.append(
 142                     original,
 143                     copyFromOffset,
 144                     fp.getBeginIndex() - copyFromOffset);
 145             copyFromOffset = fp.getEndIndex();
 146             appendTo.append(preExponent);
 147             break;
 148         case UNUM_EXPONENT_SIGN_FIELD:
 149             {
 150                 int32_t beginIndex = fp.getBeginIndex();
 151                 int32_t endIndex = fp.getEndIndex();
 152                 UChar32 aChar = original.char32At(beginIndex);
 153                 if (staticSets.fMinusSigns->contains(aChar)) {
 154                     appendTo.append(
 155                             original,
 156                             copyFromOffset,
 157                             beginIndex - copyFromOffset);
 158                     appendTo.append(kSuperscriptMinusSign);
 159                 } else if (staticSets.fPlusSigns->contains(aChar)) {
 160                     appendTo.append(
 161                            original,
 162                            copyFromOffset,
 163                            beginIndex - copyFromOffset);
 164                     appendTo.append(kSuperscriptPlusSign);
 165                 } else {
 166                     status = U_INVALID_CHAR_FOUND;
 167                     return appendTo;
 168                 }
 169                 copyFromOffset = endIndex;
 170             }
 171             break;
 172         case UNUM_EXPONENT_FIELD:
 173             appendTo.append(
 174                     original,
 175                     copyFromOffset,
 176                     fp.getBeginIndex() - copyFromOffset);
 177             if (!copyAsSuperscript(
 178                     original,
 179                     fp.getBeginIndex(),
 180                     fp.getEndIndex(),
 181                     appendTo,
 182                     status)) {
 183               return appendTo;
 184             }
 185             copyFromOffset = fp.getEndIndex();
 186             break;
 187         default:
 188             break;
 189         }
 190     }
 191     appendTo.append(
 192             original, copyFromOffset, original.length() - copyFromOffset);
 193     return appendTo;
 194 }
 195
 196 ScientificNumberFormatter::Style *ScientificNumberFormatter::MarkupStyle::clone() const {
 197     return new ScientificNumberFormatter::MarkupStyle(*this);
 198 }
 199
 200 UnicodeString &ScientificNumberFormatter::MarkupStyle::format(
 201         const UnicodeString &original,
 202         FieldPositionIterator &fpi,
 203         const UnicodeString &preExponent,
 204         const DecimalFormatStaticSets & /*unusedDecimalFormatSets*/,
 205         UnicodeString &appendTo,
 206         UErrorCode &status) const {
 207     if (U_FAILURE(status)) {
 208         return appendTo;
 209     }
 210     FieldPosition fp;
 211     int32_t copyFromOffset = 0;
 212     while (fpi.next(fp)) {
 213         switch (fp.getField()) {
 214         case UNUM_EXPONENT_SYMBOL_FIELD:
 215             appendTo.append(
 216                     original,
 217                     copyFromOffset,
 218                     fp.getBeginIndex() - copyFromOffset);
 219             copyFromOffset = fp.getEndIndex();
 220             appendTo.append(preExponent);
 221             appendTo.append(fBeginMarkup);
 222             break;
 223         case UNUM_EXPONENT_FIELD:
 224             appendTo.append(
 225                     original,
 226                     copyFromOffset,
 227                     fp.getEndIndex() - copyFromOffset);
 228             copyFromOffset = fp.getEndIndex();
 229             appendTo.append(fEndMarkup);
 230             break;
 231         default:
 232             break;
 233         }
 234     }
 235     appendTo.append(
 236             original, copyFromOffset, original.length() - copyFromOffset);
 237     return appendTo;
 238 }
 239
 240 ScientificNumberFormatter::ScientificNumberFormatter(
 241         DecimalFormat *fmtToAdopt, Style *styleToAdopt, UErrorCode &status)
 242         : fPreExponent(),
 243           fDecimalFormat(fmtToAdopt),
 244           fStyle(styleToAdopt),
 245           fStaticSets(NULL) {
 246     if (U_FAILURE(status)) {
 247         return;
 248     }
 249     if (fDecimalFormat == NULL || fStyle == NULL) {
 250         status = U_ILLEGAL_ARGUMENT_ERROR;
 251         return;
 252     }
 253     const DecimalFormatSymbols *sym = fDecimalFormat->getDecimalFormatSymbols();
 254     if (sym == NULL) {
 255         status = U_ILLEGAL_ARGUMENT_ERROR;
 256         return;
 257     }
 258     getPreExponent(*sym, fPreExponent);
 259     fStaticSets = DecimalFormatStaticSets::getStaticSets(status);
 260 }
 261
 262 ScientificNumberFormatter::ScientificNumberFormatter(
 263         const ScientificNumberFormatter &other)
 264         : UObject(other),
 265           fPreExponent(other.fPreExponent),
 266           fDecimalFormat(NULL),
 267           fStyle(NULL),
 268           fStaticSets(other.fStaticSets) {
 269     fDecimalFormat = static_cast<DecimalFormat *>(
 270             other.fDecimalFormat->clone());
 271     fStyle = other.fStyle->clone();
 272 }
 273
 274 ScientificNumberFormatter::~ScientificNumberFormatter() {
 275     delete fDecimalFormat;
 276     delete fStyle;
 277 }
 278
 279 UnicodeString &ScientificNumberFormatter::format(
 280         const Formattable &number,
 281         UnicodeString &appendTo,
 282         UErrorCode &status) const {
 283     if (U_FAILURE(status)) {
 284         return appendTo;
 285     }
 286     UnicodeString original;
 287     FieldPositionIterator fpi;
 288     fDecimalFormat->format(number, original, &fpi, status);
 289     return fStyle->format(
 290             original,
 291             fpi,
 292             fPreExponent,
 293             *fStaticSets,
 294             appendTo,
 295             status);
 296 }
 297
 298 void ScientificNumberFormatter::getPreExponent(
 299         const DecimalFormatSymbols &dfs, UnicodeString &preExponent) {
 300     preExponent.append(dfs.getConstSymbol(
 301             DecimalFormatSymbols::kExponentMultiplicationSymbol));
 302     preExponent.append(dfs.getConstSymbol(DecimalFormatSymbols::kOneDigitSymbol));
 303     preExponent.append(dfs.getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
 304 }
 305
 306 U_NAMESPACE_END
 307
 308 #endif /* !UCONFIG_NO_FORMATTING */