Update ICU to 54.1 step 1

source/i18n/unicode/decimfmt.h

 /*
 ********************************************************************************
-*   Copyright (C) 1997-2013, International Business Machines
+*   Copyright (C) 1997-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ********************************************************************************
 *
 * File DECIMFMT.H
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   02/19/97    aliu        Converted from java.
 *   03/20/97    clhuang     Updated per C++ implementation.
@@ skipping 42 matching lines @@
 class CurrencyPluralInfo;
 class Hashtable;
 class UnicodeSet;
 class FieldPositionHandler;
 class DecimalFormatStaticSets;
 class FixedDecimal;
 
 // explicit template instantiation. see digitlst.h
 #if defined (_MSC_VER)
 template class U_I18N_API    EnumSet<UNumberFormatAttribute,
-            UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1, 
+            UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
             UNUM_LIMIT_BOOLEAN_ATTRIBUTE>;
 #endif
 
 /**
  * DecimalFormat is a concrete subclass of NumberFormat that formats decimal
  * numbers. It has a variety of features designed to make it possible to parse
  * and format numbers in any locale, including support for Western, Arabic, or
  * Indic digits.  It also supports different flavors of numbers, including
  * integers ("123"), fixed-point numbers ("123.4"), scientific notation
  * ("1.23E4"), percentages ("12%"), and currency amounts ("$123", "USD123",
@@ skipping 594 matching lines @@
         kRoundFloor,    /**< Round towards negative infinity */
         kRoundDown,     /**< Round towards zero */
         kRoundUp,       /**< Round away from zero */
         kRoundHalfEven, /**< Round towards the nearest integer, or
                              towards the nearest even integer if equidistant */
         kRoundHalfDown, /**< Round towards the nearest integer, or
                              towards zero if equidistant */
         kRoundHalfUp,   /**< Round towards the nearest integer, or
                              away from zero if equidistant */
         /**
-          *  Return U_FORMAT_INEXACT_ERROR if number does not format exactly. 
-          *  @stable ICU 4.8 
+          *  Return U_FORMAT_INEXACT_ERROR if number does not format exactly.
+          *  @stable ICU 4.8
           */
         kRoundUnnecessary
     };
 
     /**
      * Pad position.
      * @stable ICU 2.4
      */
     enum EPadPosition {
         kPadBeforePrefix,
@@ skipping 85 matching lines @@
 
 
     /**
      * Set an integer attribute on this DecimalFormat.
      * May return U_UNSUPPORTED_ERROR if this instance does not support
      * the specified attribute.
      * @param attr the attribute to set
      * @param newvalue new value
      * @param status the error type
      * @return *this - for chaining (example: format.setAttribute(...).setAttribute(...) )
-     * @draft ICU 51
+     * @stable ICU 51
      */
     virtual DecimalFormat& setAttribute( UNumberFormatAttribute attr,
                                        int32_t newvalue,
                                        UErrorCode &status);
 
     /**
      * Get an integer
      * May return U_UNSUPPORTED_ERROR if this instance does not support
      * the specified attribute.
      * @param attr the attribute to set
      * @param status the error type
      * @return the attribute value. Undefined if there is an error.
-     * @draft ICU 51
+     * @stable ICU 51
      */
     virtual int32_t getAttribute( UNumberFormatAttribute attr,
                                   UErrorCode &status) const;
 
+    
+    /**
+     * Set whether or not grouping will be used in this format.
+     * @param newValue    True, grouping will be used in this format.
+     * @see getGroupingUsed
+     * @draft ICU 53
+     */
+    virtual void setGroupingUsed(UBool newValue);
 
+    /**
+     * Sets whether or not numbers should be parsed as integers only.
+     * @param value    set True, this format will parse numbers as integers
+     *                 only.
+     * @see isParseIntegerOnly
+     * @draft ICU 53
+     */
+    virtual void setParseIntegerOnly(UBool value);
+
+    /* Cannot use #ifndef U_HIDE_DRAFT_API for the following draft method since it is virtual */
+    /**
+     * Set a particular UDisplayContext value in the formatter, such as
+     * UDISPCTX_CAPITALIZATION_FOR_STANDALONE.
+     * @param value The UDisplayContext value to set.
+     * @param status Input/output status. If at entry this indicates a failure
+     *               status, the function will do nothing; otherwise this will be
+     *               updated with any new status from the function. 
+     * @draft ICU 53
+     */
+    virtual void setContext(UDisplayContext value, UErrorCode& status);
 
     /**
      * Create a DecimalFormat from the given pattern and symbols.
      * Use this constructor when you need to completely customize the
      * behavior of the format.
      * <P>
      * To obtain standard formats for a given
      * locale, use the factory methods on NumberFormat such as
      * createInstance or createCurrencyInstance. If you need only minor adjustments
      * to a standard format, you can modify the format returned by
@@ skipping 241 matching lines @@
      * @return          Reference to 'appendTo' parameter.
      * @stable 4.4
      */
     virtual UnicodeString& format(const StringPiece &number,
                                   UnicodeString& appendTo,
                                   FieldPositionIterator* posIter,
                                   UErrorCode& status) const;
 
 
     /**
-     * Format a decimal number. 
+     * Format a decimal number.
      * The number is a DigitList wrapper onto a floating point decimal number.
      * The default implementation in NumberFormat converts the decimal number
      * to a double and formats that.
      *
      * @param number    The number, a DigitList format Decimal Floating Point.
      * @param appendTo  Output parameter to receive result.
      *                  Result is appended to existing contents.
      * @param posIter   On return, can be used to iterate over positions
      *                  of fields generated by this format call.
      * @param status    Output param filled with success/failure status.
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
     virtual UnicodeString& format(const DigitList &number,
                                   UnicodeString& appendTo,
                                   FieldPositionIterator* posIter,
                                   UErrorCode& status) const;
 
     /**
-     * Format a decimal number. 
+     * Format a decimal number.
      * The number is a DigitList wrapper onto a floating point decimal number.
      * The default implementation in NumberFormat converts the decimal number
-     * to a double and formats that.  
+     * to a double and formats that.
      *
      * @param number    The number, a DigitList format Decimal Floating Point.
      * @param appendTo  Output parameter to receive result.
      *                  Result is appended to existing contents.
      * @param pos       On input: an alignment field, if desired.
      *                  On output: the offsets of the alignment field.
      * @param status    Output param filled with success/failure status.
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
@@ skipping 228 matching lines @@
      * Get the rounding mode.
      * @return A rounding mode
      * @see #setRoundingIncrement
      * @see #getRoundingIncrement
      * @see #setRoundingMode
      * @stable ICU 2.0
      */
     virtual ERoundingMode getRoundingMode(void) const;
 
     /**
-     * Set the rounding mode.  
+     * Set the rounding mode.
      * @param roundingMode A rounding mode
      * @see #setRoundingIncrement
      * @see #getRoundingIncrement
      * @see #getRoundingMode
      * @stable ICU 2.0
      */
     virtual void setRoundingMode(ERoundingMode roundingMode);
 
     /**
      * Get the width to which the output of format() is padded.
@@ skipping 245 matching lines @@
     /**
      * Allows you to set the behavior of the decimal separator with integers.
      * (The decimal separator will always appear with decimals.)
      *
      * @param newValue    set TRUE if the decimal separator will always appear with decimals.
      * Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
      * @stable ICU 2.0
      */
     virtual void setDecimalSeparatorAlwaysShown(UBool newValue);
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Allows you to get the parse behavior of the pattern decimal mark.
+     *
+     * @return    TRUE if input must contain a match to decimal mark in pattern
+     * @draft ICU 54
+     */
+    UBool isDecimalPatternMatchRequired(void) const;
+#endif  /* U_HIDE_DRAFT_API */
+
+    /**
+     * Allows you to set the behavior of the pattern decimal mark.
+     * 
+     * if TRUE, the input must have a decimal mark if one was specified in the pattern. When
+     * FALSE the decimal mark may be omitted from the input.
+     *
+     * @param newValue    set TRUE if input must contain a match to decimal mark in pattern
+     * @draft ICU 54
+     */
+    virtual void setDecimalPatternMatchRequired(UBool newValue);
+
+
     /**
      * Synthesizes a pattern string that represents the current state
      * of this Format object.
      *
      * @param result    Output param which will receive the pattern.
      *                  Previous contents are deleted.
      * @return          A reference to 'result'.
      * @see applyPattern
      * @stable ICU 2.0
      */
@@ skipping 221 matching lines @@
      */
     virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec);
 
     /**
      * Sets the currency used to display currency amounts.  See
      * setCurrency(const UChar*, UErrorCode&).
      * @deprecated ICU 3.0. Use setCurrency(const UChar*, UErrorCode&).
      */
     virtual void setCurrency(const UChar* theCurrency);
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Sets the <tt>Currency Context</tt> object used to display currency.
+     * This takes effect immediately, if this format is a
+     * currency format.  
+     * @param currencyContext new currency context object to use.  
+     * @draft ICU 54
+     */
+    void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec);
+
+    /**
+     * Returns the <tt>Currency Context</tt> object used to display currency
+     * @draft ICU 54
+     */
+    UCurrencyUsage getCurrencyUsage() const;
+#endif  /* U_HIDE_DRAFT_API */
+
+
+#ifndef U_HIDE_DEPRECATED_API
     /**
      * The resource tags we use to retrieve decimal format data from
      * locale resource bundles.
      * @deprecated ICU 3.4. This string has no public purpose. Please don't use it.
      */
     static const char fgNumberPatterns[];
+#endif  /* U_HIDE_DEPRECATED_API */
 
 #ifndef U_HIDE_INTERNAL_API
     /**
      *  Get a FixedDecimal corresponding to a double as it would be
      *  formatted by this DecimalFormat.
      *  Internal, not intended for public use.
      *  @internal
      */
      FixedDecimal getFixedDecimal(double number, UErrorCode &status) const;
 
@@ skipping 118 matching lines @@
      * @param appendTo       Output parameter to receive result.
      *                       Result is appended to existing contents.
      * @param handler        Records information about field positions.
      * @param digits         the digits to be formatted.
      * @param isInteger      if TRUE format the digits as Integer.
      * @return               Reference to 'appendTo' parameter.
      */
     UnicodeString& subformat(UnicodeString& appendTo,
                              FieldPositionHandler& handler,
                              DigitList&     digits,
-                             UBool          isInteger, 
+                             UBool          isInteger,
                              UErrorCode &status) const;
 
 
     void parse(const UnicodeString& text,
                Formattable& result,
                ParsePosition& pos,
                UChar* currency) const;
 
     enum {
         fgStatusInfinite,
@@ skipping 128 matching lines @@
     void setupCurrencyAffixPatterns(UErrorCode& status);
 
     // set up the currency affixes used in currency plural formatting.
     // It sets up both fAffixesForCurrency for currency pattern if the current
     // pattern contains 3 currency signs,
     // and it sets up fPluralAffixesForCurrency for currency plural patterns.
     void setupCurrencyAffixes(const UnicodeString& pattern,
                               UBool setupForCurrentPattern,
                               UBool setupForPluralPattern,
                               UErrorCode& status);
+        
+    // get the currency rounding with respect to currency usage
+    double getCurrencyRounding(const UChar* currency,
+                               UErrorCode* ec) const;
+        
+    // get the currency fraction with respect to currency usage
+    int getCurrencyFractionDigits(const UChar* currency,
+                                  UErrorCode* ec) const;
 
     // hashtable operations
     Hashtable* initHashForAffixPattern(UErrorCode& status);
     Hashtable* initHashForAffix(UErrorCode& status);
 
     void deleteHashForAffixPattern();
     void deleteHashForAffix(Hashtable*& table);
 
     void copyHashForAffixPattern(const Hashtable* source,
                                  Hashtable* target, UErrorCode& status);
     void copyHashForAffix(const Hashtable* source,
                           Hashtable* target, UErrorCode& status);
 
     UnicodeString& _format(int64_t number,
                            UnicodeString& appendTo,
                            FieldPositionHandler& handler,
                            UErrorCode &status) const;
     UnicodeString& _format(double number,
                            UnicodeString& appendTo,
                            FieldPositionHandler& handler,
                            UErrorCode &status) const;
     UnicodeString& _format(const DigitList &number,
                            UnicodeString& appendTo,
                            FieldPositionHandler& handler,
                            UErrorCode &status) const;
 
-    // currency sign count
-    enum {
-        fgCurrencySignCountZero,
-        fgCurrencySignCountInSymbolFormat,
-        fgCurrencySignCountInISOFormat,
-        fgCurrencySignCountInPluralFormat
-    } CurrencySignCount;
-
     /**
      * Constants.
      */
 
     UnicodeString           fPositivePrefix;
     UnicodeString           fPositiveSuffix;
     UnicodeString           fNegativePrefix;
     UnicodeString           fNegativeSuffix;
     UnicodeString*          fPosPrefixPattern;
     UnicodeString*          fPosSuffixPattern;
     UnicodeString*          fNegPrefixPattern;
     UnicodeString*          fNegSuffixPattern;
 
     /**
      * Formatter for ChoiceFormat-based currency names.  If this field
      * is not null, then delegate to it to format currency symbols.
      * @since ICU 2.6
      */
     ChoiceFormat*           fCurrencyChoice;
 
     DigitList *             fMultiplier;   // NULL for multiplier of one
-    int32_t                 fScale;        
+    int32_t                 fScale;
     int32_t                 fGroupingSize;
     int32_t                 fGroupingSize2;
     UBool                   fDecimalSeparatorAlwaysShown;
     DecimalFormatSymbols*   fSymbols;
 
     UBool                   fUseSignificantDigits;
     int32_t                 fMinSignificantDigits;
     int32_t                 fMaxSignificantDigits;
 
     UBool                   fUseExponentialNotation;
     int8_t                  fMinExponentDigits;
     UBool                   fExponentSignAlwaysShown;
 
     EnumSet<UNumberFormatAttribute,
-            UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1, 
-            UNUM_LIMIT_BOOLEAN_ATTRIBUTE>  
+            UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
+            UNUM_LIMIT_BOOLEAN_ATTRIBUTE>
                             fBoolFlags;
 
     DigitList*              fRoundingIncrement;  // NULL if no rounding increment specified.
     ERoundingMode           fRoundingMode;
 
     UChar32                 fPad;
     int32_t                 fFormatWidth;
     EPadPosition            fPadPosition;
 
     /*
@@ skipping 106 matching lines @@
 
     // Information needed for DecimalFormat to format/parse currency plural.
     CurrencyPluralInfo* fCurrencyPluralInfo;
 
 #if UCONFIG_HAVE_PARSEALLINPUT
     UNumberFormatAttributeValue fParseAllInput;
 #endif
 
     // Decimal Format Static Sets singleton.
     const DecimalFormatStaticSets *fStaticSets;
-
+        
+    // Currency Usage(STANDARD vs CASH)
+    UCurrencyUsage fCurrencyUsage;
 
 protected:
 
 #ifndef U_HIDE_INTERNAL_API
     /**
      * Rounds a value according to the rules of this object.
      * @internal
      */
     DigitList& _round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const;
 #endif  /* U_HIDE_INTERNAL_API */
@@ skipping 25 matching lines @@
      * this number, it wouldn't make sense anyway, and this is just to make sure
      * that someone turning on scientific mode with default settings doesn't
      * end up with lots of zeroes.
      * @stable ICU 2.8
      */
     static const int32_t  kMaxScientificIntegerDigits;
 
 #if UCONFIG_FORMAT_FASTPATHS_49
  private:
     /**
-     * Internal state. 
+     * Internal state.
      * @internal
      */
     uint8_t fReserved[UNUM_DECIMALFORMAT_INTERNAL_SIZE];
 
 
     /**
      * Called whenever any state changes. Recomputes whether fastpath is OK to use.
      */
     void handleChanged();
 #endif
 };
 
 inline const UnicodeString &
 DecimalFormat::getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol symbol) const {
     return fSymbols->getConstSymbol(symbol);
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 #endif // _DECIMFMT
 //eof