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