numfmt.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 NUMFMT.H
*
* Modification History:
*
*   Date        Name        Description
*   02/19/97    aliu        Converted from java.
*   03/18/97    clhuang     Updated per C++ implementation.
*   04/17/97    aliu        Changed DigitCount to int per code review.
*    07/20/98    stephen        JDK 1.2 sync up. Added scientific support.
*                            Changed naming conventions to match C++ guidelines
*                            Deprecated Java style constants (eg, INTEGER_FIELD)
********************************************************************************
*/
 
#ifndef NUMFMT_H
#define NUMFMT_H
 
 
#include "unicode/utypes.h"
 
#if U_SHOW_CPLUSPLUS_API
 
#if !UCONFIG_NO_FORMATTING
 
#include "unicode/unistr.h"
#include "unicode/format.h"
#include "unicode/unum.h" // UNumberFormatStyle
#include "unicode/locid.h"
#include "unicode/stringpiece.h"
#include "unicode/curramt.h"
#include "unicode/udisplaycontext.h"
 
class NumberFormatTest;
 
U_NAMESPACE_BEGIN
 
class SharedNumberFormat;
 
#if !UCONFIG_NO_SERVICE
class NumberFormatFactory;
class StringEnumeration;
#endif
 
class U_I18N_API NumberFormat : public Format {
public:
    enum ERoundingMode {
        kRoundCeiling,  
        kRoundFloor,    
        kRoundDown,     
        kRoundUp,       
        kRoundHalfEven, 
        kRoundHalfDown, 
        kRoundHalfUp,   
        kRoundUnnecessary
    };
 
    enum EAlignmentFields {
        kIntegerField = UNUM_INTEGER_FIELD,
        kFractionField = UNUM_FRACTION_FIELD,
        kDecimalSeparatorField = UNUM_DECIMAL_SEPARATOR_FIELD,
        kExponentSymbolField = UNUM_EXPONENT_SYMBOL_FIELD,
        kExponentSignField = UNUM_EXPONENT_SIGN_FIELD,
        kExponentField = UNUM_EXPONENT_FIELD,
        kGroupingSeparatorField = UNUM_GROUPING_SEPARATOR_FIELD,
        kCurrencyField = UNUM_CURRENCY_FIELD,
        kPercentField = UNUM_PERCENT_FIELD,
        kPermillField = UNUM_PERMILL_FIELD,
        kSignField = UNUM_SIGN_FIELD,
        kMeasureUnitField = UNUM_MEASURE_UNIT_FIELD,
        kCompactField = UNUM_COMPACT_FIELD,
 
        INTEGER_FIELD        = UNUM_INTEGER_FIELD,
        FRACTION_FIELD       = UNUM_FRACTION_FIELD
    };
 
    virtual ~NumberFormat();
 
    virtual NumberFormat* clone() const override = 0;
 
    virtual bool operator==(const Format& other) const override;
 
 
    using Format::format;
 
    virtual UnicodeString& format(const Formattable& obj,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos,
                                  UErrorCode& status) const override;
 
    virtual UnicodeString& format(const Formattable& obj,
                                  UnicodeString& appendTo,
                                  FieldPositionIterator* posIter,
                                  UErrorCode& status) const override;
 
    virtual void parseObject(const UnicodeString& source,
                             Formattable& result,
                             ParsePosition& parse_pos) const override;
 
    UnicodeString& format(  double number,
                            UnicodeString& appendTo) const;
 
    UnicodeString& format(  int32_t number,
                            UnicodeString& appendTo) const;
 
    UnicodeString& format(  int64_t number,
                            UnicodeString& appendTo) const;
 
    virtual UnicodeString& format(double number,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos) const = 0;
    virtual UnicodeString& format(double number,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos,
                                  UErrorCode &status) const;
    virtual UnicodeString& format(double number,
                                  UnicodeString& appendTo,
                                  FieldPositionIterator* posIter,
                                  UErrorCode& status) const;
    virtual UnicodeString& format(int32_t number,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos) const = 0;
 
    virtual UnicodeString& format(int32_t number,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos,
                                  UErrorCode &status) const;
 
    virtual UnicodeString& format(int32_t number,
                                  UnicodeString& appendTo,
                                  FieldPositionIterator* posIter,
                                  UErrorCode& status) const;
    virtual UnicodeString& format(int64_t number,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos) const;
 
    virtual UnicodeString& format(int64_t number,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos,
                                  UErrorCode& status) const;
    virtual UnicodeString& format(int64_t number,
                                  UnicodeString& appendTo,
                                  FieldPositionIterator* posIter,
                                  UErrorCode& status) const;
 
    virtual UnicodeString& format(StringPiece number,
                                  UnicodeString& appendTo,
                                  FieldPositionIterator* posIter,
                                  UErrorCode& status) const;
 
// Can't use #ifndef U_HIDE_INTERNAL_API because these are virtual methods
 
    virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
                                  UnicodeString& appendTo,
                                  FieldPositionIterator* posIter,
                                  UErrorCode& status) const;
 
    virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
                                  UnicodeString& appendTo,
                                  FieldPosition& pos,
                                  UErrorCode& status) const;
 
    virtual void parse(const UnicodeString& text,
                       Formattable& result,
                       ParsePosition& parsePosition) const = 0;
 
    virtual void parse(const UnicodeString& text,
                       Formattable& result,
                       UErrorCode& status) const;
 
    virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
                                          ParsePosition& pos) const;
 
    UBool isParseIntegerOnly(void) const;
 
    virtual void setParseIntegerOnly(UBool value);
 
    virtual void setLenient(UBool enable);
 
    virtual UBool isLenient(void) const;
 
    static NumberFormat* U_EXPORT2 createInstance(UErrorCode&);
 
    static NumberFormat* U_EXPORT2 createInstance(const Locale& inLocale,
                                        UErrorCode&);
 
    static NumberFormat* U_EXPORT2 createInstance(const Locale& desiredLocale,
                                                  UNumberFormatStyle style,
                                                  UErrorCode& errorCode);
 
#ifndef U_HIDE_INTERNAL_API
 
    static NumberFormat* internalCreateInstance(
            const Locale& desiredLocale,
            UNumberFormatStyle style,
            UErrorCode& errorCode);
 
    static const SharedNumberFormat* U_EXPORT2 createSharedInstance(
            const Locale& inLocale, UNumberFormatStyle style, UErrorCode& status);
 
#endif  /* U_HIDE_INTERNAL_API */
 
    static NumberFormat* U_EXPORT2 createCurrencyInstance(UErrorCode&);
 
    static NumberFormat* U_EXPORT2 createCurrencyInstance(const Locale& inLocale,
                                                UErrorCode&);
 
    static NumberFormat* U_EXPORT2 createPercentInstance(UErrorCode&);
 
    static NumberFormat* U_EXPORT2 createPercentInstance(const Locale& inLocale,
                                               UErrorCode&);
 
    static NumberFormat* U_EXPORT2 createScientificInstance(UErrorCode&);
 
    static NumberFormat* U_EXPORT2 createScientificInstance(const Locale& inLocale,
                                                UErrorCode&);
 
    static const Locale* U_EXPORT2 getAvailableLocales(int32_t& count);
 
#if !UCONFIG_NO_SERVICE
    static URegistryKey U_EXPORT2 registerFactory(NumberFormatFactory* toAdopt, UErrorCode& status);
 
    static UBool U_EXPORT2 unregister(URegistryKey key, UErrorCode& status);
 
    static StringEnumeration* U_EXPORT2 getAvailableLocales(void);
#endif /* UCONFIG_NO_SERVICE */
 
    UBool isGroupingUsed(void) const;
 
    virtual void setGroupingUsed(UBool newValue);
 
    int32_t getMaximumIntegerDigits(void) const;
 
    virtual void setMaximumIntegerDigits(int32_t newValue);
 
    int32_t getMinimumIntegerDigits(void) const;
 
    virtual void setMinimumIntegerDigits(int32_t newValue);
 
    int32_t getMaximumFractionDigits(void) const;
 
    virtual void setMaximumFractionDigits(int32_t newValue);
 
    int32_t getMinimumFractionDigits(void) const;
 
    virtual void setMinimumFractionDigits(int32_t newValue);
 
    virtual void setCurrency(const char16_t* theCurrency, UErrorCode& ec);
 
    const char16_t* getCurrency() const;
 
    virtual void setContext(UDisplayContext value, UErrorCode& status);
 
    virtual UDisplayContext getContext(UDisplayContextType type, UErrorCode& status) const;
 
    virtual ERoundingMode getRoundingMode(void) const;
 
    virtual void setRoundingMode(ERoundingMode roundingMode);
 
public:
 
    static UClassID U_EXPORT2 getStaticClassID(void);
 
    virtual UClassID getDynamicClassID(void) const override = 0;
 
protected:
 
    NumberFormat();
 
    NumberFormat(const NumberFormat&);
 
    NumberFormat& operator=(const NumberFormat&);
 
    virtual void getEffectiveCurrency(char16_t* result, UErrorCode& ec) const;
 
#ifndef U_HIDE_INTERNAL_API
    static NumberFormat* makeInstance(const Locale& desiredLocale,
                                      UNumberFormatStyle style,
                                      UBool mustBeDecimalFormat,
                                      UErrorCode& errorCode);
#endif  /* U_HIDE_INTERNAL_API */
 
private:
 
    static UBool isStyleSupported(UNumberFormatStyle style);
 
    static NumberFormat* makeInstance(const Locale& desiredLocale,
                                      UNumberFormatStyle style,
                                      UErrorCode& errorCode);
 
    UBool       fGroupingUsed;
    int32_t     fMaxIntegerDigits;
    int32_t     fMinIntegerDigits;
    int32_t     fMaxFractionDigits;
    int32_t     fMinFractionDigits;
 
  protected:
    static const int32_t gDefaultMaxIntegerDigits;
    static const int32_t gDefaultMinIntegerDigits;
 
  private:
    UBool      fParseIntegerOnly;
    UBool      fLenient; // true => lenient parse is enabled
 
    // ISO currency code
    char16_t      fCurrency[4];
 
    UDisplayContext fCapitalizationContext;
 
    friend class ICUNumberFormatFactory; // access to makeInstance
    friend class ICUNumberFormatService;
    friend class ::NumberFormatTest;  // access to isStyleSupported()
};
 
#if !UCONFIG_NO_SERVICE
class U_I18N_API NumberFormatFactory : public UObject {
public:
 
    virtual ~NumberFormatFactory();
 
    virtual UBool visible(void) const = 0;
 
    virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode& status) const = 0;
 
    virtual NumberFormat* createFormat(const Locale& loc, UNumberFormatStyle formatType) = 0;
};
 
class U_I18N_API SimpleNumberFormatFactory : public NumberFormatFactory {
protected:
    const UBool _visible;
 
    UnicodeString _id;
 
public:
    SimpleNumberFormatFactory(const Locale& locale, UBool visible = true);
 
    virtual ~SimpleNumberFormatFactory();
 
    virtual UBool visible(void) const override;
 
    virtual const UnicodeString * getSupportedIDs(int32_t &count, UErrorCode& status) const override;
};
#endif /* #if !UCONFIG_NO_SERVICE */
 
// -------------------------------------
 
inline UBool
NumberFormat::isParseIntegerOnly() const
{
    return fParseIntegerOnly;
}
 
inline UBool
NumberFormat::isLenient() const
{
    return fLenient;
}
 
U_NAMESPACE_END
 
#endif /* #if !UCONFIG_NO_FORMATTING */
 
#endif /* U_SHOW_CPLUSPLUS_API */
 
#endif // _NUMFMT
//eof