decimfmt.h

Go to the documentation of this file.

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
********************************************************************************
*   Copyright (C) 1997-2016, 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.
*   04/03/97    aliu        Rewrote parsing and formatting completely, and
*                           cleaned up and debugged.  Actually works now.
*   04/17/97    aliu        Changed DigitCount to int per code review.
*   07/10/97    helena      Made ParsePosition a class and get rid of the function
*                           hiding problems.
*   09/09/97    aliu        Ported over support for exponential formats.
*   07/20/98    stephen     Changed documentation
*   01/30/13    emmons      Added Scaling methods
********************************************************************************
*/
 
#ifndef DECIMFMT_H
#define DECIMFMT_H
 
#include "unicode/utypes.h"
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_FORMATTING
 
#include "unicode/dcfmtsym.h"
#include "unicode/numfmt.h"
#include "unicode/locid.h"
#include "unicode/fpositer.h"
#include "unicode/stringpiece.h"
#include "unicode/curramt.h"
#include "unicode/enumset.h"
 
U_NAMESPACE_BEGIN
 
class CurrencyPluralInfo;
class CompactDecimalFormat;
 
namespace number {
class LocalizedNumberFormatter;
class FormattedNumber;
namespace impl {
class DecimalQuantity;
struct DecimalFormatFields;
}
}
 
namespace numparse {
namespace impl {
class NumberParserImpl;
}
}
 
class U_I18N_API DecimalFormat : public NumberFormat {
  public:
    enum EPadPosition {
        kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, kPadAfterSuffix
    };
 
    DecimalFormat(UErrorCode& status);
 
    DecimalFormat(const UnicodeString& pattern, UErrorCode& status);
 
    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
 
#ifndef U_HIDE_INTERNAL_API
 
    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
                  UNumberFormatStyle style, UErrorCode& status);
 
#if UCONFIG_HAVE_PARSEALLINPUT
 
    void setParseAllInput(UNumberFormatAttributeValue value);
 
#endif
 
#endif  /* U_HIDE_INTERNAL_API */
 
  private:
 
    DecimalFormat(const DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
 
  public:
 
    virtual DecimalFormat& setAttribute(UNumberFormatAttribute attr, int32_t newValue, UErrorCode& status);
 
    virtual int32_t getAttribute(UNumberFormatAttribute attr, UErrorCode& status) const;
 
 
    void setGroupingUsed(UBool newValue) U_OVERRIDE;
 
    void setParseIntegerOnly(UBool value) U_OVERRIDE;
 
    void setLenient(UBool enable) U_OVERRIDE;
 
    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
                  UParseError& parseError, UErrorCode& status);
 
    DecimalFormat(const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status);
 
    DecimalFormat(const DecimalFormat& source);
 
    DecimalFormat& operator=(const DecimalFormat& rhs);
 
    ~DecimalFormat() U_OVERRIDE;
 
    DecimalFormat* clone() const U_OVERRIDE;
 
    UBool operator==(const Format& other) const U_OVERRIDE;
 
 
    using NumberFormat::format;
 
    UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
#ifndef U_HIDE_INTERNAL_API
    UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos,
                          UErrorCode& status) const U_OVERRIDE;
#endif  /* U_HIDE_INTERNAL_API */
 
    UnicodeString& format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter,
                          UErrorCode& status) const U_OVERRIDE;
 
    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
#ifndef U_HIDE_INTERNAL_API
    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos,
                          UErrorCode& status) const U_OVERRIDE;
#endif  /* U_HIDE_INTERNAL_API */
 
    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
                          UErrorCode& status) const U_OVERRIDE;
 
    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
#ifndef U_HIDE_INTERNAL_API
    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos,
                          UErrorCode& status) const U_OVERRIDE;
#endif  /* U_HIDE_INTERNAL_API */
 
    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
                          UErrorCode& status) const U_OVERRIDE;
 
    UnicodeString& format(StringPiece number, UnicodeString& appendTo, FieldPositionIterator* posIter,
                          UErrorCode& status) const U_OVERRIDE;
 
#ifndef U_HIDE_INTERNAL_API
 
    UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
                          FieldPositionIterator* posIter, UErrorCode& status) const U_OVERRIDE;
 
    UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
                          FieldPosition& pos, UErrorCode& status) const U_OVERRIDE;
 
#endif // U_HIDE_INTERNAL_API
 
    using NumberFormat::parse;
 
    void parse(const UnicodeString& text, Formattable& result,
               ParsePosition& parsePosition) const U_OVERRIDE;
 
    CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE;
 
    virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const;
 
    virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
 
    virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
 
 
    virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const;
 
    virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt);
 
    virtual void setCurrencyPluralInfo(const CurrencyPluralInfo& info);
 
 
    UnicodeString& getPositivePrefix(UnicodeString& result) const;
 
    virtual void setPositivePrefix(const UnicodeString& newValue);
 
    UnicodeString& getNegativePrefix(UnicodeString& result) const;
 
    virtual void setNegativePrefix(const UnicodeString& newValue);
 
    UnicodeString& getPositiveSuffix(UnicodeString& result) const;
 
    virtual void setPositiveSuffix(const UnicodeString& newValue);
 
    UnicodeString& getNegativeSuffix(UnicodeString& result) const;
 
    virtual void setNegativeSuffix(const UnicodeString& newValue);
 
#ifndef U_HIDE_DRAFT_API
    UBool isSignAlwaysShown() const;
 
    void setSignAlwaysShown(UBool value);
#endif  /* U_HIDE_DRAFT_API */
 
    int32_t getMultiplier(void) const;
 
    virtual void setMultiplier(int32_t newValue);
 
    int32_t getMultiplierScale(void) const;
 
    void setMultiplierScale(int32_t newValue);
 
    virtual double getRoundingIncrement(void) const;
 
    virtual void setRoundingIncrement(double newValue);
 
    virtual ERoundingMode getRoundingMode(void) const U_OVERRIDE;
 
    virtual void setRoundingMode(ERoundingMode roundingMode) U_OVERRIDE;
 
    virtual int32_t getFormatWidth(void) const;
 
    virtual void setFormatWidth(int32_t width);
 
    virtual UnicodeString getPadCharacterString() const;
 
    virtual void setPadCharacter(const UnicodeString& padChar);
 
    virtual EPadPosition getPadPosition(void) const;
 
    virtual void setPadPosition(EPadPosition padPos);
 
    virtual UBool isScientificNotation(void) const;
 
    virtual void setScientificNotation(UBool useScientific);
 
    virtual int8_t getMinimumExponentDigits(void) const;
 
    virtual void setMinimumExponentDigits(int8_t minExpDig);
 
    virtual UBool isExponentSignAlwaysShown(void) const;
 
    virtual void setExponentSignAlwaysShown(UBool expSignAlways);
 
    int32_t getGroupingSize(void) const;
 
    virtual void setGroupingSize(int32_t newValue);
 
    int32_t getSecondaryGroupingSize(void) const;
 
    virtual void setSecondaryGroupingSize(int32_t newValue);
 
#ifndef U_HIDE_DRAFT_API
    int32_t getMinimumGroupingDigits() const;
 
    void setMinimumGroupingDigits(int32_t newValue);
#endif  /* U_HIDE_DRAFT_API */
 
 
    UBool isDecimalSeparatorAlwaysShown(void) const;
 
    virtual void setDecimalSeparatorAlwaysShown(UBool newValue);
 
    UBool isDecimalPatternMatchRequired(void) const;
 
    virtual void setDecimalPatternMatchRequired(UBool newValue);
 
#ifndef U_HIDE_DRAFT_API
    UBool isParseNoExponent() const;
 
    void setParseNoExponent(UBool value);
 
    UBool isParseCaseSensitive() const;
 
    void setParseCaseSensitive(UBool value);
 
    UBool isFormatFailIfMoreThanMaxDigits() const;
 
    void setFormatFailIfMoreThanMaxDigits(UBool value);
#endif  /* U_HIDE_DRAFT_API */
 
 
    virtual UnicodeString& toPattern(UnicodeString& result) const;
 
    virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const;
 
    virtual void applyPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status);
 
    virtual void applyPattern(const UnicodeString& pattern, UErrorCode& status);
 
    virtual void applyLocalizedPattern(const UnicodeString& pattern, UParseError& parseError,
                                       UErrorCode& status);
 
    virtual void applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status);
 
 
    void setMaximumIntegerDigits(int32_t newValue) U_OVERRIDE;
 
    void setMinimumIntegerDigits(int32_t newValue) U_OVERRIDE;
 
    void setMaximumFractionDigits(int32_t newValue) U_OVERRIDE;
 
    void setMinimumFractionDigits(int32_t newValue) U_OVERRIDE;
 
    int32_t getMinimumSignificantDigits() const;
 
    int32_t getMaximumSignificantDigits() const;
 
    void setMinimumSignificantDigits(int32_t min);
 
    void setMaximumSignificantDigits(int32_t max);
 
    UBool areSignificantDigitsUsed() const;
 
    void setSignificantDigitsUsed(UBool useSignificantDigits);
 
    void setCurrency(const char16_t* theCurrency, UErrorCode& ec) U_OVERRIDE;
 
#ifndef U_FORCE_HIDE_DEPRECATED_API
    virtual void setCurrency(const char16_t* theCurrency);
#endif  // U_FORCE_HIDE_DEPRECATED_API
 
    void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec);
 
    UCurrencyUsage getCurrencyUsage() const;
 
#ifndef U_HIDE_INTERNAL_API
 
    void formatToDecimalQuantity(double number, number::impl::DecimalQuantity& output,
                                 UErrorCode& status) const;
 
    void formatToDecimalQuantity(const Formattable& number, number::impl::DecimalQuantity& output,
                                 UErrorCode& status) const;
 
#endif  /* U_HIDE_INTERNAL_API */
 
#ifndef U_HIDE_DRAFT_API
    const number::LocalizedNumberFormatter* toNumberFormatter(UErrorCode& status) const;
#endif  /* U_HIDE_DRAFT_API */
 
    static UClassID U_EXPORT2 getStaticClassID(void);
 
    UClassID getDynamicClassID(void) const U_OVERRIDE;
 
  private:
 
    void touch(UErrorCode& status);
 
    void touchNoError();
 
    void setPropertiesFromPattern(const UnicodeString& pattern, int32_t ignoreRounding,
                                  UErrorCode& status);
 
    const numparse::impl::NumberParserImpl* getParser(UErrorCode& status) const;
 
    const numparse::impl::NumberParserImpl* getCurrencyParser(UErrorCode& status) const;
 
    static void fieldPositionHelper(const number::FormattedNumber& formatted, FieldPosition& fieldPosition,
                                    int32_t offset, UErrorCode& status);
 
    static void fieldPositionIteratorHelper(const number::FormattedNumber& formatted,
                                            FieldPositionIterator* fpi, int32_t offset, UErrorCode& status);
 
    void setupFastFormat();
 
    bool fastFormatDouble(double input, UnicodeString& output) const;
 
    bool fastFormatInt64(int64_t input, UnicodeString& output) const;
 
    void doFastFormatInt32(int32_t input, bool isNegative, UnicodeString& output) const;
 
    //=====================================================================================//
    //                                   INSTANCE FIELDS                                   //
    //=====================================================================================//
 
 
    // One instance field for the implementation, keep all fields inside of an implementation
    // class defined in number_mapper.h
    number::impl::DecimalFormatFields* fields = nullptr;
 
    // Allow child class CompactDecimalFormat to access fProperties:
    friend class CompactDecimalFormat;
 
    // Allow MeasureFormat to use fieldPositionHelper:
    friend class MeasureFormat;
 
};
 
U_NAMESPACE_END
 
#endif /* #if !UCONFIG_NO_FORMATTING */
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif // _DECIMFMT
//eof