ICU 56 update step 1

source/i18n/digitlst.h

 /*
 ******************************************************************************
 *
-*   Copyright (C) 1997-2013, International Business Machines
+*   Copyright (C) 1997-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
 *
 * File DIGITLST.H
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   02/25/97    aliu        Converted from java.
@@ skipping 29 matching lines @@
     DIGIT_PADDING = 3,
     DEFAULT_DIGITS = 40,   // Initial storage size, will grow as needed.
 
      // "+." + fDigits + "e" + fDecimalAt
     MAX_DEC_DIGITS = MAX_DIGITS + DIGIT_PADDING + MAX_EXPONENT
 } EDigitListValues;
 
 U_NAMESPACE_BEGIN
 
 class CharString;
+class DigitInterval; 
 
 // Export an explicit template instantiation of the MaybeStackHeaderAndArray that
 //    is used as a data member of DigitList.
 //
 //    MSVC requires this, even though it should not be necessary. 
 //    No direct access to the MaybeStackHeaderAndArray leaks out of the i18n library.
 //
 //    Macintosh produces duplicate definition linker errors with the explicit template
 //    instantiation.
 //
@@ skipping 242 matching lines @@
     /** Set to zero */
     void     setToZero() {uprv_decNumberZero(fDecNumber);}
 
     /** get the number of digits in the decimal number */
     int32_t  digits() const {return fDecNumber->digits;}
 
     /**
      * Round the number to the given number of digits.
      * @param maximumDigits The maximum number of digits to be shown.
      * Upon return, count will be less than or equal to maximumDigits.
+     * result is guaranteed to be trimmed. 
      */
     void round(int32_t maximumDigits);
 
     void roundFixedPoint(int32_t maximumFractionDigits);
 
     /** Ensure capacity for digits.  Grow the storage if it is currently less than
      *      the requested size.   Capacity is not reduced if it is already greater
      *      than requested.
      */
     void  ensureCapacity(int32_t  requestedSize, UErrorCode &status); 
@@ skipping 23 matching lines @@
 
 
     /**
      * Get the digit's value, as an integer from 0..9 inclusive.
      * Note that internally this value is a decNumberUnit, but ICU configures it to be a uint8_t.
      * @param i index of digit
      * @return value of that digit
      */
     uint8_t     getDigitValue(int32_t i);
 
+    /**
+     * Gets the upper bound exponent for this value. For 987, returns 3
+     * because 10^3 is the smallest power of 10 that is just greater than
+     * 987.
+     */
+    int32_t getUpperExponent() const;
+
+    /**
+     * Gets the lower bound exponent for this value. For 98.7, returns -1
+     * because the right most digit, is the 10^-1 place.
+     */
+    int32_t getLowerExponent() const { return fDecNumber->exponent; }
+
+    /**
+     * Sets result to the smallest DigitInterval needed to display this
+     * DigitList in fixed point form and returns result.
+     */
+    DigitInterval& getSmallestInterval(DigitInterval &result) const;
+
+    /**
+     * Like getDigitValue, but the digit is identified by exponent.
+     * For example, getDigitByExponent(7) returns the 10^7 place of this
+     * DigitList. Unlike getDigitValue, there are no upper or lower bounds
+     * for passed parameter. Instead, getDigitByExponent returns 0 if
+     * the exponent falls outside the interval for this DigitList.
+     */
+    uint8_t getDigitByExponent(int32_t exponent) const;
+
+    /**
+     * Appends the digits in this object to a CharString.
+     * 3 is appended as (char) 3, not '3'
+     */
+    void appendDigitsTo(CharString &str, UErrorCode &status) const;
+
+    /**
+     * Equivalent to roundFixedPoint(-digitExponent) except unlike
+     * roundFixedPoint, this works for any digitExponent value.
+     * If maxSigDigits is set then this instance is rounded to have no more
+     * than maxSigDigits. The end result is guaranteed to be trimmed.
+     */
+    void roundAtExponent(int32_t digitExponent, int32_t maxSigDigits=INT32_MAX);
+
+    /**
+     * Quantizes according to some amount and rounds according to the
+     * context of this instance. Quantizing 3.233 with 0.05 gives 3.25.
+     */
+    void quantize(const DigitList &amount, UErrorCode &status);
+
+    /**
+     * Like toScientific but only returns the exponent
+     * leaving this instance unchanged.
+     */ 
+    int32_t getScientificExponent(
+            int32_t minIntDigitCount, int32_t exponentMultiplier) const;
+
+    /**
+     * Converts this instance to scientific notation. This instance
+     * becomes the mantissa and the exponent is returned.
+     * @param minIntDigitCount minimum integer digits in mantissa
+     *   Exponent is set so that the actual number of integer digits
+     *   in mantissa is as close to the minimum as possible.
+     * @param exponentMultiplier The exponent is always a multiple of
+     *  This number. Usually 1, but set to 3 for engineering notation.
+     * @return exponent
+     */
+    int32_t toScientific(
+            int32_t minIntDigitCount, int32_t exponentMultiplier);
+
+    /**
+     * Shifts decimal to the right.
+     */
+    void shiftDecimalRight(int32_t numPlaces);
 
 private:
     /*
      * These data members are intentionally public and can be set directly.
      *<P>
      * The value represented is given by placing the decimal point before
      * fDigits[fDecimalAt].  If fDecimalAt is < 0, then leading zeros between
      * the decimal point and the first nonzero digit are implied.  If fDecimalAt
      * is > fCount, then trailing zeros between the fDigits[fCount-1] and the
      * decimal point are implied.
@@ skipping 44 matching lines @@
 
  public:
 
 #if U_OVERRIDE_CXX_ALLOCATION
     using UMemory::operator new;
     using UMemory::operator delete;
 #else
     static inline void * U_EXPORT2 operator new(size_t size) U_NO_THROW { return ::operator new(size); };
     static inline void U_EXPORT2 operator delete(void *ptr )  U_NO_THROW { ::operator delete(ptr); };
 #endif
+    static char U_EXPORT2 getStrtodDecimalSeparator();
 
     /**
      * Placement new for stack usage
      * @internal
      */
     static inline void * U_EXPORT2 operator new(size_t /*size*/, void * onStack, EStackMode  /*mode*/) U_NO_THROW { return onStack; }
 
     /**
      * Placement delete for stack usage
      * @internal
@@ skipping 14 matching lines @@
     }
 };
 
 
 U_NAMESPACE_END
 
 #endif // #if !UCONFIG_NO_FORMATTING
 #endif // _DIGITLST
 
 //eof