Main Page   Class Hierarchy   Compound List   File List   Header Files   Sources   Compound Members   File Members  

decimfmt.h

This is the verbatim text of the decimfmt.h include file.
/*
********************************************************************************
*   Copyright (C) 1997-1999, 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
********************************************************************************
*/
 
#ifndef DECIMFMT_H
#define DECIMFMT_H
 
#include "unicode/utypes.h"
#include "unicode/numfmt.h"
#include "unicode/locid.h"

class DecimalFormatSymbols;
class DigitList;

class U_I18N_API DecimalFormat: public NumberFormat {
public:
    enum ERoundingMode {
        kRoundCeiling,
        kRoundFloor,
        kRoundDown,
        kRoundUp,
        kRoundHalfEven,
        kRoundHalfDown,
        kRoundHalfUp
        // We don't support ROUND_UNNECESSARY
    };

    enum EPadPosition {
        kPadBeforePrefix,
        kPadAfterPrefix,
        kPadBeforeSuffix,
        kPadAfterSuffix
    };

    DecimalFormat(UErrorCode& status);

    DecimalFormat(const UnicodeString& pattern,
                  UErrorCode& status);

    DecimalFormat(  const UnicodeString& pattern,
                    DecimalFormatSymbols* symbolsToAdopt,
                    UErrorCode& status);

    DecimalFormat(  const UnicodeString& pattern,
                    const DecimalFormatSymbols& symbols,
                    UErrorCode& status);

    DecimalFormat(const DecimalFormat& source);

    DecimalFormat& operator=(const DecimalFormat& rhs);

    virtual ~DecimalFormat();

    virtual Format* clone(void) const;

    virtual UBool operator==(const Format& other) const;

    virtual UnicodeString& format(double number,
                                  UnicodeString& toAppendTo,
                                  FieldPosition& pos) const;
    virtual UnicodeString& format(int32_t number,
                                  UnicodeString& toAppendTo,
                                  FieldPosition& pos) const;
    virtual UnicodeString& format(const Formattable& obj,
                                  UnicodeString& toAppendTo,
                                  FieldPosition& pos,
                                  UErrorCode& status) const;

    UnicodeString& format(const Formattable& obj,
                          UnicodeString& result,
                          UErrorCode& status) const;

    UnicodeString& format(double number,
                          UnicodeString& output) const;

    UnicodeString& format(int32_t number,
                          UnicodeString& output) const;

    virtual void parse(const UnicodeString& text,
                       Formattable& result,
                       ParsePosition& parsePosition) const;

    // Declare here again to get rid of function hiding problems.
    virtual void parse(const UnicodeString& text, 
                       Formattable& result, 
                       UErrorCode& error) const;

    virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const;

    virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);

    virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);


    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);

    int32_t getMultiplier(void) const;

    virtual void setMultiplier(int32_t newValue);

    virtual double getRoundingIncrement(void);

    virtual void setRoundingIncrement(double newValue);

    virtual ERoundingMode getRoundingMode(void);

    virtual void setRoundingMode(ERoundingMode roundingMode);

    virtual int32_t getFormatWidth(void);

    virtual void setFormatWidth(int32_t width);

    inline UChar getPadCharacter(void);

    virtual UnicodeString getPadCharacterString();

    inline void setPadCharacter(UChar padChar);

    virtual void setPadCharacter(UnicodeString padChar);

    virtual EPadPosition getPadPosition(void);

    virtual void setPadPosition(EPadPosition padPos);

    virtual UBool isScientificNotation(void);

    virtual void setScientificNotation(UBool useScientific);

    virtual int8_t getMinimumExponentDigits(void);

    virtual void setMinimumExponentDigits(int8_t minExpDig);

    virtual UBool isExponentSignAlwaysShown(void);

    virtual void setExponentSignAlwaysShown(UBool expSignAlways);

    int32_t getGroupingSize(void) const;

    virtual void setGroupingSize(int32_t newValue);

    UBool isDecimalSeparatorAlwaysShown(void) const;

    virtual void setDecimalSeparatorAlwaysShown(UBool newValue);

    virtual UnicodeString& toPattern(UnicodeString& result) const;

    virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const;
 
    virtual void applyPattern(const UnicodeString& pattern,
                              UErrorCode& status);

    virtual void applyLocalizedPattern(const UnicodeString& pattern,
                                       UErrorCode& status);

    virtual void setMaximumIntegerDigits(int32_t newValue);

    virtual void setMinimumIntegerDigits(int32_t newValue);

    virtual void setMaximumFractionDigits(int32_t newValue);

    virtual void setMinimumFractionDigits(int32_t newValue);

    static const char *fgNumberPatterns;

public:

    static UClassID getStaticClassID(void) { return (UClassID)&fgClassID; }

    virtual UClassID getDynamicClassID(void) const { return getStaticClassID(); }

private:
    static char fgClassID;

    void construct(UErrorCode&               status,
                   const UnicodeString*     pattern = 0,
                   DecimalFormatSymbols*    symbolsToAdopt = 0,
                   const Locale&            locale = Locale::getDefault());

    UnicodeString& toPattern(UnicodeString& result, UBool localized) const;

    void applyPattern(const UnicodeString& pattern,
                            UBool localized,
                            UErrorCode& status);

    UnicodeString& subformat(UnicodeString& result,
                             FieldPosition& fieldPosition,
                             UBool         isNegative,
                             UBool         isInteger) const;

    static const int32_t fgStatusInfinite;
    static const int32_t fgStatusPositive;
    static const int32_t fgStatusLength;

    UBool subparse(const UnicodeString& text, ParsePosition& parsePosition,
                    DigitList& digits, UBool isExponent,
                    UBool* status) const;

    void appendAffix(UnicodeString& buffer, const UnicodeString& affix, 
                     UBool localized) const;

    void appendAffix(UnicodeString& buffer,
                     const UnicodeString* affixPattern,
                     const UnicodeString& expAffix, UBool localized) const;

    void expandAffix(const UnicodeString& pattern,
                     UnicodeString& affix) const;

    void expandAffixes(void);
    
    static double round(double a, ERoundingMode mode, UBool isNegative);

    void addPadding(UnicodeString& result, UBool hasAffixes,
                    UBool isNegative) const;

    static const int8_t fgMaxDigit; // The largest digit, in this case 9

    /*transient*/ DigitList* fDigitList;

    UnicodeString           fPositivePrefix;
    UnicodeString           fPositiveSuffix;
    UnicodeString           fNegativePrefix;
    UnicodeString           fNegativeSuffix;
    UnicodeString*          fPosPrefixPattern;
    UnicodeString*          fPosSuffixPattern;
    UnicodeString*          fNegPrefixPattern;
    UnicodeString*          fNegSuffixPattern;
    int32_t                 fMultiplier;
    int32_t                 fGroupingSize;
    UBool                  fDecimalSeparatorAlwaysShown;
    /*transient*/ UBool    fIsCurrencyFormat;
    DecimalFormatSymbols*   fSymbols;

    UBool                  fUseExponentialNotation;
    int8_t                  fMinExponentDigits;
    UBool                  fExponentSignAlwaysShown;

    /* If fRoundingIncrement is NULL, there is no rounding.  Otherwise, round to
     * fRoundingIncrement.getDouble().  Since this operation may be expensive,
     * we cache the result in fRoundingDouble.  All methods that update
     * fRoundingIncrement also update fRoundingDouble. */
    DigitList*              fRoundingIncrement;
    /*transient*/ double    fRoundingDouble;
    ERoundingMode           fRoundingMode;

    UChar                   fPad;
    int32_t                 fFormatWidth;
    EPadPosition            fPadPosition;

    // Constants for characters used in programmatic (unlocalized) patterns.
    static const UChar    kPatternZeroDigit;
    static const UChar    kPatternGroupingSeparator;
    static const UChar    kPatternDecimalSeparator;
    static const UChar    kPatternPerMill;
    static const UChar    kPatternPercent;
    static const UChar    kPatternDigit;
    static const UChar    kPatternSeparator;
    static const UChar    kPatternExponent;
    static const UChar    kPatternPlus;
    static const UChar    kPatternMinus;
    static const UChar    kPatternPadEscape;

    static const UChar    kCurrencySign;
    static const UChar    kQuote;

protected:
    static const int32_t  kDoubleIntegerDigits;
    static const int32_t  kDoubleFractionDigits;
};

inline UnicodeString&
DecimalFormat::format(const Formattable& obj,
                      UnicodeString& result,
                      UErrorCode& status) const {
    // Don't use Format:: - use immediate base class only,
    // in case immediate base modifies behavior later.
    return NumberFormat::format(obj, result, status);
}

inline UnicodeString&
DecimalFormat::format(double number,
                      UnicodeString& output) const {
    return NumberFormat::format(number, output);
}

inline UnicodeString&
DecimalFormat::format(int32_t number,
                      UnicodeString& output) const {
    return NumberFormat::format(number, output);
}

inline UChar
DecimalFormat::getPadCharacter() {
    return getPadCharacterString().charAt(0);
}

inline void
DecimalFormat::setPadCharacter(UChar padChar) {
    setPadCharacter(UnicodeString(padChar));
}

#endif // _DECIMFMT
//eof

Generated at Mon Jun 5 12:53:15 2000 for ICU1.5 by doxygen 1.0.0 written by Dimitri van Heesch, © 1997-1999