pango 3.2.7-x64-mingw32 → 3.2.8-x64-mingw32

data/vendor/local/include/unicode/currunit.h

@@ -44,8 +44,9 @@ class U_I18N_API CurrencyUnit: public MeasureUnit {
 
     /**
      * Construct an object with the given ISO currency code.
-     * @param isoCode the 3-letter ISO 4217 currency code; must not be
-     * NULL and must have length 3
+     * @param isoCode the 3-letter ISO 4217 currency code; must have
+     * length 3 and need not be NUL-terminated. If NULL, the currency
+     * is initialized to the unknown currency XXX.
      * @param ec input-output error code. If the isoCode is invalid,
      * then this will be set to a failing value.
      * @stable ICU 3.0

data/vendor/local/include/unicode/dcfmtsym.h

@@ -406,9 +406,12 @@ public:
      * returning a const reference to one of the symbol strings.
      * The returned reference becomes invalid when the symbol is changed
      * or when the DecimalFormatSymbols are destroyed.
-     * ### TODO markus 2002oct11: Consider proposing getConstSymbol() to be really public.
      * Note: moved #ifndef U_HIDE_INTERNAL_API after this, since this is needed for inline in DecimalFormat
      *
+     * This is not currently stable API, but if you think it should be stable,
+     * post a comment on the following ticket and the ICU team will take a look:
+     * http://bugs.icu-project.org/trac/ticket/13580
+     *
      * @param symbol Constant to indicate a number format symbol.
      * @return the format symbol by the param 'symbol'
      * @internal
@@ -422,6 +425,10 @@ public:
      * to accessing the symbol from getConstSymbol with the corresponding
      * key, such as kZeroDigitSymbol or kOneDigitSymbol.
      *
+     * This is not currently stable API, but if you think it should be stable,
+     * post a comment on the following ticket and the ICU team will take a look:
+     * http://bugs.icu-project.org/trac/ticket/13580
+     *
      * @param digit The digit, an integer between 0 and 9 inclusive.
      *              If outside the range 0 to 9, the zero digit is returned.
      * @return the format symbol for the given digit.

data/vendor/local/include/unicode/decimfmt.h

@@ -43,28 +43,25 @@
 #include "unicode/curramt.h"
 #include "unicode/enumset.h"
 
-#ifndef U_HIDE_INTERNAL_API
-/**
- * \def UNUM_DECIMALFORMAT_INTERNAL_SIZE
- * @internal
- */
-#if UCONFIG_FORMAT_FASTPATHS_49
-#define UNUM_DECIMALFORMAT_INTERNAL_SIZE 16
-#endif
-#endif  /* U_HIDE_INTERNAL_API */
-
 U_NAMESPACE_BEGIN
 
-class DigitList;
 class CurrencyPluralInfo;
-class Hashtable;
-class UnicodeSet;
-class FieldPositionHandler;
-class DecimalFormatStaticSets;
-class FixedDecimal;
-class DecimalFormatImpl;
-class PluralRules;
-class VisibleDigitsWithExponent;
+class CompactDecimalFormat;
+
+namespace number {
+class LocalizedNumberFormatter;
+class FormattedNumber;
+namespace impl {
+class DecimalQuantity;
+struct DecimalFormatFields;
+}
+}
+
+namespace numparse {
+namespace impl {
+class NumberParserImpl;
+}
+}
 
 // explicit template instantiation. see digitlst.h
 // (When building DLLs for Windows this is required.)
@@ -672,17 +669,14 @@ template class U_I18N_API    EnumSet<UNumberFormatAttribute,
  * subclasses, such code will not necessarily work and will not be
  * guaranteed to work stably from release to release.
  */
-class U_I18N_API DecimalFormat: public NumberFormat {
-public:
+class U_I18N_API DecimalFormat : public NumberFormat {
+  public:
     /**
      * Pad position.
      * @stable ICU 2.4
      */
     enum EPadPosition {
-        kPadBeforePrefix,
-        kPadAfterPrefix,
-        kPadBeforeSuffix,
-        kPadAfterSuffix
+        kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, kPadAfterSuffix
     };
 
     /**
@@ -720,8 +714,7 @@ public:
      *                  pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(const UnicodeString& pattern,
-                  UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, UErrorCode& status);
 
     /**
      * Create a DecimalFormat from the given pattern and symbols.
@@ -744,11 +737,10 @@ public:
      *                          pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    DecimalFormatSymbols* symbolsToAdopt,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
 
 #ifndef U_HIDE_INTERNAL_API
+
     /**
      * This API is for ICU use only.
      * Create a DecimalFormat from the given pattern, symbols, and style.
@@ -761,20 +753,29 @@ public:
      *                          pattern is invalid this will be set to a failure code.
      * @internal
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    DecimalFormatSymbols* symbolsToAdopt,
-                    UNumberFormatStyle style,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
+                  UNumberFormatStyle style, UErrorCode& status);
 
 #if UCONFIG_HAVE_PARSEALLINPUT
+
     /**
      * @internal
      */
     void setParseAllInput(UNumberFormatAttributeValue value);
+
 #endif
 
 #endif  /* U_HIDE_INTERNAL_API */
 
+  private:
+
+    /**
+     * Internal constructor for DecimalFormat; sets up internal fields. All public constructors should
+     * call this constructor.
+     */
+    DecimalFormat(const DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
+
+  public:
 
     /**
      * Set an integer attribute on this DecimalFormat.
@@ -786,9 +787,7 @@ public:
      * @return *this - for chaining (example: format.setAttribute(...).setAttribute(...) )
      * @stable ICU 51
      */
-    virtual DecimalFormat& setAttribute( UNumberFormatAttribute attr,
-                                       int32_t newvalue,
-                                       UErrorCode &status);
+    virtual DecimalFormat& setAttribute(UNumberFormatAttribute attr, int32_t newValue, UErrorCode& status);
 
     /**
      * Get an integer
@@ -799,8 +798,7 @@ public:
      * @return the attribute value. Undefined if there is an error.
      * @stable ICU 51
      */
-    virtual int32_t getAttribute( UNumberFormatAttribute attr,
-                                  UErrorCode &status) const;
+    virtual int32_t getAttribute(UNumberFormatAttribute attr, UErrorCode& status) const;
 
 
     /**
@@ -809,7 +807,7 @@ public:
      * @see getGroupingUsed
      * @stable ICU 53
      */
-    virtual void setGroupingUsed(UBool newValue);
+    void setGroupingUsed(UBool newValue) U_OVERRIDE;
 
     /**
      * Sets whether or not numbers should be parsed as integers only.
@@ -818,18 +816,16 @@ public:
      * @see isParseIntegerOnly
      * @stable ICU 53
      */
-    virtual void setParseIntegerOnly(UBool value);
+    void setParseIntegerOnly(UBool value) U_OVERRIDE;
 
     /**
-     * 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.
-     * @stable ICU 53
+     * Sets whether lenient parsing should be enabled (it is off by default).
+     *
+     * @param enable \c TRUE if lenient parsing should be used,
+     *               \c FALSE otherwise.
+     * @stable ICU 4.8
      */
-    virtual void setContext(UDisplayContext value, UErrorCode& status);
+    void setLenient(UBool enable) U_OVERRIDE;
 
     /**
      * Create a DecimalFormat from the given pattern and symbols.
@@ -853,10 +849,9 @@ public:
      *                          pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    DecimalFormatSymbols* symbolsToAdopt,
-                    UParseError& parseError,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
+                  UParseError& parseError, UErrorCode& status);
+
     /**
      * Create a DecimalFormat from the given pattern and symbols.
      * Use this constructor when you need to completely customize the
@@ -877,9 +872,7 @@ public:
      *                          pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    const DecimalFormatSymbols& symbols,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status);
 
     /**
      * Copy constructor.
@@ -901,7 +894,7 @@ public:
      * Destructor.
      * @stable ICU 2.0
      */
-    virtual ~DecimalFormat();
+    ~DecimalFormat() U_OVERRIDE;
 
     /**
      * Clone this Format object polymorphically. The caller owns the
@@ -910,7 +903,7 @@ public:
      * @return    a polymorphic copy of this DecimalFormat.
      * @stable ICU 2.0
      */
-    virtual Format* clone(void) const;
+    Format* clone(void) const U_OVERRIDE;
 
     /**
      * Return true if the given Format objects are semantically equal.
@@ -920,7 +913,7 @@ public:
      * @return         true if the given Format objects are semantically equal.
      * @stable ICU 2.0
      */
-    virtual UBool operator==(const Format& other) const;
+    UBool operator==(const Format& other) const U_OVERRIDE;
 
 
     using NumberFormat::format;
@@ -936,11 +929,9 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 2.0
      */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
-
+    UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
     /**
      * Format a double or long number using base-10 representation.
      *
@@ -953,10 +944,9 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
+    UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos,
+                          UErrorCode& status) const U_OVERRIDE;
+#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Format a double or long number using base-10 representation.
@@ -971,10 +961,8 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format a long number using base-10 representation.
@@ -987,10 +975,9 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 2.0
      */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
+    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
     /**
      * Format a long number using base-10 representation.
      *
@@ -1002,10 +989,9 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
+    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos,
+                          UErrorCode& status) const U_OVERRIDE;
+#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Format a long number using base-10 representation.
@@ -1020,10 +1006,8 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format an int64 number using base-10 representation.
@@ -1036,10 +1020,9 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 2.8
      */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
+    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
     /**
      * Format an int64 number using base-10 representation.
      *
@@ -1051,10 +1034,9 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
+    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos,
+                          UErrorCode& status) const U_OVERRIDE;
+#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Format an int64 number using base-10 representation.
@@ -1069,10 +1051,8 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format a decimal number.
@@ -1090,19 +1070,18 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(StringPiece number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(StringPiece number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
 
     /**
      * Format a decimal number.
-     * The number is a DigitList wrapper onto a floating point decimal number.
+     * The number is a DecimalQuantity 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 number    The number, a DecimalQuantity 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
@@ -1111,14 +1090,16 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(const DigitList &number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
+                          FieldPositionIterator* posIter, UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format a decimal number.
-     * @param number    The number
+     * The number is a DecimalQuantity 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 DecimalQuantity 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.
@@ -1127,73 +1108,34 @@ public:
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(
-            const VisibleDigitsWithExponent &number,
-            UnicodeString& appendTo,
-            FieldPosition& pos,
-            UErrorCode& status) const;
+    UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
+                          FieldPosition& pos, UErrorCode& status) const U_OVERRIDE;
 
-    /**
-     * Format a decimal number.
-     * @param number    The number
-     * @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 VisibleDigitsWithExponent &number,
-            UnicodeString& appendTo,
-            FieldPositionIterator* posIter,
-            UErrorCode& status) const;
+#endif // U_HIDE_INTERNAL_API
+
+    using NumberFormat::parse;
 
     /**
-     * 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.
+     * Parse the given string using this object's choices. The method
+     * does string comparisons to try to find an optimal match.
+     * If no object can be parsed, index is unchanged, and NULL is
+     * returned.  The result is returned as the most parsimonious
+     * type of Formattable that will accomodate all of the
+     * necessary precision.  For example, if the result is exactly 12,
+     * it will be returned as a long.  However, if it is 1.5, it will
+     * be returned as a double.
      *
-     * @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
+     * @param text           The text to be parsed.
+     * @param result         Formattable to be set to the parse result.
+     *                       If parse fails, return contents are undefined.
+     * @param parsePosition  The position to start parsing at on input.
+     *                       On output, moved to after the last successfully
+     *                       parse character. On parse failure, does not change.
+     * @see Formattable
+     * @stable ICU 2.0
      */
-    virtual UnicodeString& format(const DigitList &number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode& status) const;
-
-   using NumberFormat::parse;
-
-   /**
-    * Parse the given string using this object's choices. The method
-    * does string comparisons to try to find an optimal match.
-    * If no object can be parsed, index is unchanged, and NULL is
-    * returned.  The result is returned as the most parsimonious
-    * type of Formattable that will accomodate all of the
-    * necessary precision.  For example, if the result is exactly 12,
-    * it will be returned as a long.  However, if it is 1.5, it will
-    * be returned as a double.
-    *
-    * @param text           The text to be parsed.
-    * @param result         Formattable to be set to the parse result.
-    *                       If parse fails, return contents are undefined.
-    * @param parsePosition  The position to start parsing at on input.
-    *                       On output, moved to after the last successfully
-    *                       parse character. On parse failure, does not change.
-    * @see Formattable
-    * @stable ICU 2.0
-    */
-    virtual void parse(const UnicodeString& text,
-                       Formattable& result,
-                       ParsePosition& parsePosition) const;
+    void parse(const UnicodeString& text, Formattable& result,
+               ParsePosition& parsePosition) const U_OVERRIDE;
 
     /**
      * Parses text from the given string as a currency amount.  Unlike
@@ -1214,8 +1156,7 @@ public:
      *             the parsed currency; if parse fails, this is NULL.
      * @stable ICU 49
      */
-    virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
-                                          ParsePosition& pos) const;
+    CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE;
 
     /**
      * Returns the decimal format symbols, which is generally not changed
@@ -1344,12 +1285,29 @@ public:
      */
     virtual void setNegativeSuffix(const UnicodeString& newValue);
 
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * Whether to show the plus sign on positive (non-negative) numbers; for example, "+12"
+     * @internal Technical Preview
+     */
+    UBool isSignAlwaysShown() const;
+#endif  /* U_HIDE_INTERNAL_API */
+
+    /**
+     * Set whether to show the plus sign on positive (non-negative) numbers; for example, "+12"
+     * @param value The new setting for whether to show plus sign on positive numbers
+     * @internal Technical Preview
+     */
+    virtual void setSignAlwaysShown(UBool value);
+
     /**
      * Get the multiplier for use in percent, permill, etc.
      * For a percentage, set the suffixes to have "%" and the multiplier to be 100.
      * (For Arabic, use arabic percent symbol).
      * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000.
      *
+     * The number may also be multiplied by a power of ten; see getMultiplierScale().
+     *
      * @return    the multiplier for use in percent, permill, etc.
      * Examples: with 100, 1.23 -> "123", and "123" -> 1.23
      * @stable ICU 2.0
@@ -1362,12 +1320,52 @@ public:
      * (For Arabic, use arabic percent symbol).
      * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000.
      *
+     * This method only supports integer multipliers. To multiply by a non-integer, pair this
+     * method with setMultiplierScale().
+     *
      * @param newValue    the new value of the multiplier for use in percent, permill, etc.
      * Examples: with 100, 1.23 -> "123", and "123" -> 1.23
      * @stable ICU 2.0
      */
     virtual void setMultiplier(int32_t newValue);
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Gets the power of ten by which number should be multiplied before formatting, which
+     * can be combined with setMultiplier() to multiply by any arbitrary decimal value.
+     *
+     * A multiplier scale of 2 corresponds to multiplication by 100, and a multiplier scale
+     * of -2 corresponds to multiplication by 0.01.
+     *
+     * This method is analogous to UNUM_SCALE in getAttribute.
+     *
+     * @return    the current value of the power-of-ten multiplier.
+     * @draft ICU 62
+     */
+    int32_t getMultiplierScale(void) const;
+#endif  /* U_HIDE_DRAFT_API */
+
+    /**
+     * Sets a power of ten by which number should be multiplied before formatting, which
+     * can be combined with setMultiplier() to multiply by any arbitrary decimal value.
+     *
+     * A multiplier scale of 2 corresponds to multiplication by 100, and a multiplier scale
+     * of -2 corresponds to multiplication by 0.01.
+     *
+     * For example, to multiply numbers by 0.5 before formatting, you can do:
+     *
+     * <pre>
+     * df.setMultiplier(5);
+     * df.setMultiplierScale(-1);
+     * </pre>
+     *
+     * This method is analogous to UNUM_SCALE in setAttribute.
+     *
+     * @param newValue    the new value of the power-of-ten multiplier.
+     * @draft ICU 62
+     */
+    virtual void setMultiplierScale(int32_t newValue);
+
     /**
      * Get the rounding increment.
      * @return A positive rounding increment, or 0.0 if a custom rounding
@@ -1400,7 +1398,7 @@ public:
      * @see #setRoundingMode
      * @stable ICU 2.0
      */
-    virtual ERoundingMode getRoundingMode(void) const;
+    virtual ERoundingMode getRoundingMode(void) const U_OVERRIDE;
 
     /**
      * Set the rounding mode.
@@ -1410,7 +1408,7 @@ public:
      * @see #getRoundingMode
      * @stable ICU 2.0
      */
-    virtual void setRoundingMode(ERoundingMode roundingMode);
+    virtual void setRoundingMode(ERoundingMode roundingMode) U_OVERRIDE;
 
     /**
      * Get the width to which the output of format() is padded.
@@ -1469,7 +1467,7 @@ public:
      * @see #setPadPosition
      * @stable ICU 2.0
      */
-    virtual void setPadCharacter(const UnicodeString &padChar);
+    virtual void setPadCharacter(const UnicodeString& padChar);
 
     /**
      * Get the position at which padding will take place.  This is the location
@@ -1676,7 +1674,7 @@ public:
 
 #endif  /* U_HIDE_INTERNAL_API */
 
-	/* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual. */
+    /* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual. */
     /**
      * Sets the minimum grouping digits. Setting to a value less than or
      * equal to 1 turns off minimum grouping digits.
@@ -1717,7 +1715,7 @@ public:
     UBool isDecimalPatternMatchRequired(void) const;
 
     /**
-     * Allows you to set the behavior of the pattern decimal mark.
+     * Allows you to set the parse 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.
@@ -1727,6 +1725,60 @@ public:
      */
     virtual void setDecimalPatternMatchRequired(UBool newValue);
 
+    /**
+     * {@icu} Returns whether to ignore exponents when parsing.
+     *
+     * @see #setParseNoExponent
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual UBool isParseNoExponent() const;
+
+    /**
+     * {@icu} Specifies whether to stop parsing when an exponent separator is encountered. For
+     * example, parses "123E4" to 123 (with parse position 3) instead of 1230000 (with parse position
+     * 5).
+     *
+     * @param value true to prevent exponents from being parsed; false to allow them to be parsed.
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual void setParseNoExponent(UBool value);
+
+    /**
+     * {@icu} Returns whether parsing is sensitive to case (lowercase/uppercase).
+     *
+     * @see #setParseCaseSensitive
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual UBool isParseCaseSensitive() const;
+
+    /**
+     * {@icu} Whether to pay attention to case when parsing; default is to ignore case (perform
+     * case-folding). For example, "A" == "a" in case-insensitive but not case-sensitive mode.
+     *
+     * Currency symbols are never case-folded. For example, "us$1.00" will not parse in case-insensitive
+     * mode, even though "US$1.00" parses.
+     *
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual void setParseCaseSensitive(UBool value);
+
+    /**
+     * {@icu} Returns whether truncation of high-order integer digits should result in an error.
+     * By default, setMaximumIntegerDigits truncates high-order digits silently.
+     *
+     * @see setFormatFailIfMoreThanMaxDigits
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual UBool isFormatFailIfMoreThanMaxDigits() const;
+
+    /**
+     * {@icu} Sets whether truncation of high-order integer digits should result in an error.
+     * By default, setMaximumIntegerDigits truncates high-order digits silently.
+     *
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual void setFormatFailIfMoreThanMaxDigits(UBool value);
+
 
     /**
      * Synthesizes a pattern string that represents the current state
@@ -1781,9 +1833,8 @@ public:
      *                   set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyPattern(const UnicodeString& pattern,
-                             UParseError& parseError,
-                             UErrorCode& status);
+    virtual void applyPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status);
+
     /**
      * Sets the pattern.
      * @param pattern   The pattern to be applied.
@@ -1792,8 +1843,7 @@ public:
      *                  set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyPattern(const UnicodeString& pattern,
-                             UErrorCode& status);
+    virtual void applyPattern(const UnicodeString& pattern, UErrorCode& status);
 
     /**
      * Apply the given pattern to this Format object.  The pattern
@@ -1825,8 +1875,7 @@ public:
      *                  set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyLocalizedPattern(const UnicodeString& pattern,
-                                       UParseError& parseError,
+    virtual void applyLocalizedPattern(const UnicodeString& pattern, UParseError& parseError,
                                        UErrorCode& status);
 
     /**
@@ -1838,8 +1887,7 @@ public:
      *                  set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyLocalizedPattern(const UnicodeString& pattern,
-                                       UErrorCode& status);
+    virtual void applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status);
 
 
     /**
@@ -1851,7 +1899,7 @@ public:
      * @see NumberFormat#setMaximumIntegerDigits
      * @stable ICU 2.0
      */
-    virtual void setMaximumIntegerDigits(int32_t newValue);
+    void setMaximumIntegerDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Sets the minimum number of digits allowed in the integer portion of a
@@ -1862,7 +1910,7 @@ public:
      * @see NumberFormat#setMinimumIntegerDigits
      * @stable ICU 2.0
      */
-    virtual void setMinimumIntegerDigits(int32_t newValue);
+    void setMinimumIntegerDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Sets the maximum number of digits allowed in the fraction portion of a
@@ -1873,7 +1921,7 @@ public:
      * @see NumberFormat#setMaximumFractionDigits
      * @stable ICU 2.0
      */
-    virtual void setMaximumFractionDigits(int32_t newValue);
+    void setMaximumFractionDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Sets the minimum number of digits allowed in the fraction portion of a
@@ -1884,7 +1932,7 @@ public:
      * @see NumberFormat#setMinimumFractionDigits
      * @stable ICU 2.0
      */
-    virtual void setMinimumFractionDigits(int32_t newValue);
+    void setMinimumFractionDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Returns the minimum number of significant digits that will be
@@ -1947,7 +1995,6 @@ public:
      */
     void setSignificantDigitsUsed(UBool useSignificantDigits);
 
- public:
     /**
      * Sets the currency used to display currency
      * amounts.  This takes effect immediately, if this format is a
@@ -1960,7 +2007,7 @@ public:
      * @param ec input-output error code
      * @stable ICU 3.0
      */
-    virtual void setCurrency(const char16_t* theCurrency, UErrorCode& ec);
+    void setCurrency(const char16_t* theCurrency, UErrorCode& ec) U_OVERRIDE;
 
     /**
      * Sets the currency used to display currency amounts.  See
@@ -1984,78 +2031,53 @@ public:
      */
     UCurrencyUsage getCurrencyUsage() const;
 
-
-#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;
-
-    /**
-     *  Get a FixedDecimal corresponding to a formattable as it would be
-     *  formatted by this DecimalFormat.
-     *  Internal, not intended for public use.
-     *  @internal
-     */
-     FixedDecimal getFixedDecimal(const Formattable &number, UErrorCode &status) const;
 
     /**
-     *  Get a FixedDecimal corresponding to a DigitList as it would be
-     *  formatted by this DecimalFormat. Note: the DigitList may be modified.
+     *  Format a number and save it into the given DecimalQuantity.
      *  Internal, not intended for public use.
      *  @internal
      */
-     FixedDecimal getFixedDecimal(DigitList &number, UErrorCode &status) const;
+    void formatToDecimalQuantity(double number, number::impl::DecimalQuantity& output,
+                                 UErrorCode& status) const;
 
     /**
-     *  Get a VisibleDigitsWithExponent corresponding to a double
-     *  as it would be formatted by this DecimalFormat.
+     *  Get a DecimalQuantity corresponding to a formattable as it would be
+     *  formatted by this DecimalFormat.
      *  Internal, not intended for public use.
      *  @internal
      */
-     VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-             double number,
-             VisibleDigitsWithExponent &digits,
-             UErrorCode &status) const;
+    void formatToDecimalQuantity(const Formattable& number, number::impl::DecimalQuantity& output,
+                                 UErrorCode& status) const;
 
-    /**
-     *  Get a VisibleDigitsWithExponent corresponding to a formattable
-     *  as it would be formatted by this DecimalFormat.
-     *  Internal, not intended for public use.
-     *  @internal
-     */
-     VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-             const Formattable &number,
-             VisibleDigitsWithExponent &digits,
-             UErrorCode &status) const;
+#endif
 
+#ifndef U_HIDE_DRAFT_API
     /**
-     *  Get a VisibleDigitsWithExponent corresponding to a DigitList
-     *  as it would be formatted by this DecimalFormat.
-     *  Note: the DigitList may be modified.
-     *  Internal, not intended for public use.
-     *  @internal
+     * Converts this DecimalFormat to a NumberFormatter.  Starting in ICU 60,
+     * NumberFormatter is the recommended way to format numbers.
+     *
+     * NOTE: The returned LocalizedNumberFormatter is owned by this DecimalFormat.
+     * If a non-const method is called on the DecimalFormat, or if the DecimalFormat
+     * is deleted, the object becomes invalid. If you plan to keep the return value
+     * beyond the lifetime of the DecimalFormat, copy it to a local variable:
+     *
+     * <pre>
+     * LocalizedNumberFormatter f = df->toNumberFormatter();
+     * </pre>
+     *
+     * It is, however, safe to use the return value for chaining:
+     *
+     * <pre>
+     * FormattedNumber result = df->toNumberFormatter().formatDouble(123, status);
+     * </pre>
+     *
+     * @param output The variable into which to store the LocalizedNumberFormatter.
+     * @return The output variable, for chaining.
+     * @draft ICU 62
      */
-     VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-             DigitList &number,
-             VisibleDigitsWithExponent &digits,
-             UErrorCode &status) const;
-
-#endif  /* U_HIDE_INTERNAL_API */
-
-public:
+    const number::LocalizedNumberFormatter& toNumberFormatter() const;
+#endif  /* U_HIDE_DRAFT_API */
 
     /**
      * Return the class ID for this class.  This is useful only for
@@ -2081,217 +2103,57 @@ public:
      *                  other classes have different class IDs.
      * @stable ICU 2.0
      */
-    virtual UClassID getDynamicClassID(void) const;
-
-private:
-
-    DecimalFormat(); // default constructor not implemented
-
-    /**
-     *   Initialize all fields of a new DecimalFormatter to a safe default value.
-     *      Common code for use by constructors.
-     */
-    void init();
-
-    /**
-     * Do real work of constructing a new DecimalFormat.
-     */
-    void construct(UErrorCode&              status,
-                   UParseError&             parseErr,
-                   const UnicodeString*     pattern = 0,
-                   DecimalFormatSymbols*    symbolsToAdopt = 0
-                   );
-
-    void handleCurrencySignInPattern(UErrorCode& status);
-
-    void parse(const UnicodeString& text,
-               Formattable& result,
-               ParsePosition& pos,
-               char16_t* currency) const;
-
-    enum {
-        fgStatusInfinite,
-        fgStatusLength      // Leave last in list.
-    } StatusFlags;
-
-    UBool subparse(const UnicodeString& text,
-                   const UnicodeString* negPrefix,
-                   const UnicodeString* negSuffix,
-                   const UnicodeString* posPrefix,
-                   const UnicodeString* posSuffix,
-                   UBool complexCurrencyParsing,
-                   int8_t type,
-                   ParsePosition& parsePosition,
-                   DigitList& digits, UBool* status,
-                   char16_t* currency) const;
-
-    // Mixed style parsing for currency.
-    // It parses against the current currency pattern
-    // using complex affix comparison
-    // parses against the currency plural patterns using complex affix comparison,
-    // and parses against the current pattern using simple affix comparison.
-    UBool parseForCurrency(const UnicodeString& text,
-                           ParsePosition& parsePosition,
-                           DigitList& digits,
-                           UBool* status,
-                           char16_t* currency) const;
-
-    int32_t skipPadding(const UnicodeString& text, int32_t position) const;
-
-    int32_t compareAffix(const UnicodeString& input,
-                         int32_t pos,
-                         UBool isNegative,
-                         UBool isPrefix,
-                         const UnicodeString* affixPat,
-                         UBool complexCurrencyParsing,
-                         int8_t type,
-                         char16_t* currency) const;
-
-    static UnicodeString& trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix);
-
-    UBool equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const;
-
-    int32_t compareSimpleAffix(const UnicodeString& affix,
-                                      const UnicodeString& input,
-                                      int32_t pos,
-                                      UBool lenient) const;
-
-    static int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos);
-
-    static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos);
-
-    static int32_t skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos);
-
-    static int32_t skipBidiMarks(const UnicodeString& text, int32_t pos);
-
-    int32_t compareComplexAffix(const UnicodeString& affixPat,
-                                const UnicodeString& input,
-                                int32_t pos,
-                                int8_t type,
-                                char16_t* currency) const;
-
-    static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch);
+    UClassID getDynamicClassID(void) const U_OVERRIDE;
 
-    static int32_t match(const UnicodeString& text, int32_t pos, const UnicodeString& str);
+  private:
 
-    static UBool matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol,
-                             UnicodeSet *sset, UChar32 schar);
+    /** Rebuilds the formatter object from the property bag. */
+    void touch(UErrorCode& status);
 
-    static UBool matchDecimal(UChar32 symbolChar,
-                            UBool sawDecimal,  UChar32 sawDecimalChar,
-                             const UnicodeSet *sset, UChar32 schar);
-
-    static UBool matchGrouping(UChar32 groupingChar,
-                            UBool sawGrouping, UChar32 sawGroupingChar,
-                             const UnicodeSet *sset,
-                             UChar32 decimalChar, const UnicodeSet *decimalSet,
-                             UChar32 schar);
-
-    // set up currency affix patterns for mix parsing.
-    // The patterns saved here are the affix patterns of default currency
-    // pattern and the unique affix patterns of the plural currency patterns.
-    // Those patterns are used by parseForCurrency().
-    void setupCurrencyAffixPatterns(UErrorCode& status);
-
-    // get the currency rounding with respect to currency usage
-    double getCurrencyRounding(const char16_t* currency,
-                               UErrorCode* ec) const;
-
-    // get the currency fraction with respect to currency usage
-    int getCurrencyFractionDigits(const char16_t* currency,
-                                  UErrorCode* ec) const;
-
-    // hashtable operations
-    Hashtable* initHashForAffixPattern(UErrorCode& status);
-
-    void deleteHashForAffixPattern();
-
-    void copyHashForAffixPattern(const Hashtable* source,
-                                 Hashtable* target, UErrorCode& status);
-
-    DecimalFormatImpl *fImpl;
+    /** Rebuilds the formatter object, hiding the error code. */
+    void touchNoError();
 
     /**
-     * Constants.
+     * Updates the property bag with settings from the given pattern.
+     *
+     * @param pattern The pattern string to parse.
+     * @param ignoreRounding Whether to leave out rounding information (minFrac, maxFrac, and rounding
+     *     increment) when parsing the pattern. This may be desirable if a custom rounding mode, such
+     *     as CurrencyUsage, is to be used instead. One of {@link
+     *     PatternStringParser#IGNORE_ROUNDING_ALWAYS}, {@link PatternStringParser#IGNORE_ROUNDING_IF_CURRENCY},
+     *     or {@link PatternStringParser#IGNORE_ROUNDING_NEVER}.
+     * @see PatternAndPropertyUtils#parseToExistingProperties
      */
+    void setPropertiesFromPattern(const UnicodeString& pattern, int32_t ignoreRounding,
+                                  UErrorCode& status);
 
+    const numparse::impl::NumberParserImpl* getParser(UErrorCode& status) const;
 
-    EnumSet<UNumberFormatAttribute,
-            UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
-            UNUM_LIMIT_BOOLEAN_ATTRIBUTE>
-                            fBoolFlags;
+    const numparse::impl::NumberParserImpl* getCurrencyParser(UErrorCode& status) const;
 
+    static void fieldPositionHelper(const number::FormattedNumber& formatted, FieldPosition& fieldPosition,
+                                    int32_t offset, UErrorCode& status);
 
-    // style is only valid when decimal formatter is constructed by
-    // DecimalFormat(pattern, decimalFormatSymbol, style)
-    int fStyle;
+    static void fieldPositionIteratorHelper(const number::FormattedNumber& formatted,
+                                            FieldPositionIterator* fpi, int32_t offset, UErrorCode& status);
 
+    void setupFastFormat();
 
-    // Affix pattern set for currency.
-    // It is a set of AffixPatternsForCurrency,
-    // each element of the set saves the negative prefix pattern,
-    // negative suffix pattern, positive prefix pattern,
-    // and positive suffix  pattern of a pattern.
-    // It is used for currency mixed style parsing.
-    // It is actually is a set.
-    // The set contains the default currency pattern from the locale,
-    // and the currency plural patterns.
-    // Since it is a set, it does not contain duplicated items.
-    // For example, if 2 currency plural patterns are the same, only one pattern
-    // is included in the set. When parsing, we do not check whether the plural
-    // count match or not.
-    Hashtable* fAffixPatternsForCurrency;
+    bool fastFormatDouble(double input, UnicodeString& output) const;
 
-    // Information needed for DecimalFormat to format/parse currency plural.
-    CurrencyPluralInfo* fCurrencyPluralInfo;
+    bool fastFormatInt64(int64_t input, UnicodeString& output) const;
 
-#if UCONFIG_HAVE_PARSEALLINPUT
-    UNumberFormatAttributeValue fParseAllInput;
-#endif
+    void doFastFormatInt32(int32_t input, bool isNegative, UnicodeString& output) const;
 
-    // Decimal Format Static Sets singleton.
-    const DecimalFormatStaticSets *fStaticSets;
+    //=====================================================================================//
+    //                                   INSTANCE FIELDS                                   //
+    //=====================================================================================//
 
-protected:
+    // Only one instance field: keep all fields inside of an implementation class defined in number_mapper.h
+    number::impl::DecimalFormatFields* fields;
 
-#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 */
-
-    /**
-     * Returns the currency in effect for this formatter.  Subclasses
-     * should override this method as needed.  Unlike getCurrency(),
-     * this method should never return "".
-     * @result output parameter for null-terminated result, which must
-     * have a capacity of at least 4
-     * @internal
-     */
-    virtual void getEffectiveCurrency(char16_t* result, UErrorCode& ec) const;
-
-  /** number of integer digits
-   * @stable ICU 2.4
-   */
-    static const int32_t  kDoubleIntegerDigits;
-  /** number of fraction digits
-   * @stable ICU 2.4
-   */
-    static const int32_t  kDoubleFractionDigits;
-
-    /**
-     * When someone turns on scientific mode, we assume that more than this
-     * number of digits is due to flipping from some other mode that didn't
-     * restrict the maximum, and so we force 1 integer digit.  We don't bother
-     * to track and see if someone is using exponential notation with more than
-     * 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;
+    // Allow child class CompactDecimalFormat to access fProperties:
+    friend class CompactDecimalFormat;
 
 };