OLD | NEW |
(Empty) | |
| 1 /* |
| 2 ******************************************************************************* |
| 3 * Copyright (C) 2015, International Business Machines Corporation and * |
| 4 * others. All Rights Reserved. * |
| 5 ******************************************************************************* |
| 6 */ |
| 7 |
| 8 #ifndef VALUEFORMATTER_H |
| 9 #define VALUEFORMATTER_H |
| 10 |
| 11 #if !UCONFIG_NO_FORMATTING |
| 12 |
| 13 #include "unicode/uobject.h" |
| 14 #include "unicode/utypes.h" |
| 15 |
| 16 |
| 17 |
| 18 U_NAMESPACE_BEGIN |
| 19 |
| 20 class UnicodeString; |
| 21 class DigitList; |
| 22 class FieldPositionHandler; |
| 23 class DigitGrouping; |
| 24 class PluralRules; |
| 25 class FixedPrecision; |
| 26 class DigitFormatter; |
| 27 class DigitFormatterOptions; |
| 28 class ScientificPrecision; |
| 29 class SciFormatterOptions; |
| 30 class FixedDecimal; |
| 31 class VisibleDigitsWithExponent; |
| 32 |
| 33 |
| 34 /** |
| 35 * A closure around rounding and formatting a value. As these instances are |
| 36 * designed to be short lived (they only exist while formatting a value), they |
| 37 * do not own their own attributes. Rather the caller maintains ownership of |
| 38 * all attributes. A caller first calls a prepareXXX method on an instance |
| 39 * to share its data before using that instance. Using an |
| 40 * instance without first calling a prepareXXX method results in an |
| 41 * assertion error and a program crash. |
| 42 */ |
| 43 class U_I18N_API ValueFormatter : public UObject { |
| 44 public: |
| 45 ValueFormatter() : fType(kFormatTypeCount) { |
| 46 } |
| 47 |
| 48 virtual ~ValueFormatter(); |
| 49 |
| 50 /** |
| 51 * This function is here only to support the protected round() method |
| 52 * in DecimalFormat. It serves no ther purpose than that. |
| 53 * |
| 54 * @param value this value is rounded in place. |
| 55 * @param status any error returned here. |
| 56 */ |
| 57 DigitList &round(DigitList &value, UErrorCode &status) const; |
| 58 |
| 59 /** |
| 60 * Returns TRUE if the absolute value of value can be fast formatted |
| 61 * using ValueFormatter::formatInt32. |
| 62 */ |
| 63 UBool isFastFormattable(int32_t value) const; |
| 64 |
| 65 /** |
| 66 * Converts value to a VisibleDigitsWithExponent. |
| 67 * Result may be fixed point or scientific. |
| 68 */ |
| 69 VisibleDigitsWithExponent &toVisibleDigitsWithExponent( |
| 70 int64_t value, |
| 71 VisibleDigitsWithExponent &digits, |
| 72 UErrorCode &status) const; |
| 73 |
| 74 /** |
| 75 * Converts value to a VisibleDigitsWithExponent. |
| 76 * Result may be fixed point or scientific. |
| 77 */ |
| 78 VisibleDigitsWithExponent &toVisibleDigitsWithExponent( |
| 79 DigitList &value, |
| 80 VisibleDigitsWithExponent &digits, |
| 81 UErrorCode &status) const; |
| 82 |
| 83 /** |
| 84 * formats positiveValue and appends to appendTo. Returns appendTo. |
| 85 * @param positiveValue If negative, no negative sign is formatted. |
| 86 * @param handler stores the field positions |
| 87 * @param appendTo formatted value appended here. |
| 88 */ |
| 89 UnicodeString &format( |
| 90 const VisibleDigitsWithExponent &positiveValue, |
| 91 FieldPositionHandler &handler, |
| 92 UnicodeString &appendTo) const; |
| 93 |
| 94 |
| 95 /** |
| 96 * formats positiveValue and appends to appendTo. Returns appendTo. |
| 97 * value must be positive. Calling formatInt32 to format a value when |
| 98 * isFastFormattable indicates that the value cannot be fast formatted |
| 99 * results in undefined behavior. |
| 100 */ |
| 101 UnicodeString &formatInt32( |
| 102 int32_t positiveValue, |
| 103 FieldPositionHandler &handler, |
| 104 UnicodeString &appendTo) const; |
| 105 |
| 106 /** |
| 107 * Returns the number of code points needed to format. |
| 108 * @param positiveValue if negative, the negative sign is not included |
| 109 * in count. |
| 110 */ |
| 111 int32_t countChar32( |
| 112 const VisibleDigitsWithExponent &positiveValue) const; |
| 113 |
| 114 /** |
| 115 * Prepares this instance for fixed decimal formatting. |
| 116 */ |
| 117 void prepareFixedDecimalFormatting( |
| 118 const DigitFormatter &formatter, |
| 119 const DigitGrouping &grouping, |
| 120 const FixedPrecision &precision, |
| 121 const DigitFormatterOptions &options); |
| 122 |
| 123 /** |
| 124 * Prepares this instance for scientific formatting. |
| 125 */ |
| 126 void prepareScientificFormatting( |
| 127 const DigitFormatter &formatter, |
| 128 const ScientificPrecision &precision, |
| 129 const SciFormatterOptions &options); |
| 130 |
| 131 private: |
| 132 ValueFormatter(const ValueFormatter &); |
| 133 ValueFormatter &operator=(const ValueFormatter &); |
| 134 enum FormatType { |
| 135 kFixedDecimal, |
| 136 kScientificNotation, |
| 137 kFormatTypeCount |
| 138 }; |
| 139 |
| 140 FormatType fType; |
| 141 |
| 142 // for fixed decimal and scientific formatting |
| 143 const DigitFormatter *fDigitFormatter; |
| 144 |
| 145 // for fixed decimal formatting |
| 146 const FixedPrecision *fFixedPrecision; |
| 147 const DigitFormatterOptions *fFixedOptions; |
| 148 const DigitGrouping *fGrouping; |
| 149 |
| 150 // for scientific formatting |
| 151 const ScientificPrecision *fScientificPrecision; |
| 152 const SciFormatterOptions *fScientificOptions; |
| 153 }; |
| 154 |
| 155 U_NAMESPACE_END |
| 156 |
| 157 #endif /* !UCONFIG_NO_FORMATTING */ |
| 158 |
| 159 #endif /* VALUEFORMATTER_H */ |
OLD | NEW |