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