OLD | NEW |
(Empty) | |
| 1 /* |
| 2 ******************************************************************************** |
| 3 * Copyright (C) 2015, International Business Machines |
| 4 * Corporation and others. All Rights Reserved. |
| 5 ******************************************************************************** |
| 6 * |
| 7 * File decimfmtimpl.h |
| 8 ******************************************************************************** |
| 9 */ |
| 10 |
| 11 #ifndef DECIMFMTIMPL_H |
| 12 #define DECIMFMTIMPL_H |
| 13 |
| 14 #include "unicode/utypes.h" |
| 15 |
| 16 #if !UCONFIG_NO_FORMATTING |
| 17 |
| 18 #include "unicode/decimfmt.h" |
| 19 #include "unicode/uobject.h" |
| 20 #include "affixpatternparser.h" |
| 21 #include "digitaffixesandpadding.h" |
| 22 #include "digitformatter.h" |
| 23 #include "digitgrouping.h" |
| 24 #include "precision.h" |
| 25 |
| 26 U_NAMESPACE_BEGIN |
| 27 |
| 28 class UnicodeString; |
| 29 class FieldPosition; |
| 30 class ValueFormatter; |
| 31 class FieldPositionHandler; |
| 32 class FixedDecimal; |
| 33 |
| 34 /** |
| 35 * DecimalFormatImpl is the glue code between the legacy DecimalFormat class |
| 36 * and the new decimal formatting classes. DecimalFormat still handles |
| 37 * parsing directly. However, DecimalFormat uses attributes of this class |
| 38 * for parsing when possible. |
| 39 * |
| 40 * The public API of this class closely mirrors the legacy API of the |
| 41 * legacy DecimalFormat deviating only when the legacy API does not make |
| 42 * sense. For example, although DecimalFormat has a |
| 43 * getPadCharacterString() method, DecimalFormatImpl has a getPadCharacter() |
| 44 * method because formatting uses only a single pad character for padding. |
| 45 * |
| 46 * Each legacy DecimalFormat instance heap allocates its own instance of |
| 47 * this class. Most DecimalFormat methods that deal with formatting simply |
| 48 * delegate to the DecimalFormat's DecimalFormatImpl method. |
| 49 * |
| 50 * Because DecimalFormat extends NumberFormat, Each instance of this class |
| 51 * "borrows" a pointer to the NumberFormat part of its enclosing DecimalFormat |
| 52 * instance. This way each DecimalFormatImpl instance can read or even modify |
| 53 * the NumberFormat portion of its enclosing DecimalFormat instance. |
| 54 * |
| 55 * Directed acyclic graph (DAG): |
| 56 * |
| 57 * This class can be represented as a directed acyclic graph (DAG) where each |
| 58 * vertex is an attribute, and each directed edge indicates that the value |
| 59 * of the destination attribute is calculated from the value of the source |
| 60 * attribute. Attributes with setter methods reside at the bottom of the |
| 61 * DAG. That is, no edges point to them. We call these independent attributes |
| 62 * because their values can be set independently of one another. The rest of |
| 63 * the attributes are derived attributes because their values depend on the |
| 64 * independent attributes. DecimalFormatImpl often uses the derived |
| 65 * attributes, not the independent attributes, when formatting numbers. |
| 66 * |
| 67 * The independent attributes at the bottom of the DAG correspond to the legacy |
| 68 * attributes of DecimalFormat while the attributes at the top of the DAG |
| 69 * correspond to the attributes of the new code. The edges of the DAG |
| 70 * correspond to the code that handles the complex interaction among all the |
| 71 * legacy attributes of the DecimalFormat API. |
| 72 * |
| 73 * We use a DAG for three reasons. |
| 74 * |
| 75 * First, the DAG preserves backward compatibility. Clients of the legacy |
| 76 * DecimalFormat expect existing getters and setters of each attribute to be |
| 77 * consistent. That means if a client sets a particular attribute to a new |
| 78 * value, the attribute should retain that value until the client sets it to |
| 79 * a new value. The DAG allows these attributes to remain consistent even |
| 80 * though the new code may not use them when formatting. |
| 81 * |
| 82 * Second, the DAG obviates the need to recalculate derived attributes with |
| 83 * each format. Instead, the DAG "remembers" the values of all derived |
| 84 * attributes. Only setting an independent attribute requires a recalculation. |
| 85 * Moreover, setting an independent attribute recalculates only the affected |
| 86 * dependent attributes rather than all dependent attributes. |
| 87 * |
| 88 * Third, the DAG abstracts away the complex interaction among the legacy |
| 89 * attributes of the DecimalFormat API. |
| 90 * |
| 91 * Only the independent attributes of the DAG have setters and getters. |
| 92 * Derived attributes have no setters (and often no getters either). |
| 93 * |
| 94 * Copy and assign: |
| 95 * |
| 96 * For copy and assign, DecimalFormatImpl copies and assigns every attribute |
| 97 * regardless of whether or not it is independent. We do this for simplicity. |
| 98 * |
| 99 * Implementation of the DAG: |
| 100 * |
| 101 * The DAG consists of three smaller DAGs: |
| 102 * 1. Grouping attributes |
| 103 * 2. Precision attributes |
| 104 * 3. Formatting attributes. |
| 105 * |
| 106 * The first two DAGs are simple in that setting any independent attribute |
| 107 * in the DAG recalculates all the dependent attributes in that DAG. |
| 108 * The updateGrouping() and updatePrecision() perform the respective |
| 109 * recalculations. |
| 110 * |
| 111 * Because some of the derived formatting attributes are expensive to |
| 112 * calculate, the formatting attributes DAG is more complex. The |
| 113 * updateFormatting() method is composed of many updateFormattingXXX() |
| 114 * methods, each of which recalculates a single derived attribute. The |
| 115 * updateFormatting() method accepts a bitfield of recently changed |
| 116 * attributes and passes this bitfield by reference to each of the |
| 117 * updateFormattingXXX() methods. Each updateFormattingXXX() method checks |
| 118 * the bitfield to see if any of the attributes it uses to compute the XXX |
| 119 * attribute changed. If none of them changed, it exists immediately. However, |
| 120 * if at least one of them changed, it recalculates the XXX attribute and |
| 121 * sets the corresponding bit in the bitfield. In this way, each |
| 122 * updateFormattingXXX() method encodes the directed edges in the formatting |
| 123 * DAG that point to the attribute its calculating. |
| 124 * |
| 125 * Maintenance of the updateFormatting() method. |
| 126 * |
| 127 * Use care when changing the updateFormatting() method. |
| 128 * The updateFormatting() method must call each updateFormattingXXX() in the |
| 129 * same partial order that the formatting DAG prescribes. That is, the |
| 130 * attributes near the bottom of the DAG must be calculated before attributes |
| 131 * further up. As we mentioned in the prvious paragraph, the directed edges of |
| 132 * the formatting DAG are encoded within each updateFormattingXXX() method. |
| 133 * Finally, adding new attributes may involve adding to the bitmap that the |
| 134 * updateFormatting() method uses. The top most attributes in the DAG, |
| 135 * those that do not point to any attributes but only have attributes |
| 136 * pointing to it, need not have a slot in the bitmap. |
| 137 * |
| 138 * Keep in mind that most of the code that makes the legacy DecimalFormat API |
| 139 * work the way it always has before can be found in these various updateXXX() |
| 140 * methods. For example the updatePrecisionForScientific() method |
| 141 * handles the complex interactions amoung the various precision attributes |
| 142 * when formatting in scientific notation. Changing the way attributes |
| 143 * interract, often means changing one of these updateXXX() methods. |
| 144 * |
| 145 * Conclusion: |
| 146 * |
| 147 * The DecimFmtImpl class is the glue code between the legacy and new |
| 148 * number formatting code. It uses a direct acyclic graph (DAG) to |
| 149 * maintain backward compatibility, to make the code efficient, and to |
| 150 * abstract away the complex interraction among legacy attributs. |
| 151 */ |
| 152 |
| 153 |
| 154 class DecimalFormatImpl : public UObject { |
| 155 public: |
| 156 |
| 157 DecimalFormatImpl( |
| 158 NumberFormat *super, |
| 159 const Locale &locale, |
| 160 const UnicodeString &pattern, |
| 161 UErrorCode &status); |
| 162 DecimalFormatImpl( |
| 163 NumberFormat *super, |
| 164 const UnicodeString &pattern, |
| 165 DecimalFormatSymbols *symbolsToAdopt, |
| 166 UParseError &parseError, |
| 167 UErrorCode &status); |
| 168 DecimalFormatImpl( |
| 169 NumberFormat *super, |
| 170 const DecimalFormatImpl &other, |
| 171 UErrorCode &status); |
| 172 DecimalFormatImpl &assign( |
| 173 const DecimalFormatImpl &other, UErrorCode &status); |
| 174 virtual ~DecimalFormatImpl(); |
| 175 void adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt); |
| 176 const DecimalFormatSymbols &getDecimalFormatSymbols() const { |
| 177 return *fSymbols; |
| 178 } |
| 179 UnicodeString &format( |
| 180 int32_t number, |
| 181 UnicodeString &appendTo, |
| 182 FieldPosition &pos, |
| 183 UErrorCode &status) const; |
| 184 UnicodeString &format( |
| 185 int32_t number, |
| 186 UnicodeString &appendTo, |
| 187 FieldPositionIterator *posIter, |
| 188 UErrorCode &status) const; |
| 189 UnicodeString &format( |
| 190 int64_t number, |
| 191 UnicodeString &appendTo, |
| 192 FieldPosition &pos, |
| 193 UErrorCode &status) const; |
| 194 UnicodeString &format( |
| 195 double number, |
| 196 UnicodeString &appendTo, |
| 197 FieldPosition &pos, |
| 198 UErrorCode &status) const; |
| 199 UnicodeString &format( |
| 200 const DigitList &number, |
| 201 UnicodeString &appendTo, |
| 202 FieldPosition &pos, |
| 203 UErrorCode &status) const; |
| 204 UnicodeString &format( |
| 205 int64_t number, |
| 206 UnicodeString &appendTo, |
| 207 FieldPositionIterator *posIter, |
| 208 UErrorCode &status) const; |
| 209 UnicodeString &format( |
| 210 double number, |
| 211 UnicodeString &appendTo, |
| 212 FieldPositionIterator *posIter, |
| 213 UErrorCode &status) const; |
| 214 UnicodeString &format( |
| 215 const DigitList &number, |
| 216 UnicodeString &appendTo, |
| 217 FieldPositionIterator *posIter, |
| 218 UErrorCode &status) const; |
| 219 UnicodeString &format( |
| 220 const StringPiece &number, |
| 221 UnicodeString &appendTo, |
| 222 FieldPositionIterator *posIter, |
| 223 UErrorCode &status) const; |
| 224 UnicodeString &format( |
| 225 const VisibleDigitsWithExponent &digits, |
| 226 UnicodeString &appendTo, |
| 227 FieldPosition &pos, |
| 228 UErrorCode &status) const; |
| 229 UnicodeString &format( |
| 230 const VisibleDigitsWithExponent &digits, |
| 231 UnicodeString &appendTo, |
| 232 FieldPositionIterator *posIter, |
| 233 UErrorCode &status) const; |
| 234 |
| 235 UBool operator==(const DecimalFormatImpl &) const; |
| 236 |
| 237 UBool operator!=(const DecimalFormatImpl &other) const { |
| 238 return !(*this == other); |
| 239 } |
| 240 |
| 241 void setRoundingMode(DecimalFormat::ERoundingMode mode) { |
| 242 fRoundingMode = mode; |
| 243 fEffPrecision.fMantissa.fExactOnly = (fRoundingMode == DecimalFormat::kRound
Unnecessary); |
| 244 fEffPrecision.fMantissa.fRoundingMode = mode; |
| 245 } |
| 246 DecimalFormat::ERoundingMode getRoundingMode() const { |
| 247 return fRoundingMode; |
| 248 } |
| 249 void setFailIfMoreThanMaxDigits(UBool b) { |
| 250 fEffPrecision.fMantissa.fFailIfOverMax = b; |
| 251 } |
| 252 UBool isFailIfMoreThanMaxDigits() const { return fEffPrecision.fMantissa.fFailIf
OverMax; } |
| 253 void setMinimumSignificantDigits(int32_t newValue); |
| 254 void setMaximumSignificantDigits(int32_t newValue); |
| 255 void setMinMaxSignificantDigits(int32_t min, int32_t max); |
| 256 void setScientificNotation(UBool newValue); |
| 257 void setSignificantDigitsUsed(UBool newValue); |
| 258 |
| 259 int32_t getMinimumSignificantDigits() const { |
| 260 return fMinSigDigits; } |
| 261 int32_t getMaximumSignificantDigits() const { |
| 262 return fMaxSigDigits; } |
| 263 UBool isScientificNotation() const { return fUseScientific; } |
| 264 UBool areSignificantDigitsUsed() const { return fUseSigDigits; } |
| 265 void setGroupingSize(int32_t newValue); |
| 266 void setSecondaryGroupingSize(int32_t newValue); |
| 267 void setMinimumGroupingDigits(int32_t newValue); |
| 268 int32_t getGroupingSize() const { return fGrouping.fGrouping; } |
| 269 int32_t getSecondaryGroupingSize() const { return fGrouping.fGrouping2; } |
| 270 int32_t getMinimumGroupingDigits() const { return fGrouping.fMinGrouping; } |
| 271 void applyPattern(const UnicodeString &pattern, UErrorCode &status); |
| 272 void applyPatternFavorCurrencyPrecision( |
| 273 const UnicodeString &pattern, UErrorCode &status); |
| 274 void applyPattern( |
| 275 const UnicodeString &pattern, UParseError &perror, UErrorCode &status); |
| 276 void applyLocalizedPattern(const UnicodeString &pattern, UErrorCode &status); |
| 277 void applyLocalizedPattern( |
| 278 const UnicodeString &pattern, UParseError &perror, UErrorCode &status); |
| 279 void setCurrencyUsage(UCurrencyUsage usage, UErrorCode &status); |
| 280 UCurrencyUsage getCurrencyUsage() const { return fCurrencyUsage; } |
| 281 void setRoundingIncrement(double d); |
| 282 double getRoundingIncrement() const; |
| 283 int32_t getMultiplier() const; |
| 284 void setMultiplier(int32_t m); |
| 285 UChar32 getPadCharacter() const { return fAffixes.fPadChar; } |
| 286 void setPadCharacter(UChar32 c) { fAffixes.fPadChar = c; } |
| 287 int32_t getFormatWidth() const { return fAffixes.fWidth; } |
| 288 void setFormatWidth(int32_t x) { fAffixes.fWidth = x; } |
| 289 DigitAffixesAndPadding::EPadPosition getPadPosition() const { |
| 290 return fAffixes.fPadPosition; |
| 291 } |
| 292 void setPadPosition(DigitAffixesAndPadding::EPadPosition x) { |
| 293 fAffixes.fPadPosition = x; |
| 294 } |
| 295 int32_t getMinimumExponentDigits() const { |
| 296 return fEffPrecision.fMinExponentDigits; |
| 297 } |
| 298 void setMinimumExponentDigits(int32_t x) { |
| 299 fEffPrecision.fMinExponentDigits = x; |
| 300 } |
| 301 UBool isExponentSignAlwaysShown() const { |
| 302 return fOptions.fExponent.fAlwaysShowSign; |
| 303 } |
| 304 void setExponentSignAlwaysShown(UBool x) { |
| 305 fOptions.fExponent.fAlwaysShowSign = x; |
| 306 } |
| 307 UBool isDecimalSeparatorAlwaysShown() const { |
| 308 return fOptions.fMantissa.fAlwaysShowDecimal; |
| 309 } |
| 310 void setDecimalSeparatorAlwaysShown(UBool x) { |
| 311 fOptions.fMantissa.fAlwaysShowDecimal = x; |
| 312 } |
| 313 UnicodeString &getPositivePrefix(UnicodeString &result) const; |
| 314 UnicodeString &getPositiveSuffix(UnicodeString &result) const; |
| 315 UnicodeString &getNegativePrefix(UnicodeString &result) const; |
| 316 UnicodeString &getNegativeSuffix(UnicodeString &result) const; |
| 317 void setPositivePrefix(const UnicodeString &str); |
| 318 void setPositiveSuffix(const UnicodeString &str); |
| 319 void setNegativePrefix(const UnicodeString &str); |
| 320 void setNegativeSuffix(const UnicodeString &str); |
| 321 UnicodeString &toPattern(UnicodeString& result) const; |
| 322 FixedDecimal &getFixedDecimal(double value, FixedDecimal &result, UErrorCode &st
atus) const; |
| 323 FixedDecimal &getFixedDecimal(DigitList &number, FixedDecimal &result, UErrorCod
e &status) const; |
| 324 DigitList &round(DigitList &number, UErrorCode &status) const; |
| 325 |
| 326 VisibleDigitsWithExponent & |
| 327 initVisibleDigitsWithExponent( |
| 328 int64_t number, |
| 329 VisibleDigitsWithExponent &digits, |
| 330 UErrorCode &status) const; |
| 331 VisibleDigitsWithExponent & |
| 332 initVisibleDigitsWithExponent( |
| 333 double number, |
| 334 VisibleDigitsWithExponent &digits, |
| 335 UErrorCode &status) const; |
| 336 VisibleDigitsWithExponent & |
| 337 initVisibleDigitsWithExponent( |
| 338 DigitList &number, |
| 339 VisibleDigitsWithExponent &digits, |
| 340 UErrorCode &status) const; |
| 341 |
| 342 void updatePrecision(); |
| 343 void updateGrouping(); |
| 344 void updateCurrency(UErrorCode &status); |
| 345 |
| 346 |
| 347 private: |
| 348 // Disallow copy and assign |
| 349 DecimalFormatImpl(const DecimalFormatImpl &other); |
| 350 DecimalFormatImpl &operator=(const DecimalFormatImpl &other); |
| 351 NumberFormat *fSuper; |
| 352 DigitList fMultiplier; |
| 353 int32_t fScale; |
| 354 |
| 355 DecimalFormat::ERoundingMode fRoundingMode; |
| 356 |
| 357 // These fields include what the user can see and set. |
| 358 // When the user updates these fields, it triggers automatic updates of |
| 359 // other fields that may be invisible to user |
| 360 |
| 361 // Updating any of the following fields triggers an update to |
| 362 // fEffPrecision.fMantissa.fMin, |
| 363 // fEffPrecision.fMantissa.fMax, |
| 364 // fEffPrecision.fMantissa.fSignificant fields |
| 365 // We have this two phase update because of backward compatibility. |
| 366 // DecimalFormat has to remember all settings even if those settings are |
| 367 // invalid or disabled. |
| 368 int32_t fMinSigDigits; |
| 369 int32_t fMaxSigDigits; |
| 370 UBool fUseScientific; |
| 371 UBool fUseSigDigits; |
| 372 // In addition to these listed above, changes to min/max int digits and |
| 373 // min/max frac digits from fSuper also trigger an update. |
| 374 |
| 375 // Updating any of the following fields triggers an update to |
| 376 // fEffGrouping field Again we do it this way because original |
| 377 // grouping settings have to be retained if grouping is turned off. |
| 378 DigitGrouping fGrouping; |
| 379 // In addition to these listed above, changes to isGroupingUsed in |
| 380 // fSuper also triggers an update to fEffGrouping. |
| 381 |
| 382 // Updating any of the following fields triggers updates on the following: |
| 383 // fMonetary, fRules, fAffixParser, fCurrencyAffixInfo, |
| 384 // fFormatter, fAffixes.fPositivePrefiix, fAffixes.fPositiveSuffix, |
| 385 // fAffixes.fNegativePrefiix, fAffixes.fNegativeSuffix |
| 386 // We do this two phase update because localizing the affix patterns |
| 387 // and formatters can be expensive. Better to do it once with the setters |
| 388 // than each time within format. |
| 389 AffixPattern fPositivePrefixPattern; |
| 390 AffixPattern fNegativePrefixPattern; |
| 391 AffixPattern fPositiveSuffixPattern; |
| 392 AffixPattern fNegativeSuffixPattern; |
| 393 DecimalFormatSymbols *fSymbols; |
| 394 UCurrencyUsage fCurrencyUsage; |
| 395 // In addition to these listed above, changes to getCurrency() in |
| 396 // fSuper also triggers an update. |
| 397 |
| 398 // Optional may be NULL |
| 399 PluralRules *fRules; |
| 400 |
| 401 // These fields are totally hidden from user and are used to derive the affixes |
| 402 // in fAffixes below from the four affix patterns above. |
| 403 UBool fMonetary; |
| 404 AffixPatternParser fAffixParser; |
| 405 CurrencyAffixInfo fCurrencyAffixInfo; |
| 406 |
| 407 // The actual precision used when formatting |
| 408 ScientificPrecision fEffPrecision; |
| 409 |
| 410 // The actual grouping used when formatting |
| 411 DigitGrouping fEffGrouping; |
| 412 SciFormatterOptions fOptions; // Encapsulates fixed precision options |
| 413 DigitFormatter fFormatter; |
| 414 DigitAffixesAndPadding fAffixes; |
| 415 |
| 416 UnicodeString &formatInt32( |
| 417 int32_t number, |
| 418 UnicodeString &appendTo, |
| 419 FieldPositionHandler &handler, |
| 420 UErrorCode &status) const; |
| 421 |
| 422 UnicodeString &formatInt64( |
| 423 int64_t number, |
| 424 UnicodeString &appendTo, |
| 425 FieldPositionHandler &handler, |
| 426 UErrorCode &status) const; |
| 427 |
| 428 UnicodeString &formatDouble( |
| 429 double number, |
| 430 UnicodeString &appendTo, |
| 431 FieldPositionHandler &handler, |
| 432 UErrorCode &status) const; |
| 433 |
| 434 // Scales for precent or permille symbols |
| 435 UnicodeString &formatDigitList( |
| 436 DigitList &number, |
| 437 UnicodeString &appendTo, |
| 438 FieldPositionHandler &handler, |
| 439 UErrorCode &status) const; |
| 440 |
| 441 // Does not scale for precent or permille symbols |
| 442 UnicodeString &formatAdjustedDigitList( |
| 443 DigitList &number, |
| 444 UnicodeString &appendTo, |
| 445 FieldPositionHandler &handler, |
| 446 UErrorCode &status) const; |
| 447 |
| 448 UnicodeString &formatVisibleDigitsWithExponent( |
| 449 const VisibleDigitsWithExponent &number, |
| 450 UnicodeString &appendTo, |
| 451 FieldPositionHandler &handler, |
| 452 UErrorCode &status) const; |
| 453 |
| 454 VisibleDigitsWithExponent & |
| 455 initVisibleDigitsFromAdjusted( |
| 456 DigitList &number, |
| 457 VisibleDigitsWithExponent &digits, |
| 458 UErrorCode &status) const; |
| 459 |
| 460 template<class T> |
| 461 UBool maybeFormatWithDigitList( |
| 462 T number, |
| 463 UnicodeString &appendTo, |
| 464 FieldPositionHandler &handler, |
| 465 UErrorCode &status) const; |
| 466 |
| 467 template<class T> |
| 468 UBool maybeInitVisibleDigitsFromDigitList( |
| 469 T number, |
| 470 VisibleDigitsWithExponent &digits, |
| 471 UErrorCode &status) const; |
| 472 |
| 473 DigitList &adjustDigitList(DigitList &number, UErrorCode &status) const; |
| 474 |
| 475 void applyPattern( |
| 476 const UnicodeString &pattern, |
| 477 UBool localized, UParseError &perror, UErrorCode &status); |
| 478 |
| 479 ValueFormatter &prepareValueFormatter(ValueFormatter &vf) const; |
| 480 void setMultiplierScale(int32_t s); |
| 481 int32_t getPatternScale() const; |
| 482 void setScale(int32_t s) { fScale = s; } |
| 483 int32_t getScale() const { return fScale; } |
| 484 |
| 485 // Updates everything |
| 486 void updateAll(UErrorCode &status); |
| 487 void updateAll( |
| 488 int32_t formattingFlags, |
| 489 UBool updatePrecisionBasedOnCurrency, |
| 490 UErrorCode &status); |
| 491 |
| 492 // Updates from formatting pattern changes |
| 493 void updateForApplyPattern(UErrorCode &status); |
| 494 void updateForApplyPatternFavorCurrencyPrecision(UErrorCode &status); |
| 495 |
| 496 // Updates from changes to third group of attributes |
| 497 void updateFormatting(int32_t changedFormattingFields, UErrorCode &status); |
| 498 void updateFormatting( |
| 499 int32_t changedFormattingFields, |
| 500 UBool updatePrecisionBasedOnCurrency, |
| 501 UErrorCode &status); |
| 502 |
| 503 // Helper functions for updatePrecision |
| 504 void updatePrecisionForScientific(); |
| 505 void updatePrecisionForFixed(); |
| 506 void extractMinMaxDigits(DigitInterval &min, DigitInterval &max) const; |
| 507 void extractSigDigits(SignificantDigitInterval &sig) const; |
| 508 |
| 509 // Helper functions for updateFormatting |
| 510 void updateFormattingUsesCurrency(int32_t &changedFormattingFields); |
| 511 void updateFormattingPluralRules( |
| 512 int32_t &changedFormattingFields, UErrorCode &status); |
| 513 void updateFormattingAffixParser(int32_t &changedFormattingFields); |
| 514 void updateFormattingCurrencyAffixInfo( |
| 515 int32_t &changedFormattingFields, |
| 516 UBool updatePrecisionBasedOnCurrency, |
| 517 UErrorCode &status); |
| 518 void updateFormattingFixedPointFormatter( |
| 519 int32_t &changedFormattingFields); |
| 520 void updateFormattingLocalizedPositivePrefix( |
| 521 int32_t &changedFormattingFields, UErrorCode &status); |
| 522 void updateFormattingLocalizedPositiveSuffix( |
| 523 int32_t &changedFormattingFields, UErrorCode &status); |
| 524 void updateFormattingLocalizedNegativePrefix( |
| 525 int32_t &changedFormattingFields, UErrorCode &status); |
| 526 void updateFormattingLocalizedNegativeSuffix( |
| 527 int32_t &changedFormattingFields, UErrorCode &status); |
| 528 |
| 529 int32_t computeExponentPatternLength() const; |
| 530 int32_t countFractionDigitAndDecimalPatternLength(int32_t fracDigitCount) const; |
| 531 UnicodeString &toNumberPattern( |
| 532 UBool hasPadding, int32_t minimumLength, UnicodeString& result) const; |
| 533 |
| 534 int32_t getOldFormatWidth() const; |
| 535 const UnicodeString &getConstSymbol( |
| 536 DecimalFormatSymbols::ENumberFormatSymbol symbol) const; |
| 537 UBool isParseFastpath() const; |
| 538 |
| 539 friend class DecimalFormat; |
| 540 |
| 541 }; |
| 542 |
| 543 |
| 544 U_NAMESPACE_END |
| 545 #endif /* #if !UCONFIG_NO_FORMATTING */ |
| 546 #endif // DECIMFMTIMPL_H |
| 547 //eof |
OLD | NEW |