OLD | NEW |
(Empty) | |
| 1 /* |
| 2 ******************************************************************************* |
| 3 * Copyright (C) 2015, International Business Machines |
| 4 * Corporation and others. All Rights Reserved. |
| 5 ******************************************************************************* |
| 6 * digitinterval.h |
| 7 * |
| 8 * created on: 2015jan6 |
| 9 * created by: Travis Keep |
| 10 */ |
| 11 |
| 12 #ifndef __DIGITINTERVAL_H__ |
| 13 #define __DIGITINTERVAL_H__ |
| 14 |
| 15 #include "unicode/uobject.h" |
| 16 #include "unicode/utypes.h" |
| 17 |
| 18 U_NAMESPACE_BEGIN |
| 19 |
| 20 /** |
| 21 * An interval of digits. |
| 22 * DigitIntervals are for fixed point formatting. A DigitInterval specifies |
| 23 * zero or more integer digits and zero or more fractional digits. This class |
| 24 * specifies particular digits in a number by their power of 10. For example, |
| 25 * the digit position just to the left of the decimal is 0, and the digit |
| 26 * position just left of that is 1. The digit position just to the right of |
| 27 * the decimal is -1. The digit position just to the right of that is -2. |
| 28 */ |
| 29 class U_I18N_API DigitInterval : public UMemory { |
| 30 public: |
| 31 |
| 32 /** |
| 33 * Spans all integer and fraction digits |
| 34 */ |
| 35 DigitInterval() |
| 36 : fLargestExclusive(INT32_MAX), fSmallestInclusive(INT32_MIN) { } |
| 37 |
| 38 |
| 39 /** |
| 40 * Makes this instance span all digits. |
| 41 */ |
| 42 void clear() { |
| 43 fLargestExclusive = INT32_MAX; |
| 44 fSmallestInclusive = INT32_MIN; |
| 45 } |
| 46 |
| 47 /** |
| 48 * Returns TRUE if this interval contains this digit position. |
| 49 */ |
| 50 UBool contains(int32_t digitPosition) const; |
| 51 |
| 52 /** |
| 53 * Returns true if this object is the same as rhs. |
| 54 */ |
| 55 UBool equals(const DigitInterval &rhs) const { |
| 56 return ((fLargestExclusive == rhs.fLargestExclusive) && |
| 57 (fSmallestInclusive == rhs.fSmallestInclusive)); |
| 58 } |
| 59 |
| 60 /** |
| 61 * Expand this interval so that it contains all of rhs. |
| 62 */ |
| 63 void expandToContain(const DigitInterval &rhs); |
| 64 |
| 65 /** |
| 66 * Shrink this interval so that it contains no more than rhs. |
| 67 */ |
| 68 void shrinkToFitWithin(const DigitInterval &rhs); |
| 69 |
| 70 /** |
| 71 * Expand this interval as necessary to contain digit with given exponent |
| 72 * After this method returns, this interval is guaranteed to contain |
| 73 * digitExponent. |
| 74 */ |
| 75 void expandToContainDigit(int32_t digitExponent); |
| 76 |
| 77 /** |
| 78 * Changes the number of digits to the left of the decimal point that |
| 79 * this interval spans. If count is negative, it means span all digits |
| 80 * to the left of the decimal point. |
| 81 */ |
| 82 void setIntDigitCount(int32_t count); |
| 83 |
| 84 /** |
| 85 * Changes the number of digits to the right of the decimal point that |
| 86 * this interval spans. If count is negative, it means span all digits |
| 87 * to the right of the decimal point. |
| 88 */ |
| 89 void setFracDigitCount(int32_t count); |
| 90 |
| 91 /** |
| 92 * Sets the least significant inclusive value to smallest. If smallest >= 0 |
| 93 * then least significant inclusive value becomes 0. |
| 94 */ |
| 95 void setLeastSignificantInclusive(int32_t smallest) { |
| 96 fSmallestInclusive = smallest < 0 ? smallest : 0; |
| 97 } |
| 98 |
| 99 /** |
| 100 * Sets the most significant exclusive value to largest. |
| 101 * If largest <= 0 then most significant exclusive value becomes 0. |
| 102 */ |
| 103 void setMostSignificantExclusive(int32_t largest) { |
| 104 fLargestExclusive = largest > 0 ? largest : 0; |
| 105 } |
| 106 |
| 107 /** |
| 108 * If returns 8, the most significant digit in interval is the 10^7 digit. |
| 109 * Returns INT32_MAX if this interval spans all digits to left of |
| 110 * decimal point. |
| 111 */ |
| 112 int32_t getMostSignificantExclusive() const { |
| 113 return fLargestExclusive; |
| 114 } |
| 115 |
| 116 /** |
| 117 * Returns number of digits to the left of the decimal that this |
| 118 * interval includes. This is a synonym for getMostSignificantExclusive(). |
| 119 */ |
| 120 int32_t getIntDigitCount() const { |
| 121 return fLargestExclusive; |
| 122 } |
| 123 |
| 124 /** |
| 125 * Returns number of digits to the right of the decimal that this |
| 126 * interval includes. |
| 127 */ |
| 128 int32_t getFracDigitCount() const { |
| 129 return fSmallestInclusive == INT32_MIN ? INT32_MAX : -fSmallestInclusive
; |
| 130 } |
| 131 |
| 132 /** |
| 133 * Returns the total number of digits that this interval spans. |
| 134 * Caution: If this interval spans all digits to the left or right of |
| 135 * decimal point instead of some fixed number, then what length() |
| 136 * returns is undefined. |
| 137 */ |
| 138 int32_t length() const { |
| 139 return fLargestExclusive - fSmallestInclusive; |
| 140 } |
| 141 |
| 142 /** |
| 143 * If returns -3, the least significant digit in interval is the 10^-3 |
| 144 * digit. Returns INT32_MIN if this interval spans all digits to right of |
| 145 * decimal point. |
| 146 */ |
| 147 int32_t getLeastSignificantInclusive() const { |
| 148 return fSmallestInclusive; |
| 149 } |
| 150 private: |
| 151 int32_t fLargestExclusive; |
| 152 int32_t fSmallestInclusive; |
| 153 }; |
| 154 |
| 155 U_NAMESPACE_END |
| 156 |
| 157 #endif // __DIGITINTERVAL_H__ |
OLD | NEW |