OLD | NEW |
(Empty) | |
| 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::c
lone() 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 */ |
OLD | NEW |