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