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

dcfmtsym.h

This is the verbatim text of the dcfmtsym.h include file.
/*
********************************************************************************
*   Copyright (C) 1997-1999, International Business Machines
*   Corporation and others.  All Rights Reserved.
********************************************************************************
*
* File DCFMTSYM.H
*
* Modification History:
* 
*   Date        Name        Description
*   02/19/97    aliu        Converted from java.
*   03/18/97    clhuang     Updated per C++ implementation.
*   03/27/97    helena      Updated to pass the simple test after code review.
*   08/26/97    aliu        Added currency/intl currency symbol support.
*    07/22/98    stephen        Changed to match C++ style 
*                            currencySymbol -> fCurrencySymbol
*                            Constants changed from CAPS to kCaps
*   06/24/99    helena      Integrated Alan's NF enhancements and Java2 bug fixes
********************************************************************************
*/
 
#ifndef DCFMTSYM_H
#define DCFMTSYM_H
 
#include "unicode/utypes.h"
#include "unicode/locid.h"

class U_I18N_API DecimalFormatSymbols {
public:
    enum ENumberFormatSymbol {
        kDecimalSeparatorSymbol,
        kGroupingSeparatorSymbol,
        kPatternSeparatorSymbol,
        kPercentSymbol,
        kZeroDigitSymbol,
        kDigitSymbol,
        kMinusSignSymbol,
        kPlusSignSymbol,
        kCurrencySymbol,
        kIntlCurrencySymbol,
        kMonetarySeparatorSymbol,
        kExponentialSymbol,
        kPermillSymbol,
        kPadEscapeSymbol,
        kInfinitySymbol,
        kNaNSymbol,
        kFormatSymbolCount
    };

    DecimalFormatSymbols(const Locale& locale, UErrorCode& status);

    DecimalFormatSymbols( UErrorCode& status);

    DecimalFormatSymbols(const DecimalFormatSymbols&);

    DecimalFormatSymbols& operator=(const DecimalFormatSymbols&);

    ~DecimalFormatSymbols();

    UBool operator==(const DecimalFormatSymbols& other) const;

    UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }

    UnicodeString getSymbol(ENumberFormatSymbol symbol) const;

    void setSymbol(ENumberFormatSymbol symbol, UnicodeString value);

    UChar getZeroDigit(void) const;
    void setZeroDigit(UChar zeroDigit);

    UChar getGroupingSeparator(void) const;
    void setGroupingSeparator(UChar groupingSeparator);

    UChar getDecimalSeparator(void) const;
    void setDecimalSeparator(UChar decimalSeparator);

    UChar getPerMill(void) const;
    void setPerMill(UChar permill);

    UChar getPercent(void) const;
    void setPercent(UChar percent);

    UChar getDigit(void) const;
    void setDigit(UChar digit);

    UChar getPatternSeparator(void) const;
    void setPatternSeparator(UChar patternSeparator);

    UnicodeString& getInfinity(UnicodeString& result) const;
    void setInfinity(const UnicodeString& infinity);
    int32_t compareInfinity(const UnicodeString& text, UTextOffset offset) const;

    UnicodeString& getNaN(UnicodeString& result) const;
    void setNaN(const UnicodeString& NaN);
    int32_t compareNaN(const UnicodeString& text, UTextOffset offset) const;

    UChar getPlusSign(void) const;
    void setPlusSign(UChar minusSign);

    UChar getMinusSign(void) const;
    void setMinusSign(UChar minusSign);
 
    UChar getExponentialSymbol(void) const;
    void setExponentialSymbol(UChar exponential);

    UnicodeString& getCurrencySymbol(UnicodeString& result) const;
    void setCurrencySymbol(const UnicodeString& currency);
    int32_t compareCurrencySymbol(const UnicodeString& text, UTextOffset offset) const;

    UnicodeString& getInternationalCurrencySymbol(UnicodeString& result) const;
    void setInternationalCurrencySymbol(const UnicodeString& currency);
    int32_t compareInternationalCurrencySymbol(const UnicodeString& text, UTextOffset offset) const;

    UChar getMonetaryDecimalSeparator(void) const;
    void setMonetaryDecimalSeparator(UChar sep);

    UChar getPadEscape(void) const;

    void setPadEscape(UChar c);

private:
    void initialize(const Locale& locale, UErrorCode& success, UBool useLastResortData = FALSE);

    void initialize(const UnicodeString* numberElements, const UnicodeString* currencyElements);

    void initialize();

    UnicodeString fSymbols[kFormatSymbolCount];
};


// -------------------------------------

inline UnicodeString
DecimalFormatSymbols::getSymbol(ENumberFormatSymbol symbol) const {
    if(symbol<kFormatSymbolCount) {
        return fSymbols[symbol];
    } else {
        return UnicodeString();
    }
}

// -------------------------------------

inline void
DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, UnicodeString value) {
    if(symbol<kFormatSymbolCount) {
        fSymbols[symbol]=value;
    }
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getZeroDigit() const
{
    return fSymbols[kZeroDigitSymbol].charAt(0);
}

// -------------------------------------
 
inline void
DecimalFormatSymbols::setZeroDigit(UChar zeroDigit)
{
    fSymbols[kZeroDigitSymbol] = zeroDigit;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getGroupingSeparator() const
{
    return fSymbols[kGroupingSeparatorSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setGroupingSeparator(UChar groupingSeparator)
{
    fSymbols[kGroupingSeparatorSymbol] = groupingSeparator;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getDecimalSeparator() const
{
    return fSymbols[kDecimalSeparatorSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setDecimalSeparator(UChar decimalSeparator)
{
    fSymbols[kDecimalSeparatorSymbol] = decimalSeparator;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getPerMill() const
{
    return fSymbols[kPermillSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setPerMill(UChar permill)
{
    fSymbols[kPermillSymbol] = permill;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getPercent() const
{
    return fSymbols[kPercentSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setPercent(UChar percent)
{
    fSymbols[kPercentSymbol] = percent;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getDigit() const
{
    return fSymbols[kDigitSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setDigit(UChar digit)
{
    fSymbols[kDigitSymbol] = digit;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getPatternSeparator() const
{
    return fSymbols[kPatternSeparatorSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setPatternSeparator(UChar patternSeparator)
{
    fSymbols[kPatternSeparatorSymbol] = patternSeparator;
}

// -------------------------------------

inline UnicodeString&
DecimalFormatSymbols::getInfinity(UnicodeString& result) const
{
    return result = fSymbols[kInfinitySymbol];
}

// -------------------------------------

inline void
DecimalFormatSymbols::setInfinity(const UnicodeString& infinity)
{
    fSymbols[kInfinitySymbol] = infinity;
}

// -------------------------------------

inline int32_t
DecimalFormatSymbols::compareInfinity(const UnicodeString& text,
                                      UTextOffset offset) const
{
    return text.compare(offset,
                        fSymbols[kInfinitySymbol].length(),
                        fSymbols[kInfinitySymbol],
                        0,
                        fSymbols[kInfinitySymbol].length())
           ? 0 : fSymbols[kInfinitySymbol].length();
}

// -------------------------------------

inline UnicodeString&
DecimalFormatSymbols::getNaN(UnicodeString& result) const
{
    return result = fSymbols[kNaNSymbol];
}

// -------------------------------------

inline void
DecimalFormatSymbols::setNaN(const UnicodeString& NaN)
{
    fSymbols[kNaNSymbol] = NaN;
}

// -------------------------------------

inline int32_t
DecimalFormatSymbols::compareNaN(const UnicodeString& text, UTextOffset offset) const
{
    return text.compare(offset,
                        fSymbols[kNaNSymbol].length(),
                        fSymbols[kNaNSymbol],
                        0,
                        fSymbols[kNaNSymbol].length())
           ? 0 : fSymbols[kNaNSymbol].length();
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getPlusSign() const
{
    return fSymbols[kPlusSignSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setPlusSign(UChar plusSign)
{
    fSymbols[kPlusSignSymbol] = plusSign;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getMinusSign() const
{
    return fSymbols[kMinusSignSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setMinusSign(UChar minusSign)
{
    fSymbols[kMinusSignSymbol] = minusSign;
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getExponentialSymbol(void) const
{
    return fSymbols[kExponentialSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setExponentialSymbol(UChar exponential)
{
    fSymbols[kExponentialSymbol] = exponential;
}

// -------------------------------------

inline UnicodeString&
DecimalFormatSymbols::getCurrencySymbol(UnicodeString& result) const
{
    return result = fSymbols[kCurrencySymbol];
}

// -------------------------------------

inline void
DecimalFormatSymbols::setCurrencySymbol(const UnicodeString& str)
{
    fSymbols[kCurrencySymbol] = str;
}

// -------------------------------------

inline int32_t
DecimalFormatSymbols::compareCurrencySymbol(const UnicodeString& text,
                                            UTextOffset offset) const
{
    return text.compare(offset,
                        fSymbols[kCurrencySymbol].length(),
                        fSymbols[kCurrencySymbol],
                        0,
                        fSymbols[kCurrencySymbol].length())
           ? 0 : fSymbols[kCurrencySymbol].length();
}

// -------------------------------------

inline UnicodeString&
DecimalFormatSymbols::getInternationalCurrencySymbol(UnicodeString& result) const
{
    return result = fSymbols[kIntlCurrencySymbol];
}

// -------------------------------------

inline void
DecimalFormatSymbols::setInternationalCurrencySymbol(const UnicodeString& str)
{
    fSymbols[kIntlCurrencySymbol] = str;
}

// -------------------------------------

inline int32_t
DecimalFormatSymbols::compareInternationalCurrencySymbol(const UnicodeString& text,
                                                         UTextOffset offset) const
{
    return text.compare(offset,
                        fSymbols[kIntlCurrencySymbol].length(),
                        fSymbols[kIntlCurrencySymbol],
                        0,
                        fSymbols[kIntlCurrencySymbol].length())
           ? 0 : fSymbols[kIntlCurrencySymbol].length();
}

// -------------------------------------

inline UChar
DecimalFormatSymbols::getMonetaryDecimalSeparator(void) const
{
    return fSymbols[kMonetarySeparatorSymbol].charAt(0);
}

// -------------------------------------

inline void
DecimalFormatSymbols::setMonetaryDecimalSeparator(UChar sep)
{
    fSymbols[kMonetarySeparatorSymbol] = sep;
}

inline UChar DecimalFormatSymbols::getPadEscape(void) const {
    return fSymbols[kPadEscapeSymbol].charAt(0);
}

inline void DecimalFormatSymbols::setPadEscape(UChar c) {
    fSymbols[kPadEscapeSymbol] = c;
}

#endif // _DCFMTSYM
//eof

Generated at Wed Aug 16 16:05:44 2000 for ICU1.6 by doxygen 1.0.0 written by Dimitri van Heesch, © 1997-1999