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:
ValueFormatter()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 */
160