icuSources/i18n/digitinterval.h

   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__