icuSources/i18n/unicode/dcfmtsym.h

   1 /*
   2 ********************************************************************************
   3 *   Copyright (C) 1997-2016, 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          * @stable ICU 4.6
 132          */
 133         kOneDigitSymbol,
 134         /** Two
 135          * @stable ICU 4.6
 136          */
 137         kTwoDigitSymbol,
 138         /** Three
 139          * @stable ICU 4.6
 140          */
 141         kThreeDigitSymbol,
 142         /** Four
 143          * @stable ICU 4.6
 144          */
 145         kFourDigitSymbol,
 146         /** Five
 147          * @stable ICU 4.6
 148          */
 149         kFiveDigitSymbol,
 150         /** Six
 151          * @stable ICU 4.6
 152          */
 153         kSixDigitSymbol,
 154         /** Seven
 155          * @stable ICU 4.6
 156          */
 157         kSevenDigitSymbol,
 158         /** Eight
 159          * @stable ICU 4.6
 160          */
 161         kEightDigitSymbol,
 162         /** Nine
 163          * @stable ICU 4.6
 164          */
 165         kNineDigitSymbol,
 166         /** Multiplication sign.
 167          * @stable ICU 54
 168          */
 169         kExponentMultiplicationSymbol,
 170         /** count symbol constants */
 171         kFormatSymbolCount = kNineDigitSymbol + 2
 172     };
 173
 174     /**
 175      * Create a DecimalFormatSymbols object for the given locale.
 176      *
 177      * @param locale    The locale to get symbols for.
 178      * @param status    Input/output parameter, set to success or
 179      *                  failure code upon return.
 180      * @stable ICU 2.0
 181      */
 182     DecimalFormatSymbols(const Locale& locale, UErrorCode& status);
 183
 184     /**
 185      * Create a DecimalFormatSymbols object for the default locale.
 186      * This constructor will not fail.  If the resource file data is
 187      * not available, it will use hard-coded last-resort data and
 188      * set status to U_USING_FALLBACK_ERROR.
 189      *
 190      * @param status    Input/output parameter, set to success or
 191      *                  failure code upon return.
 192      * @stable ICU 2.0
 193      */
 194     DecimalFormatSymbols(UErrorCode& status);
 195
 196     /**
 197      * Creates a DecimalFormatSymbols object with last-resort data.
 198      * Intended for callers who cache the symbols data and
 199      * set all symbols on the resulting object.
 200      *
 201      * The last-resort symbols are similar to those for the root data,
 202      * except that the grouping separators are empty,
 203      * the NaN symbol is U+FFFD rather than "NaN",
 204      * and the CurrencySpacing patterns are empty.
 205      *
 206      * @param status    Input/output parameter, set to success or
 207      *                  failure code upon return.
 208      * @return last-resort symbols
 209      * @stable ICU 52
 210      */
 211     static DecimalFormatSymbols* createWithLastResortData(UErrorCode& status);
 212
 213     /**
 214      * Copy constructor.
 215      * @stable ICU 2.0
 216      */
 217     DecimalFormatSymbols(const DecimalFormatSymbols&);
 218
 219     /**
 220      * Assignment operator.
 221      * @stable ICU 2.0
 222      */
 223     DecimalFormatSymbols& operator=(const DecimalFormatSymbols&);
 224
 225     /**
 226      * Destructor.
 227      * @stable ICU 2.0
 228      */
 229     virtual ~DecimalFormatSymbols();
 230
 231     /**
 232      * Return true if another object is semantically equal to this one.
 233      *
 234      * @param other    the object to be compared with.
 235      * @return         true if another object is semantically equal to this one.
 236      * @stable ICU 2.0
 237      */
 238     UBool operator==(const DecimalFormatSymbols& other) const;
 239
 240     /**
 241      * Return true if another object is semantically unequal to this one.
 242      *
 243      * @param other    the object to be compared with.
 244      * @return         true if another object is semantically unequal to this one.
 245      * @stable ICU 2.0
 246      */
 247     UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
 248
 249     /**
 250      * Get one of the format symbols by its enum constant.
 251      * Each symbol is stored as a string so that graphemes
 252      * (characters with modifier letters) can be used.
 253      *
 254      * @param symbol    Constant to indicate a number format symbol.
 255      * @return    the format symbols by the param 'symbol'
 256      * @stable ICU 2.0
 257      */
 258     inline UnicodeString getSymbol(ENumberFormatSymbol symbol) const;
 259
 260     /**
 261      * Set one of the format symbols by its enum constant.
 262      * Each symbol is stored as a string so that graphemes
 263      * (characters with modifier letters) can be used.
 264      *
 265      * @param symbol    Constant to indicate a number format symbol.
 266      * @param value     value of the format symbol
 267      * @param propogateDigits If false, setting the zero digit will not automatically set 1-9.
 268      *     The default behavior is to automatically set 1-9 if zero is being set and the value
 269      *     it is being set to corresponds to a known Unicode zero digit.
 270      * @stable ICU 2.0
 271      */
 272     void setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propogateDigits);
 273
 274     /**
 275      * Returns the locale for which this object was constructed.
 276      * @stable ICU 2.6
 277      */
 278     inline Locale getLocale() const;
 279
 280     /**
 281      * Returns the locale for this object. Two flavors are available:
 282      * valid and actual locale.
 283      * @stable ICU 2.8
 284      */
 285     Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
 286
 287     /**
 288       * Get pattern string for 'CurrencySpacing' that can be applied to
 289       * currency format.
 290       * This API gets the CurrencySpacing data from ResourceBundle. The pattern can
 291       * be empty if there is no data from current locale and its parent locales.
 292       *
 293       * @param type :  UNUM_CURRENCY_MATCH, UNUM_CURRENCY_SURROUNDING_MATCH or UNUM_CURRENCY_INSERT.
 294       * @param beforeCurrency : true if the pattern is for before currency symbol.
 295       *                         false if the pattern is for after currency symbol.
 296       * @param status: Input/output parameter, set to success or
 297       *                  failure code upon return.
 298       * @return pattern string for currencyMatch, surroundingMatch or spaceInsert.
 299       *     Return empty string if there is no data for this locale and its parent
 300       *     locales.
 301       * @stable ICU 4.8
 302       */
 303      const UnicodeString& getPatternForCurrencySpacing(UCurrencySpacing type,
 304                                                  UBool beforeCurrency,
 305                                                  UErrorCode& status) const;
 306      /**
 307        * Set pattern string for 'CurrencySpacing' that can be applied to
 308        * currency format.
 309        *
 310        * @param type : UNUM_CURRENCY_MATCH, UNUM_CURRENCY_SURROUNDING_MATCH or UNUM_CURRENCY_INSERT.
 311        * @param beforeCurrency : true if the pattern is for before currency symbol.
 312        *                         false if the pattern is for after currency symbol.
 313        * @param pattern : pattern string to override current setting.
 314        * @stable ICU 4.8
 315        */
 316      void setPatternForCurrencySpacing(UCurrencySpacing type,
 317                                        UBool beforeCurrency,
 318                                        const UnicodeString& pattern);
 319
 320     /**
 321      * ICU "poor man's RTTI", returns a UClassID for the actual class.
 322      *
 323      * @stable ICU 2.2
 324      */
 325     virtual UClassID getDynamicClassID() const;
 326
 327     /**
 328      * ICU "poor man's RTTI", returns a UClassID for this class.
 329      *
 330      * @stable ICU 2.2
 331      */
 332     static UClassID U_EXPORT2 getStaticClassID();
 333
 334 private:
 335     DecimalFormatSymbols();
 336
 337     /**
 338      * Initializes the symbols from the LocaleElements resource bundle.
 339      * Note: The organization of LocaleElements badly needs to be
 340      * cleaned up.
 341      *
 342      * @param locale               The locale to get symbols for.
 343      * @param success              Input/output parameter, set to success or
 344      *                             failure code upon return.
 345      * @param useLastResortData    determine if use last resort data
 346      */
 347     void initialize(const Locale& locale, UErrorCode& success, UBool useLastResortData = FALSE);
 348
 349     /**
 350      * Initialize the symbols with default values.
 351      */
 352     void initialize();
 353
 354     void setCurrencyForSymbols();
 355
 356 public:
 357
 358 #ifndef U_HIDE_INTERNAL_API
 359     /**
 360      * @internal For ICU use only
 361      */
 362     inline UBool isCustomCurrencySymbol() const {
 363         return fIsCustomCurrencySymbol;
 364     }
 365
 366     /**
 367      * @internal For ICU use only
 368      */
 369     inline UBool isCustomIntlCurrencySymbol() const {
 370         return fIsCustomIntlCurrencySymbol;
 371     }
 372 #endif  /* U_HIDE_INTERNAL_API */
 373
 374     /**
 375      * _Internal_ function - more efficient version of getSymbol,
 376      * returning a const reference to one of the symbol strings.
 377      * The returned reference becomes invalid when the symbol is changed
 378      * or when the DecimalFormatSymbols are destroyed.
 379      * ### TODO markus 2002oct11: Consider proposing getConstSymbol() to be really public.
 380      * Note: moved #ifndef U_HIDE_INTERNAL_API after this, since this is needed for inline in DecimalFormat
 381      *
 382      * @param symbol Constant to indicate a number format symbol.
 383      * @return the format symbol by the param 'symbol'
 384      * @internal
 385      */
 386     inline const UnicodeString &getConstSymbol(ENumberFormatSymbol symbol) const;
 387
 388 #ifndef U_HIDE_INTERNAL_API
 389     /**
 390      * Returns that pattern stored in currecy info. Internal API for use by NumberFormat API.
 391      * @internal
 392      */
 393     inline const UChar* getCurrencyPattern(void) const;
 394 #endif  /* U_HIDE_INTERNAL_API */
 395
 396 private:
 397     /**
 398      * Private symbol strings.
 399      * They are either loaded from a resource bundle or otherwise owned.
 400      * setSymbol() clones the symbol string.
 401      * Readonly aliases can only come from a resource bundle, so that we can always
 402      * use fastCopyFrom() with them.
 403      *
 404      * If DecimalFormatSymbols becomes subclassable and the status of fSymbols changes
 405      * from private to protected,
 406      * or when fSymbols can be set any other way that allows them to be readonly aliases
 407      * to non-resource bundle strings,
 408      * then regular UnicodeString copies must be used instead of fastCopyFrom().
 409      *
 410      * @internal
 411      */
 412     UnicodeString fSymbols[kFormatSymbolCount];
 413
 414     /**
 415      * Non-symbol variable for getConstSymbol(). Always empty.
 416      * @internal
 417      */
 418     UnicodeString fNoSymbol;
 419
 420     Locale locale;
 421
 422     char actualLocale[ULOC_FULLNAME_CAPACITY];
 423     char validLocale[ULOC_FULLNAME_CAPACITY];
 424     const UChar* currPattern;
 425
 426     UnicodeString currencySpcBeforeSym[UNUM_CURRENCY_SPACING_COUNT];
 427     UnicodeString currencySpcAfterSym[UNUM_CURRENCY_SPACING_COUNT];
 428     UBool fIsCustomCurrencySymbol;
 429     UBool fIsCustomIntlCurrencySymbol;
 430 };
 431
 432 // -------------------------------------
 433
 434 inline UnicodeString
 435 DecimalFormatSymbols::getSymbol(ENumberFormatSymbol symbol) const {
 436     const UnicodeString *strPtr;
 437     if(symbol < kFormatSymbolCount) {
 438         strPtr = &fSymbols[symbol];
 439     } else {
 440         strPtr = &fNoSymbol;
 441     }
 442     return *strPtr;
 443 }
 444
 445 // See comments above for this function. Not hidden with #ifndef U_HIDE_INTERNAL_API
 446 inline const UnicodeString &
 447 DecimalFormatSymbols::getConstSymbol(ENumberFormatSymbol symbol) const {
 448     const UnicodeString *strPtr;
 449     if(symbol < kFormatSymbolCount) {
 450         strPtr = &fSymbols[symbol];
 451     } else {
 452         strPtr = &fNoSymbol;
 453     }
 454     return *strPtr;
 455 }
 456
 457 // -------------------------------------
 458
 459 inline void
 460 DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propogateDigits = TRUE) {
 461     if (symbol == kCurrencySymbol) {
 462         fIsCustomCurrencySymbol = TRUE;
 463     }
 464     else if (symbol == kIntlCurrencySymbol) {
 465         fIsCustomIntlCurrencySymbol = TRUE;
 466     }
 467     if(symbol<kFormatSymbolCount) {
 468         fSymbols[symbol]=value;
 469     }
 470
 471     // If the zero digit is being set to a known zero digit according to Unicode,
 472     // then we automatically set the corresponding 1-9 digits
 473     if ( propogateDigits && symbol == kZeroDigitSymbol && value.countChar32() == 1 ) {
 474         UChar32 sym = value.char32At(0);
 475         if ( u_charDigitValue(sym) == 0 ) {
 476             for ( int8_t i = 1 ; i<= 9 ; i++ ) {
 477                 sym++;
 478                 fSymbols[(int)kOneDigitSymbol+i-1] = UnicodeString(sym);
 479             }
 480         }
 481     }
 482 }
 483
 484 // -------------------------------------
 485
 486 inline Locale
 487 DecimalFormatSymbols::getLocale() const {
 488     return locale;
 489 }
 490
 491 #ifndef U_HIDE_INTERNAL_API
 492 inline const UChar*
 493 DecimalFormatSymbols::getCurrencyPattern() const {
 494     return currPattern;
 495 }
 496 #endif /* U_HIDE_INTERNAL_API */
 497
 498 U_NAMESPACE_END
 499
 500 #endif /* #if !UCONFIG_NO_FORMATTING */
 501
 502 #endif // _DCFMTSYM
 503 //eof