Main Page   Class Hierarchy   Alphabetical List   Data Structures   File List   Data Fields   Globals  

dcfmtsym.h

00001 /*
00002 ********************************************************************************
00003 *   Copyright (C) 1997-1999, International Business Machines
00004 *   Corporation and others.  All Rights Reserved.
00005 ********************************************************************************
00006 *
00007 * File DCFMTSYM.H
00008 *
00009 * Modification History:
00010 * 
00011 *   Date        Name        Description
00012 *   02/19/97    aliu        Converted from java.
00013 *   03/18/97    clhuang     Updated per C++ implementation.
00014 *   03/27/97    helena      Updated to pass the simple test after code review.
00015 *   08/26/97    aliu        Added currency/intl currency symbol support.
00016 *   07/22/98    stephen     Changed to match C++ style 
00017 *                            currencySymbol -> fCurrencySymbol
00018 *                            Constants changed from CAPS to kCaps
00019 *   06/24/99    helena      Integrated Alan's NF enhancements and Java2 bug fixes
00020 *   09/22/00    grhoten     Marked deprecation tags with a pointer to replacement
00021 *                            functions.
00022 ********************************************************************************
00023 */
00024  
00025 #ifndef DCFMTSYM_H
00026 #define DCFMTSYM_H
00027  
00028 #include "unicode/utypes.h"
00029 #include "unicode/locid.h"
00030 
00031 U_NAMESPACE_BEGIN
00032 
00072 class U_I18N_API DecimalFormatSymbols {
00073 public:
00078     enum ENumberFormatSymbol {
00080         kDecimalSeparatorSymbol,
00082         kGroupingSeparatorSymbol,
00084         kPatternSeparatorSymbol,
00086         kPercentSymbol,
00088         kZeroDigitSymbol,
00090         kDigitSymbol,
00092         kMinusSignSymbol,
00094         kPlusSignSymbol,
00096         kCurrencySymbol,
00098         kIntlCurrencySymbol,
00100         kMonetarySeparatorSymbol,
00102         kExponentialSymbol,
00104         kPerMillSymbol,
00106         kPadEscapeSymbol,
00108         kInfinitySymbol,
00110         kNaNSymbol,
00112         kFormatSymbolCount
00113     };
00114 
00123     DecimalFormatSymbols(const Locale& locale, UErrorCode& status);
00124 
00135     DecimalFormatSymbols( UErrorCode& status);
00136 
00141     DecimalFormatSymbols(const DecimalFormatSymbols&);
00142 
00147     DecimalFormatSymbols& operator=(const DecimalFormatSymbols&);
00148 
00153     ~DecimalFormatSymbols();
00154 
00159     UBool operator==(const DecimalFormatSymbols& other) const;
00160 
00165     UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
00166 
00173     UnicodeString getSymbol(ENumberFormatSymbol symbol) const;
00174 
00181     void setSymbol(ENumberFormatSymbol symbol, UnicodeString value);
00182 
00183 #ifdef ICU_DECIMALFORMATSYMBOLS_USE_DEPRECATES
00184 
00190     UChar getZeroDigit(void) const;
00197     void setZeroDigit(UChar zeroDigit);
00198 
00205     UChar getGroupingSeparator(void) const;
00212     void setGroupingSeparator(UChar groupingSeparator);
00213 
00220     UChar getDecimalSeparator(void) const;
00227     void setDecimalSeparator(UChar decimalSeparator);
00228 
00235     UChar getPerMill(void) const;
00242     void setPerMill(UChar permill);
00243 
00250     UChar getPercent(void) const;
00257     void setPercent(UChar percent);
00258 
00265     UChar getDigit(void) const;
00272     void setDigit(UChar digit);
00273 
00281     UChar getPatternSeparator(void) const;
00289     void setPatternSeparator(UChar patternSeparator);
00290 
00296     UnicodeString& getInfinity(UnicodeString& result) const;
00302     void setInfinity(const UnicodeString& infinity);
00309     int32_t compareInfinity(const UnicodeString& text, UTextOffset offset) const;
00310 
00316     UnicodeString& getNaN(UnicodeString& result) const;
00322     void setNaN(const UnicodeString& NaN);
00329     int32_t compareNaN(const UnicodeString& text, UTextOffset offset) const;
00330 
00337     UChar getPlusSign(void) const;
00344     void setPlusSign(UChar minusSign);
00345 
00354     UChar getMinusSign(void) const;
00363     void setMinusSign(UChar minusSign);
00364  
00372     UChar getExponentialSymbol(void) const;
00380     void setExponentialSymbol(UChar exponential);
00381 
00386     UnicodeString& getCurrencySymbol(UnicodeString& result) const;
00391     void setCurrencySymbol(const UnicodeString& currency);
00399     int32_t compareCurrencySymbol(const UnicodeString& text, UTextOffset offset) const;
00400 
00405     UnicodeString& getInternationalCurrencySymbol(UnicodeString& result) const;
00410     void setInternationalCurrencySymbol(const UnicodeString& currency);
00419     int32_t compareInternationalCurrencySymbol(const UnicodeString& text, UTextOffset offset) const;
00420 
00427     UChar getMonetaryDecimalSeparator(void) const;
00434     void setMonetaryDecimalSeparator(UChar sep);
00435 
00450     UChar getPadEscape(void) const;
00451 
00465     void setPadEscape(UChar c);
00466 #endif
00467 private:
00473     void initialize(const Locale& locale, UErrorCode& success, UBool useLastResortData = FALSE);
00474 
00479     void initialize(const UnicodeString* numberElements, const UnicodeString* currencyElements);
00480 
00484     void initialize();
00485 
00486     UnicodeString fSymbols[kFormatSymbolCount];
00487 
00488     static const char fgNumberElements[];
00489     static const char fgCurrencyElements[];
00490 };
00491 
00492 
00493 // -------------------------------------
00494 
00495 inline UnicodeString
00496 DecimalFormatSymbols::getSymbol(ENumberFormatSymbol symbol) const {
00497     if(symbol<kFormatSymbolCount) {
00498         return fSymbols[symbol];
00499     } else {
00500         return UnicodeString();
00501     }
00502 }
00503 
00504 // -------------------------------------
00505 
00506 inline void
00507 DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, UnicodeString value) {
00508     if(symbol<kFormatSymbolCount) {
00509         fSymbols[symbol]=value;
00510     }
00511 }
00512 
00513 #ifdef ICU_DECIMALFORMATSYMBOLS_USE_DEPRECATES
00514 // -------------------------------------
00515 
00516 inline UChar
00517 DecimalFormatSymbols::getZeroDigit() const
00518 {
00519     return fSymbols[kZeroDigitSymbol].charAt(0);
00520 }
00521 
00522 // -------------------------------------
00523  
00524 inline void
00525 DecimalFormatSymbols::setZeroDigit(UChar zeroDigit)
00526 {
00527     fSymbols[kZeroDigitSymbol] = zeroDigit;
00528 }
00529 
00530 // -------------------------------------
00531 
00532 inline UChar
00533 DecimalFormatSymbols::getGroupingSeparator() const
00534 {
00535     return fSymbols[kGroupingSeparatorSymbol].charAt(0);
00536 }
00537 
00538 // -------------------------------------
00539 
00540 inline void
00541 DecimalFormatSymbols::setGroupingSeparator(UChar groupingSeparator)
00542 {
00543     fSymbols[kGroupingSeparatorSymbol] = groupingSeparator;
00544 }
00545 
00546 // -------------------------------------
00547 
00548 inline UChar
00549 DecimalFormatSymbols::getDecimalSeparator() const
00550 {
00551     return fSymbols[kDecimalSeparatorSymbol].charAt(0);
00552 }
00553 
00554 // -------------------------------------
00555 
00556 inline void
00557 DecimalFormatSymbols::setDecimalSeparator(UChar decimalSeparator)
00558 {
00559     fSymbols[kDecimalSeparatorSymbol] = decimalSeparator;
00560 }
00561 
00562 // -------------------------------------
00563 
00564 inline UChar
00565 DecimalFormatSymbols::getPerMill() const
00566 {
00567     return fSymbols[kPermillSymbol].charAt(0);
00568 }
00569 
00570 // -------------------------------------
00571 
00572 inline void
00573 DecimalFormatSymbols::setPerMill(UChar permill)
00574 {
00575     fSymbols[kPermillSymbol] = permill;
00576 }
00577 
00578 // -------------------------------------
00579 
00580 inline UChar
00581 DecimalFormatSymbols::getPercent() const
00582 {
00583     return fSymbols[kPercentSymbol].charAt(0);
00584 }
00585 
00586 // -------------------------------------
00587 
00588 inline void
00589 DecimalFormatSymbols::setPercent(UChar percent)
00590 {
00591     fSymbols[kPercentSymbol] = percent;
00592 }
00593 
00594 // -------------------------------------
00595 
00596 inline UChar
00597 DecimalFormatSymbols::getDigit() const
00598 {
00599     return fSymbols[kDigitSymbol].charAt(0);
00600 }
00601 
00602 // -------------------------------------
00603 
00604 inline void
00605 DecimalFormatSymbols::setDigit(UChar digit)
00606 {
00607     fSymbols[kDigitSymbol] = digit;
00608 }
00609 
00610 // -------------------------------------
00611 
00612 inline UChar
00613 DecimalFormatSymbols::getPatternSeparator() const
00614 {
00615     return fSymbols[kPatternSeparatorSymbol].charAt(0);
00616 }
00617 
00618 // -------------------------------------
00619 
00620 inline void
00621 DecimalFormatSymbols::setPatternSeparator(UChar patternSeparator)
00622 {
00623     fSymbols[kPatternSeparatorSymbol] = patternSeparator;
00624 }
00625 
00626 // -------------------------------------
00627 
00628 inline UnicodeString&
00629 DecimalFormatSymbols::getInfinity(UnicodeString& result) const
00630 {
00631     return result = fSymbols[kInfinitySymbol];
00632 }
00633 
00634 // -------------------------------------
00635 
00636 inline void
00637 DecimalFormatSymbols::setInfinity(const UnicodeString& infinity)
00638 {
00639     fSymbols[kInfinitySymbol] = infinity;
00640 }
00641 
00642 // -------------------------------------
00643 
00644 inline int32_t
00645 DecimalFormatSymbols::compareInfinity(const UnicodeString& text,
00646                                       UTextOffset offset) const
00647 {
00648     int32_t symbolLength = fSymbols[kInfinitySymbol].length();
00649     return text.compare(offset,
00650                         symbolLength,
00651                         fSymbols[kInfinitySymbol],
00652                         0,
00653                         symbolLength)
00654            ? 0 : symbolLength;
00655 }
00656 
00657 // -------------------------------------
00658 
00659 inline UnicodeString&
00660 DecimalFormatSymbols::getNaN(UnicodeString& result) const
00661 {
00662     return result = fSymbols[kNaNSymbol];
00663 }
00664 
00665 // -------------------------------------
00666 
00667 inline void
00668 DecimalFormatSymbols::setNaN(const UnicodeString& NaN)
00669 {
00670     fSymbols[kNaNSymbol] = NaN;
00671 }
00672 
00673 // -------------------------------------
00674 
00675 inline int32_t
00676 DecimalFormatSymbols::compareNaN(const UnicodeString& text, UTextOffset offset) const
00677 {
00678     int32_t symbolLength = fSymbols[kNaNSymbol].length();
00679     return text.compare(offset,
00680                         symbolLength,
00681                         fSymbols[kNaNSymbol],
00682                         0,
00683                         symbolLength)
00684            ? 0 : symbolLength;
00685 }
00686 
00687 // -------------------------------------
00688 
00689 inline UChar
00690 DecimalFormatSymbols::getPlusSign() const
00691 {
00692     return fSymbols[kPlusSignSymbol].charAt(0);
00693 }
00694 
00695 // -------------------------------------
00696 
00697 inline void
00698 DecimalFormatSymbols::setPlusSign(UChar plusSign)
00699 {
00700     fSymbols[kPlusSignSymbol] = plusSign;
00701 }
00702 
00703 // -------------------------------------
00704 
00705 inline UChar
00706 DecimalFormatSymbols::getMinusSign() const
00707 {
00708     return fSymbols[kMinusSignSymbol].charAt(0);
00709 }
00710 
00711 // -------------------------------------
00712 
00713 inline void
00714 DecimalFormatSymbols::setMinusSign(UChar minusSign)
00715 {
00716     fSymbols[kMinusSignSymbol] = minusSign;
00717 }
00718 
00719 // -------------------------------------
00720 
00721 inline UChar
00722 DecimalFormatSymbols::getExponentialSymbol(void) const
00723 {
00724     return fSymbols[kExponentialSymbol].charAt(0);
00725 }
00726 
00727 // -------------------------------------
00728 
00729 inline void
00730 DecimalFormatSymbols::setExponentialSymbol(UChar exponential)
00731 {
00732     fSymbols[kExponentialSymbol] = exponential;
00733 }
00734 
00735 // -------------------------------------
00736 
00737 inline UnicodeString&
00738 DecimalFormatSymbols::getCurrencySymbol(UnicodeString& result) const
00739 {
00740     return result = fSymbols[kCurrencySymbol];
00741 }
00742 
00743 // -------------------------------------
00744 
00745 inline void
00746 DecimalFormatSymbols::setCurrencySymbol(const UnicodeString& str)
00747 {
00748     fSymbols[kCurrencySymbol] = str;
00749 }
00750 
00751 // -------------------------------------
00752 
00753 inline int32_t
00754 DecimalFormatSymbols::compareCurrencySymbol(const UnicodeString& text,
00755                                             UTextOffset offset) const
00756 {
00757     int32_t symbolLength = fSymbols[kCurrencySymbol].length();
00758     return text.compare(offset,
00759                         symbolLength,
00760                         fSymbols[kCurrencySymbol],
00761                         0,
00762                         symbolLength)
00763            ? 0 : symbolLength;
00764 }
00765 
00766 // -------------------------------------
00767 
00768 inline UnicodeString&
00769 DecimalFormatSymbols::getInternationalCurrencySymbol(UnicodeString& result) const
00770 {
00771     return result = fSymbols[kIntlCurrencySymbol];
00772 }
00773 
00774 // -------------------------------------
00775 
00776 inline void
00777 DecimalFormatSymbols::setInternationalCurrencySymbol(const UnicodeString& str)
00778 {
00779     fSymbols[kIntlCurrencySymbol] = str;
00780 }
00781 
00782 // -------------------------------------
00783 
00784 inline int32_t
00785 DecimalFormatSymbols::compareInternationalCurrencySymbol(const UnicodeString& text,
00786                                                          UTextOffset offset) const
00787 {
00788     int32_t symbolLength = fSymbols[kIntlCurrencySymbol].length();
00789     return text.compare(offset,
00790                         symbolLength,
00791                         fSymbols[kIntlCurrencySymbol],
00792                         0,
00793                         symbolLength)
00794            ? 0 : symbolLength;
00795 }
00796 
00797 // -------------------------------------
00798 
00799 inline UChar
00800 DecimalFormatSymbols::getMonetaryDecimalSeparator(void) const
00801 {
00802     return fSymbols[kMonetarySeparatorSymbol].charAt(0);
00803 }
00804 
00805 // -------------------------------------
00806 
00807 inline void
00808 DecimalFormatSymbols::setMonetaryDecimalSeparator(UChar sep)
00809 {
00810     fSymbols[kMonetarySeparatorSymbol] = sep;
00811 }
00812 
00813 inline UChar DecimalFormatSymbols::getPadEscape(void) const {
00814     return fSymbols[kPadEscapeSymbol].charAt(0);
00815 }
00816 
00817 inline void DecimalFormatSymbols::setPadEscape(UChar c) {
00818     fSymbols[kPadEscapeSymbol] = c;
00819 }
00820 #endif /* ICU_DECIMALFORMATSYMBOLS_USE_DEPRECATES */
00821 
00822 U_NAMESPACE_END
00823 
00824 #endif // _DCFMTSYM
00825 //eof

Generated on Sun Mar 10 02:53:59 2002 for ICU 2.0 by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002