Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

dcfmtsym.h

Go to the documentation of this file.
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 
00071 class U_I18N_API DecimalFormatSymbols {
00072 public:
00077     enum ENumberFormatSymbol {
00079         kDecimalSeparatorSymbol,
00081         kGroupingSeparatorSymbol,
00083         kPatternSeparatorSymbol,
00085         kPercentSymbol,
00087         kZeroDigitSymbol,
00089         kDigitSymbol,
00091         kMinusSignSymbol,
00093         kPlusSignSymbol,
00095         kCurrencySymbol,
00097         kIntlCurrencySymbol,
00099         kMonetarySeparatorSymbol,
00101         kExponentialSymbol,
00103         kPermillSymbol,
00105         kPadEscapeSymbol,
00107         kInfinitySymbol,
00109         kNaNSymbol,
00111         kFormatSymbolCount
00112     };
00113 
00122     DecimalFormatSymbols(const Locale& locale, UErrorCode& status);
00123 
00134     DecimalFormatSymbols( UErrorCode& status);
00135 
00140     DecimalFormatSymbols(const DecimalFormatSymbols&);
00141 
00146     DecimalFormatSymbols& operator=(const DecimalFormatSymbols&);
00147 
00152     ~DecimalFormatSymbols();
00153 
00158     UBool operator==(const DecimalFormatSymbols& other) const;
00159 
00164     UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
00165 
00172     UnicodeString getSymbol(ENumberFormatSymbol symbol) const;
00173 
00180     void setSymbol(ENumberFormatSymbol symbol, UnicodeString value);
00181 
00188     UChar getZeroDigit(void) const;
00195     void setZeroDigit(UChar zeroDigit);
00196 
00203     UChar getGroupingSeparator(void) const;
00210     void setGroupingSeparator(UChar groupingSeparator);
00211 
00218     UChar getDecimalSeparator(void) const;
00225     void setDecimalSeparator(UChar decimalSeparator);
00226 
00233     UChar getPerMill(void) const;
00240     void setPerMill(UChar permill);
00241 
00248     UChar getPercent(void) const;
00255     void setPercent(UChar percent);
00256 
00263     UChar getDigit(void) const;
00270     void setDigit(UChar digit);
00271 
00279     UChar getPatternSeparator(void) const;
00287     void setPatternSeparator(UChar patternSeparator);
00288 
00294     UnicodeString& getInfinity(UnicodeString& result) const;
00300     void setInfinity(const UnicodeString& infinity);
00307     int32_t compareInfinity(const UnicodeString& text, UTextOffset offset) const;
00308 
00314     UnicodeString& getNaN(UnicodeString& result) const;
00320     void setNaN(const UnicodeString& NaN);
00327     int32_t compareNaN(const UnicodeString& text, UTextOffset offset) const;
00328 
00335     UChar getPlusSign(void) const;
00342     void setPlusSign(UChar minusSign);
00343 
00352     UChar getMinusSign(void) const;
00361     void setMinusSign(UChar minusSign);
00362  
00370     UChar getExponentialSymbol(void) const;
00378     void setExponentialSymbol(UChar exponential);
00379 
00384     UnicodeString& getCurrencySymbol(UnicodeString& result) const;
00389     void setCurrencySymbol(const UnicodeString& currency);
00397     int32_t compareCurrencySymbol(const UnicodeString& text, UTextOffset offset) const;
00398 
00403     UnicodeString& getInternationalCurrencySymbol(UnicodeString& result) const;
00408     void setInternationalCurrencySymbol(const UnicodeString& currency);
00417     int32_t compareInternationalCurrencySymbol(const UnicodeString& text, UTextOffset offset) const;
00418 
00425     UChar getMonetaryDecimalSeparator(void) const;
00432     void setMonetaryDecimalSeparator(UChar sep);
00433 
00448     UChar getPadEscape(void) const;
00449 
00463     void setPadEscape(UChar c);
00464 
00465 private:
00471     void initialize(const Locale& locale, UErrorCode& success, UBool useLastResortData = FALSE);
00472 
00477     void initialize(const UnicodeString* numberElements, const UnicodeString* currencyElements);
00478 
00482     void initialize();
00483 
00484     UnicodeString fSymbols[kFormatSymbolCount];
00485 };
00486 
00487 
00488 // -------------------------------------
00489 
00490 inline UnicodeString
00491 DecimalFormatSymbols::getSymbol(ENumberFormatSymbol symbol) const {
00492     if(symbol<kFormatSymbolCount) {
00493         return fSymbols[symbol];
00494     } else {
00495         return UnicodeString();
00496     }
00497 }
00498 
00499 // -------------------------------------
00500 
00501 inline void
00502 DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, UnicodeString value) {
00503     if(symbol<kFormatSymbolCount) {
00504         fSymbols[symbol]=value;
00505     }
00506 }
00507 
00508 // -------------------------------------
00509 
00510 inline UChar
00511 DecimalFormatSymbols::getZeroDigit() const
00512 {
00513     return fSymbols[kZeroDigitSymbol].charAt(0);
00514 }
00515 
00516 // -------------------------------------
00517  
00518 inline void
00519 DecimalFormatSymbols::setZeroDigit(UChar zeroDigit)
00520 {
00521     fSymbols[kZeroDigitSymbol] = zeroDigit;
00522 }
00523 
00524 // -------------------------------------
00525 
00526 inline UChar
00527 DecimalFormatSymbols::getGroupingSeparator() const
00528 {
00529     return fSymbols[kGroupingSeparatorSymbol].charAt(0);
00530 }
00531 
00532 // -------------------------------------
00533 
00534 inline void
00535 DecimalFormatSymbols::setGroupingSeparator(UChar groupingSeparator)
00536 {
00537     fSymbols[kGroupingSeparatorSymbol] = groupingSeparator;
00538 }
00539 
00540 // -------------------------------------
00541 
00542 inline UChar
00543 DecimalFormatSymbols::getDecimalSeparator() const
00544 {
00545     return fSymbols[kDecimalSeparatorSymbol].charAt(0);
00546 }
00547 
00548 // -------------------------------------
00549 
00550 inline void
00551 DecimalFormatSymbols::setDecimalSeparator(UChar decimalSeparator)
00552 {
00553     fSymbols[kDecimalSeparatorSymbol] = decimalSeparator;
00554 }
00555 
00556 // -------------------------------------
00557 
00558 inline UChar
00559 DecimalFormatSymbols::getPerMill() const
00560 {
00561     return fSymbols[kPermillSymbol].charAt(0);
00562 }
00563 
00564 // -------------------------------------
00565 
00566 inline void
00567 DecimalFormatSymbols::setPerMill(UChar permill)
00568 {
00569     fSymbols[kPermillSymbol] = permill;
00570 }
00571 
00572 // -------------------------------------
00573 
00574 inline UChar
00575 DecimalFormatSymbols::getPercent() const
00576 {
00577     return fSymbols[kPercentSymbol].charAt(0);
00578 }
00579 
00580 // -------------------------------------
00581 
00582 inline void
00583 DecimalFormatSymbols::setPercent(UChar percent)
00584 {
00585     fSymbols[kPercentSymbol] = percent;
00586 }
00587 
00588 // -------------------------------------
00589 
00590 inline UChar
00591 DecimalFormatSymbols::getDigit() const
00592 {
00593     return fSymbols[kDigitSymbol].charAt(0);
00594 }
00595 
00596 // -------------------------------------
00597 
00598 inline void
00599 DecimalFormatSymbols::setDigit(UChar digit)
00600 {
00601     fSymbols[kDigitSymbol] = digit;
00602 }
00603 
00604 // -------------------------------------
00605 
00606 inline UChar
00607 DecimalFormatSymbols::getPatternSeparator() const
00608 {
00609     return fSymbols[kPatternSeparatorSymbol].charAt(0);
00610 }
00611 
00612 // -------------------------------------
00613 
00614 inline void
00615 DecimalFormatSymbols::setPatternSeparator(UChar patternSeparator)
00616 {
00617     fSymbols[kPatternSeparatorSymbol] = patternSeparator;
00618 }
00619 
00620 // -------------------------------------
00621 
00622 inline UnicodeString&
00623 DecimalFormatSymbols::getInfinity(UnicodeString& result) const
00624 {
00625     return result = fSymbols[kInfinitySymbol];
00626 }
00627 
00628 // -------------------------------------
00629 
00630 inline void
00631 DecimalFormatSymbols::setInfinity(const UnicodeString& infinity)
00632 {
00633     fSymbols[kInfinitySymbol] = infinity;
00634 }
00635 
00636 // -------------------------------------
00637 
00638 inline int32_t
00639 DecimalFormatSymbols::compareInfinity(const UnicodeString& text,
00640                                       UTextOffset offset) const
00641 {
00642     int32_t symbolLength = fSymbols[kInfinitySymbol].length();
00643     return text.compare(offset,
00644                         symbolLength,
00645                         fSymbols[kInfinitySymbol],
00646                         0,
00647                         symbolLength)
00648            ? 0 : symbolLength;
00649 }
00650 
00651 // -------------------------------------
00652 
00653 inline UnicodeString&
00654 DecimalFormatSymbols::getNaN(UnicodeString& result) const
00655 {
00656     return result = fSymbols[kNaNSymbol];
00657 }
00658 
00659 // -------------------------------------
00660 
00661 inline void
00662 DecimalFormatSymbols::setNaN(const UnicodeString& NaN)
00663 {
00664     fSymbols[kNaNSymbol] = NaN;
00665 }
00666 
00667 // -------------------------------------
00668 
00669 inline int32_t
00670 DecimalFormatSymbols::compareNaN(const UnicodeString& text, UTextOffset offset) const
00671 {
00672     int32_t symbolLength = fSymbols[kNaNSymbol].length();
00673     return text.compare(offset,
00674                         symbolLength,
00675                         fSymbols[kNaNSymbol],
00676                         0,
00677                         symbolLength)
00678            ? 0 : symbolLength;
00679 }
00680 
00681 // -------------------------------------
00682 
00683 inline UChar
00684 DecimalFormatSymbols::getPlusSign() const
00685 {
00686     return fSymbols[kPlusSignSymbol].charAt(0);
00687 }
00688 
00689 // -------------------------------------
00690 
00691 inline void
00692 DecimalFormatSymbols::setPlusSign(UChar plusSign)
00693 {
00694     fSymbols[kPlusSignSymbol] = plusSign;
00695 }
00696 
00697 // -------------------------------------
00698 
00699 inline UChar
00700 DecimalFormatSymbols::getMinusSign() const
00701 {
00702     return fSymbols[kMinusSignSymbol].charAt(0);
00703 }
00704 
00705 // -------------------------------------
00706 
00707 inline void
00708 DecimalFormatSymbols::setMinusSign(UChar minusSign)
00709 {
00710     fSymbols[kMinusSignSymbol] = minusSign;
00711 }
00712 
00713 // -------------------------------------
00714 
00715 inline UChar
00716 DecimalFormatSymbols::getExponentialSymbol(void) const
00717 {
00718     return fSymbols[kExponentialSymbol].charAt(0);
00719 }
00720 
00721 // -------------------------------------
00722 
00723 inline void
00724 DecimalFormatSymbols::setExponentialSymbol(UChar exponential)
00725 {
00726     fSymbols[kExponentialSymbol] = exponential;
00727 }
00728 
00729 // -------------------------------------
00730 
00731 inline UnicodeString&
00732 DecimalFormatSymbols::getCurrencySymbol(UnicodeString& result) const
00733 {
00734     return result = fSymbols[kCurrencySymbol];
00735 }
00736 
00737 // -------------------------------------
00738 
00739 inline void
00740 DecimalFormatSymbols::setCurrencySymbol(const UnicodeString& str)
00741 {
00742     fSymbols[kCurrencySymbol] = str;
00743 }
00744 
00745 // -------------------------------------
00746 
00747 inline int32_t
00748 DecimalFormatSymbols::compareCurrencySymbol(const UnicodeString& text,
00749                                             UTextOffset offset) const
00750 {
00751     int32_t symbolLength = fSymbols[kCurrencySymbol].length();
00752     return text.compare(offset,
00753                         symbolLength,
00754                         fSymbols[kCurrencySymbol],
00755                         0,
00756                         symbolLength)
00757            ? 0 : symbolLength;
00758 }
00759 
00760 // -------------------------------------
00761 
00762 inline UnicodeString&
00763 DecimalFormatSymbols::getInternationalCurrencySymbol(UnicodeString& result) const
00764 {
00765     return result = fSymbols[kIntlCurrencySymbol];
00766 }
00767 
00768 // -------------------------------------
00769 
00770 inline void
00771 DecimalFormatSymbols::setInternationalCurrencySymbol(const UnicodeString& str)
00772 {
00773     fSymbols[kIntlCurrencySymbol] = str;
00774 }
00775 
00776 // -------------------------------------
00777 
00778 inline int32_t
00779 DecimalFormatSymbols::compareInternationalCurrencySymbol(const UnicodeString& text,
00780                                                          UTextOffset offset) const
00781 {
00782     int32_t symbolLength = fSymbols[kIntlCurrencySymbol].length();
00783     return text.compare(offset,
00784                         symbolLength,
00785                         fSymbols[kIntlCurrencySymbol],
00786                         0,
00787                         symbolLength)
00788            ? 0 : symbolLength;
00789 }
00790 
00791 // -------------------------------------
00792 
00793 inline UChar
00794 DecimalFormatSymbols::getMonetaryDecimalSeparator(void) const
00795 {
00796     return fSymbols[kMonetarySeparatorSymbol].charAt(0);
00797 }
00798 
00799 // -------------------------------------
00800 
00801 inline void
00802 DecimalFormatSymbols::setMonetaryDecimalSeparator(UChar sep)
00803 {
00804     fSymbols[kMonetarySeparatorSymbol] = sep;
00805 }
00806 
00807 inline UChar DecimalFormatSymbols::getPadEscape(void) const {
00808     return fSymbols[kPadEscapeSymbol].charAt(0);
00809 }
00810 
00811 inline void DecimalFormatSymbols::setPadEscape(UChar c) {
00812     fSymbols[kPadEscapeSymbol] = c;
00813 }
00814 
00815 #endif // _DCFMTSYM
00816 //eof

Generated at Fri Dec 15 12:12:32 2000 for ICU 1.7 by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000