blob: 174f797fa4209c3c9f240b932a4716ed7aaf035e (
plain)
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
|
/*
*******************************************************************************
* Copyright (C) 2015, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
* digitinterval.h
*
* created on: 2015jan6
* created by: Travis Keep
*/
#ifndef __DIGITINTERVAL_H__
#define __DIGITINTERVAL_H__
#include "unicode/uobject.h"
#include "unicode/utypes.h"
U_NAMESPACE_BEGIN
/**
* An interval of digits.
* DigitIntervals are for fixed point formatting. A DigitInterval specifies
* zero or more integer digits and zero or more fractional digits. This class
* specifies particular digits in a number by their power of 10. For example,
* the digit position just to the left of the decimal is 0, and the digit
* position just left of that is 1. The digit position just to the right of
* the decimal is -1. The digit position just to the right of that is -2.
*/
class U_I18N_API DigitInterval : public UMemory {
public:
/**
* Spans all integer and fraction digits
*/
DigitInterval()
: fLargestExclusive(INT32_MAX), fSmallestInclusive(INT32_MIN) { }
/**
* Makes this instance span all digits.
*/
void clear() {
fLargestExclusive = INT32_MAX;
fSmallestInclusive = INT32_MIN;
}
/**
* Returns TRUE if this interval contains this digit position.
*/
UBool contains(int32_t digitPosition) const;
/**
* Returns true if this object is the same as rhs.
*/
UBool equals(const DigitInterval &rhs) const {
return ((fLargestExclusive == rhs.fLargestExclusive) &&
(fSmallestInclusive == rhs.fSmallestInclusive));
}
/**
* Expand this interval so that it contains all of rhs.
*/
void expandToContain(const DigitInterval &rhs);
/**
* Shrink this interval so that it contains no more than rhs.
*/
void shrinkToFitWithin(const DigitInterval &rhs);
/**
* Expand this interval as necessary to contain digit with given exponent
* After this method returns, this interval is guaranteed to contain
* digitExponent.
*/
void expandToContainDigit(int32_t digitExponent);
/**
* Changes the number of digits to the left of the decimal point that
* this interval spans. If count is negative, it means span all digits
* to the left of the decimal point.
*/
void setIntDigitCount(int32_t count);
/**
* Changes the number of digits to the right of the decimal point that
* this interval spans. If count is negative, it means span all digits
* to the right of the decimal point.
*/
void setFracDigitCount(int32_t count);
/**
* Sets the least significant inclusive value to smallest. If smallest >= 0
* then least significant inclusive value becomes 0.
*/
void setLeastSignificantInclusive(int32_t smallest) {
fSmallestInclusive = smallest < 0 ? smallest : 0;
}
/**
* Sets the most significant exclusive value to largest.
* If largest <= 0 then most significant exclusive value becomes 0.
*/
void setMostSignificantExclusive(int32_t largest) {
fLargestExclusive = largest > 0 ? largest : 0;
}
/**
* If returns 8, the most significant digit in interval is the 10^7 digit.
* Returns INT32_MAX if this interval spans all digits to left of
* decimal point.
*/
int32_t getMostSignificantExclusive() const {
return fLargestExclusive;
}
/**
* Returns number of digits to the left of the decimal that this
* interval includes. This is a synonym for getMostSignificantExclusive().
*/
int32_t getIntDigitCount() const {
return fLargestExclusive;
}
/**
* Returns number of digits to the right of the decimal that this
* interval includes.
*/
int32_t getFracDigitCount() const {
return fSmallestInclusive == INT32_MIN ? INT32_MAX : -fSmallestInclusive;
}
/**
* Returns the total number of digits that this interval spans.
* Caution: If this interval spans all digits to the left or right of
* decimal point instead of some fixed number, then what length()
* returns is undefined.
*/
int32_t length() const {
return fLargestExclusive - fSmallestInclusive;
}
/**
* If returns -3, the least significant digit in interval is the 10^-3
* digit. Returns INT32_MIN if this interval spans all digits to right of
* decimal point.
*/
int32_t getLeastSignificantInclusive() const {
return fSmallestInclusive;
}
private:
int32_t fLargestExclusive;
int32_t fSmallestInclusive;
};
U_NAMESPACE_END
#endif // __DIGITINTERVAL_H__
|
