Home | History | Annotate | Download | only in unicode
      1 /*
      2 ********************************************************************************
      3 *   Copyright (C) 1997-2011, International Business Machines
      4 *   Corporation and others.  All Rights Reserved.
      5 ********************************************************************************
      6 *
      7 * File DCFMTSYM.H
      8 *
      9 * Modification History:
     10 *
     11 *   Date        Name        Description
     12 *   02/19/97    aliu        Converted from java.
     13 *   03/18/97    clhuang     Updated per C++ implementation.
     14 *   03/27/97    helena      Updated to pass the simple test after code review.
     15 *   08/26/97    aliu        Added currency/intl currency symbol support.
     16 *   07/22/98    stephen     Changed to match C++ style
     17 *                            currencySymbol -> fCurrencySymbol
     18 *                            Constants changed from CAPS to kCaps
     19 *   06/24/99    helena      Integrated Alan's NF enhancements and Java2 bug fixes
     20 *   09/22/00    grhoten     Marked deprecation tags with a pointer to replacement
     21 *                            functions.
     22 ********************************************************************************
     23 */
     24 
     25 #ifndef DCFMTSYM_H
     26 #define DCFMTSYM_H
     27 
     28 #include "unicode/utypes.h"
     29 #include "unicode/uchar.h"
     30 
     31 #if !UCONFIG_NO_FORMATTING
     32 
     33 #include "unicode/uobject.h"
     34 #include "unicode/locid.h"
     35 #include "unicode/unum.h"
     36 
     37 /**
     38  * \file
     39  * \brief C++ API: Symbols for formatting numbers.
     40  */
     41 
     42 
     43 U_NAMESPACE_BEGIN
     44 
     45 /**
     46  * This class represents the set of symbols needed by DecimalFormat
     47  * to format numbers. DecimalFormat creates for itself an instance of
     48  * DecimalFormatSymbols from its locale data.  If you need to change any
     49  * of these symbols, you can get the DecimalFormatSymbols object from
     50  * your DecimalFormat and modify it.
     51  * <P>
     52  * Here are the special characters used in the parts of the
     53  * subpattern, with notes on their usage.
     54  * <pre>
     55  * \code
     56  *        Symbol   Meaning
     57  *          0      a digit
     58  *          #      a digit, zero shows as absent
     59  *          .      placeholder for decimal separator
     60  *          ,      placeholder for grouping separator.
     61  *          ;      separates formats.
     62  *          -      default negative prefix.
     63  *          %      divide by 100 and show as percentage
     64  *          X      any other characters can be used in the prefix or suffix
     65  *          '      used to quote special characters in a prefix or suffix.
     66  * \endcode
     67  *  </pre>
     68  * [Notes]
     69  * <P>
     70  * If there is no explicit negative subpattern, - is prefixed to the
     71  * positive form. That is, "0.00" alone is equivalent to "0.00;-0.00".
     72  * <P>
     73  * The grouping separator is commonly used for thousands, but in some
     74  * countries for ten-thousands. The interval is a constant number of
     75  * digits between the grouping characters, such as 100,000,000 or 1,0000,0000.
     76  * If you supply a pattern with multiple grouping characters, the interval
     77  * between the last one and the end of the integer is the one that is
     78  * used. So "#,##,###,####" == "######,####" == "##,####,####".
     79  * <P>
     80  * This class only handles localized digits where the 10 digits are
     81  * contiguous in Unicode, from 0 to 9. Other digits sets (such as
     82  * superscripts) would need a different subclass.
     83  */
     84 class U_I18N_API DecimalFormatSymbols : public UObject {
     85 public:
     86     /**
     87      * Constants for specifying a number format symbol.
     88      * @stable ICU 2.0
     89      */
     90     enum ENumberFormatSymbol {
     91         /** The decimal separator */
     92         kDecimalSeparatorSymbol,
     93         /** The grouping separator */
     94         kGroupingSeparatorSymbol,
     95         /** The pattern separator */
     96         kPatternSeparatorSymbol,
     97         /** The percent sign */
     98         kPercentSymbol,
     99         /** Zero*/
    100         kZeroDigitSymbol,
    101         /** Character representing a digit in the pattern */
    102         kDigitSymbol,
    103         /** The minus sign */
    104         kMinusSignSymbol,
    105         /** The plus sign */
    106         kPlusSignSymbol,
    107         /** The currency symbol */
    108         kCurrencySymbol,
    109         /** The international currency symbol */
    110         kIntlCurrencySymbol,
    111         /** The monetary separator */
    112         kMonetarySeparatorSymbol,
    113         /** The exponential symbol */
    114         kExponentialSymbol,
    115         /** Per mill symbol - replaces kPermillSymbol */
    116         kPerMillSymbol,
    117         /** Escape padding character */
    118         kPadEscapeSymbol,
    119         /** Infinity symbol */
    120         kInfinitySymbol,
    121         /** Nan symbol */
    122         kNaNSymbol,
    123         /** Significant digit symbol
    124          * @stable ICU 3.0 */
    125         kSignificantDigitSymbol,
    126         /** The monetary grouping separator
    127          * @stable ICU 3.6
    128          */
    129         kMonetaryGroupingSeparatorSymbol,
    130         /** One
    131          * @draft ICU 4.6
    132          */
    133         kOneDigitSymbol,
    134         /** Two
    135          * @draft ICU 4.6
    136          */
    137         kTwoDigitSymbol,
    138         /** Three
    139          * @draft ICU 4.6
    140          */
    141         kThreeDigitSymbol,
    142         /** Four
    143          * @draft ICU 4.6
    144          */
    145         kFourDigitSymbol,
    146         /** Five
    147          * @draft ICU 4.6
    148          */
    149         kFiveDigitSymbol,
    150         /** Six
    151          * @draft ICU 4.6
    152          */
    153         kSixDigitSymbol,
    154         /** Seven
    155          * @draft ICU 4.6
    156          */
    157         kSevenDigitSymbol,
    158         /** Eight
    159          * @draft ICU 4.6
    160          */
    161         kEightDigitSymbol,
    162         /** Nine
    163          * @draft ICU 4.6
    164          */
    165         kNineDigitSymbol,
    166         /** count symbol constants */
    167         kFormatSymbolCount
    168     };
    169 
    170     /**
    171      * Create a DecimalFormatSymbols object for the given locale.
    172      *
    173      * @param locale    The locale to get symbols for.
    174      * @param status    Input/output parameter, set to success or
    175      *                  failure code upon return.
    176      * @stable ICU 2.0
    177      */
    178     DecimalFormatSymbols(const Locale& locale, UErrorCode& status);
    179 
    180     /**
    181      * Create a DecimalFormatSymbols object for the default locale.
    182      * This constructor will not fail.  If the resource file data is
    183      * not available, it will use hard-coded last-resort data and
    184      * set status to U_USING_FALLBACK_ERROR.
    185      *
    186      * @param status    Input/output parameter, set to success or
    187      *                  failure code upon return.
    188      * @stable ICU 2.0
    189      */
    190     DecimalFormatSymbols( UErrorCode& status);
    191 
    192     // BEGIN android-added: we need a default constructor for performance.
    193     // Proposed for ICU 4.8: http://icu-project.org/trac/ticket/7392
    194     DecimalFormatSymbols();
    195     // END android-added
    196 
    197     /**
    198      * Copy constructor.
    199      * @stable ICU 2.0
    200      */
    201     DecimalFormatSymbols(const DecimalFormatSymbols&);
    202 
    203     /**
    204      * Assignment operator.
    205      * @stable ICU 2.0
    206      */
    207     DecimalFormatSymbols& operator=(const DecimalFormatSymbols&);
    208 
    209     /**
    210      * Destructor.
    211      * @stable ICU 2.0
    212      */
    213     virtual ~DecimalFormatSymbols();
    214 
    215     /**
    216      * Return true if another object is semantically equal to this one.
    217      *
    218      * @param other    the object to be compared with.
    219      * @return         true if another object is semantically equal to this one.
    220      * @stable ICU 2.0
    221      */
    222     UBool operator==(const DecimalFormatSymbols& other) const;
    223 
    224     /**
    225      * Return true if another object is semantically unequal to this one.
    226      *
    227      * @param other    the object to be compared with.
    228      * @return         true if another object is semantically unequal to this one.
    229      * @stable ICU 2.0
    230      */
    231     UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
    232 
    233     /**
    234      * Get one of the format symbols by its enum constant.
    235      * Each symbol is stored as a string so that graphemes
    236      * (characters with modifier letters) can be used.
    237      *
    238      * @param symbol    Constant to indicate a number format symbol.
    239      * @return    the format symbols by the param 'symbol'
    240      * @stable ICU 2.0
    241      */
    242     inline UnicodeString getSymbol(ENumberFormatSymbol symbol) const;
    243 
    244     /**
    245      * Set one of the format symbols by its enum constant.
    246      * Each symbol is stored as a string so that graphemes
    247      * (characters with modifier letters) can be used.
    248      *
    249      * @param symbol    Constant to indicate a number format symbol.
    250      * @param value     value of the format symbol
    251      * @param propogateDigits If false, setting the zero digit will not automatically set 1-9.
    252      *     The default behavior is to automatically set 1-9 if zero is being set and the value
    253      *     it is being set to corresponds to a known Unicode zero digit.
    254      * @stable ICU 2.0
    255      */
    256     void setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propogateDigits);
    257 
    258     /**
    259      * Returns the locale for which this object was constructed.
    260      * @stable ICU 2.6
    261      */
    262     inline Locale getLocale() const;
    263 
    264     /**
    265      * Returns the locale for this object. Two flavors are available:
    266      * valid and actual locale.
    267      * @stable ICU 2.8
    268      */
    269     Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
    270 
    271     /**
    272       * Get pattern string for 'CurrencySpacing' that can be applied to
    273       * currency format.
    274       * This API gets the CurrencySpacing data from ResourceBundle. The pattern can
    275       * be empty if there is no data from current locale and its parent locales.
    276       *
    277       * @param type :  UNUM_CURRENCY_MATCH, UNUM_CURRENCY_SURROUNDING_MATCH or UNUM_CURRENCY_INSERT.
    278       * @param beforeCurrency : true if the pattern is for before currency symbol.
    279       *                         false if the pattern is for after currency symbol.
    280       * @param status: Input/output parameter, set to success or
    281       *                  failure code upon return.
    282       * @return pattern string for currencyMatch, surroundingMatch or spaceInsert.
    283       *     Return empty string if there is no data for this locale and its parent
    284       *     locales.
    285       * @draft ICU 4.8
    286       */
    287      const UnicodeString& getPatternForCurrencySpacing(UCurrencySpacing type,
    288                                                  UBool beforeCurrency,
    289                                                  UErrorCode& status) const;
    290      /**
    291        * Set pattern string for 'CurrencySpacing' that can be applied to
    292        * currency format.
    293        *
    294        * @param type : UNUM_CURRENCY_MATCH, UNUM_CURRENCY_SURROUNDING_MATCH or UNUM_CURRENCY_INSERT.
    295        * @param beforeCurrency : true if the pattern is for before currency symbol.
    296        *                         false if the pattern is for after currency symbol.
    297        * @param pattern : pattern string to override current setting.
    298        * @draft ICU 4.8
    299        */
    300      void setPatternForCurrencySpacing(UCurrencySpacing type,
    301                                        UBool beforeCurrency,
    302                                        const UnicodeString& pattern);
    303 
    304     /**
    305      * ICU "poor man's RTTI", returns a UClassID for the actual class.
    306      *
    307      * @stable ICU 2.2
    308      */
    309     virtual UClassID getDynamicClassID() const;
    310 
    311     /**
    312      * ICU "poor man's RTTI", returns a UClassID for this class.
    313      *
    314      * @stable ICU 2.2
    315      */
    316     static UClassID U_EXPORT2 getStaticClassID();
    317 
    318 private:
    319     // BEGIN android-removed: we need a default constructor for performance.
    320     // DecimalFormatSymbols(); // default constructor not implemented
    321     // END android-removed
    322 
    323     /**
    324      * Initializes the symbols from the LocaleElements resource bundle.
    325      * Note: The organization of LocaleElements badly needs to be
    326      * cleaned up.
    327      *
    328      * @param locale               The locale to get symbols for.
    329      * @param success              Input/output parameter, set to success or
    330      *                             failure code upon return.
    331      * @param useLastResortData    determine if use last resort data
    332      */
    333     void initialize(const Locale& locale, UErrorCode& success, UBool useLastResortData = FALSE);
    334 
    335     /**
    336      * Initialize the symbols with default values.
    337      */
    338     void initialize();
    339 
    340     void setCurrencyForSymbols();
    341 
    342 public:
    343     /**
    344      * _Internal_ function - more efficient version of getSymbol,
    345      * returning a const reference to one of the symbol strings.
    346      * The returned reference becomes invalid when the symbol is changed
    347      * or when the DecimalFormatSymbols are destroyed.
    348      * ### TODO markus 2002oct11: Consider proposing getConstSymbol() to be really public.
    349      *
    350      * @param symbol Constant to indicate a number format symbol.
    351      * @return the format symbol by the param 'symbol'
    352      * @internal
    353      */
    354     inline const UnicodeString &getConstSymbol(ENumberFormatSymbol symbol) const;
    355 
    356     /**
    357      * Returns that pattern stored in currecy info. Internal API for use by NumberFormat API.
    358      * @internal
    359      */
    360     inline const UChar* getCurrencyPattern(void) const;
    361 
    362 private:
    363     /**
    364      * Private symbol strings.
    365      * They are either loaded from a resource bundle or otherwise owned.
    366      * setSymbol() clones the symbol string.
    367      * Readonly aliases can only come from a resource bundle, so that we can always
    368      * use fastCopyFrom() with them.
    369      *
    370      * If DecimalFormatSymbols becomes subclassable and the status of fSymbols changes
    371      * from private to protected,
    372      * or when fSymbols can be set any other way that allows them to be readonly aliases
    373      * to non-resource bundle strings,
    374      * then regular UnicodeString copies must be used instead of fastCopyFrom().
    375      *
    376      * @internal
    377      */
    378     UnicodeString fSymbols[kFormatSymbolCount];
    379 
    380     /**
    381      * Non-symbol variable for getConstSymbol(). Always empty.
    382      * @internal
    383      */
    384     UnicodeString fNoSymbol;
    385 
    386     Locale locale;
    387 
    388     char actualLocale[ULOC_FULLNAME_CAPACITY];
    389     char validLocale[ULOC_FULLNAME_CAPACITY];
    390     const UChar* currPattern;
    391 
    392     UnicodeString currencySpcBeforeSym[UNUM_CURRENCY_SPACING_COUNT];
    393     UnicodeString currencySpcAfterSym[UNUM_CURRENCY_SPACING_COUNT];
    394 };
    395 
    396 // -------------------------------------
    397 
    398 inline UnicodeString
    399 DecimalFormatSymbols::getSymbol(ENumberFormatSymbol symbol) const {
    400     const UnicodeString *strPtr;
    401     if(symbol < kFormatSymbolCount) {
    402         strPtr = &fSymbols[symbol];
    403     } else {
    404         strPtr = &fNoSymbol;
    405     }
    406     return *strPtr;
    407 }
    408 
    409 inline const UnicodeString &
    410 DecimalFormatSymbols::getConstSymbol(ENumberFormatSymbol symbol) const {
    411     const UnicodeString *strPtr;
    412     if(symbol < kFormatSymbolCount) {
    413         strPtr = &fSymbols[symbol];
    414     } else {
    415         strPtr = &fNoSymbol;
    416     }
    417     return *strPtr;
    418 }
    419 
    420 // -------------------------------------
    421 
    422 inline void
    423 DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propogateDigits = TRUE) {
    424     if(symbol<kFormatSymbolCount) {
    425         fSymbols[symbol]=value;
    426     }
    427 
    428     // If the zero digit is being set to a known zero digit according to Unicode,
    429     // then we automatically set the corresponding 1-9 digits
    430     if ( propogateDigits && symbol == kZeroDigitSymbol && value.countChar32() == 1 ) {
    431         UChar32 sym = value.char32At(0);
    432         if ( u_charDigitValue(sym) == 0 ) {
    433             for ( int8_t i = 1 ; i<= 9 ; i++ ) {
    434                 sym++;
    435                 fSymbols[(int)kOneDigitSymbol+i-1] = UnicodeString(sym);
    436             }
    437         }
    438     }
    439 }
    440 
    441 // -------------------------------------
    442 
    443 inline Locale
    444 DecimalFormatSymbols::getLocale() const {
    445     return locale;
    446 }
    447 
    448 inline const UChar*
    449 DecimalFormatSymbols::getCurrencyPattern() const {
    450     return currPattern;
    451 }
    452 U_NAMESPACE_END
    453 
    454 #endif /* #if !UCONFIG_NO_FORMATTING */
    455 
    456 #endif // _DCFMTSYM
    457 //eof
    458