Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/unicode/dcfmtsym.h @ 69:33d812a61356

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
author jpayne
date Tue, 18 Mar 2025 17:55:14 -0400
parents
children
comparison
equal deleted inserted replaced
67:0e9998148a16 69:33d812a61356
1 // © 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
32 #if U_SHOW_CPLUSPLUS_API
33
34 #if !UCONFIG_NO_FORMATTING
35
36 #include "unicode/uchar.h"
37 #include "unicode/uobject.h"
38 #include "unicode/locid.h"
39 #include "unicode/numsys.h"
40 #include "unicode/unum.h"
41 #include "unicode/unistr.h"
42
43 /**
44 * \file
45 * \brief C++ API: Symbols for formatting numbers.
46 */
47
48
49 U_NAMESPACE_BEGIN
50
51 /**
52 * This class represents the set of symbols needed by DecimalFormat
53 * to format numbers. DecimalFormat creates for itself an instance of
54 * DecimalFormatSymbols from its locale data. If you need to change any
55 * of these symbols, you can get the DecimalFormatSymbols object from
56 * your DecimalFormat and modify it.
57 * <P>
58 * Here are the special characters used in the parts of the
59 * subpattern, with notes on their usage.
60 * <pre>
61 * \code
62 * Symbol Meaning
63 * 0 a digit
64 * # a digit, zero shows as absent
65 * . placeholder for decimal separator
66 * , placeholder for grouping separator.
67 * ; separates formats.
68 * - default negative prefix.
69 * % divide by 100 and show as percentage
70 * X any other characters can be used in the prefix or suffix
71 * ' used to quote special characters in a prefix or suffix.
72 * \endcode
73 * </pre>
74 * [Notes]
75 * <P>
76 * If there is no explicit negative subpattern, - is prefixed to the
77 * positive form. That is, "0.00" alone is equivalent to "0.00;-0.00".
78 * <P>
79 * The grouping separator is commonly used for thousands, but in some
80 * countries for ten-thousands. The interval is a constant number of
81 * digits between the grouping characters, such as 100,000,000 or 1,0000,0000.
82 * If you supply a pattern with multiple grouping characters, the interval
83 * between the last one and the end of the integer is the one that is
84 * used. So "#,##,###,####" == "######,####" == "##,####,####".
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 * Creates a DecimalFormatSymbols instance for the given locale with digits and symbols
188 * corresponding to the given NumberingSystem.
189 *
190 * This constructor behaves equivalently to the normal constructor called with a locale having a
191 * "numbers=xxxx" keyword specifying the numbering system by name.
192 *
193 * In this constructor, the NumberingSystem argument will be used even if the locale has its own
194 * "numbers=xxxx" keyword.
195 *
196 * @param locale The locale to get symbols for.
197 * @param ns The numbering system.
198 * @param status Input/output parameter, set to success or
199 * failure code upon return.
200 * @stable ICU 60
201 */
202 DecimalFormatSymbols(const Locale& locale, const NumberingSystem& ns, UErrorCode& status);
203
204 /**
205 * Create a DecimalFormatSymbols object for the default locale.
206 * This constructor will not fail. If the resource file data is
207 * not available, it will use hard-coded last-resort data and
208 * set status to U_USING_FALLBACK_ERROR.
209 *
210 * @param status Input/output parameter, set to success or
211 * failure code upon return.
212 * @stable ICU 2.0
213 */
214 DecimalFormatSymbols(UErrorCode& status);
215
216 /**
217 * Creates a DecimalFormatSymbols object with last-resort data.
218 * Intended for callers who cache the symbols data and
219 * set all symbols on the resulting object.
220 *
221 * The last-resort symbols are similar to those for the root data,
222 * except that the grouping separators are empty,
223 * the NaN symbol is U+FFFD rather than "NaN",
224 * and the CurrencySpacing patterns are empty.
225 *
226 * @param status Input/output parameter, set to success or
227 * failure code upon return.
228 * @return last-resort symbols
229 * @stable ICU 52
230 */
231 static DecimalFormatSymbols* createWithLastResortData(UErrorCode& status);
232
233 /**
234 * Copy constructor.
235 * @stable ICU 2.0
236 */
237 DecimalFormatSymbols(const DecimalFormatSymbols&);
238
239 /**
240 * Assignment operator.
241 * @stable ICU 2.0
242 */
243 DecimalFormatSymbols& operator=(const DecimalFormatSymbols&);
244
245 /**
246 * Destructor.
247 * @stable ICU 2.0
248 */
249 virtual ~DecimalFormatSymbols();
250
251 /**
252 * Return true if another object is semantically equal to this one.
253 *
254 * @param other the object to be compared with.
255 * @return true if another object is semantically equal to this one.
256 * @stable ICU 2.0
257 */
258 UBool operator==(const DecimalFormatSymbols& other) const;
259
260 /**
261 * Return true if another object is semantically unequal to this one.
262 *
263 * @param other the object to be compared with.
264 * @return true if another object is semantically unequal to this one.
265 * @stable ICU 2.0
266 */
267 UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
268
269 /**
270 * Get one of the format symbols by its enum constant.
271 * Each symbol is stored as a string so that graphemes
272 * (characters with modifier letters) can be used.
273 *
274 * @param symbol Constant to indicate a number format symbol.
275 * @return the format symbols by the param 'symbol'
276 * @stable ICU 2.0
277 */
278 inline UnicodeString getSymbol(ENumberFormatSymbol symbol) const;
279
280 /**
281 * Set one of the format symbols by its enum constant.
282 * Each symbol is stored as a string so that graphemes
283 * (characters with modifier letters) can be used.
284 *
285 * @param symbol Constant to indicate a number format symbol.
286 * @param value value of the format symbol
287 * @param propogateDigits If false, setting the zero digit will not automatically set 1-9.
288 * The default behavior is to automatically set 1-9 if zero is being set and the value
289 * it is being set to corresponds to a known Unicode zero digit.
290 * @stable ICU 2.0
291 */
292 void setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propogateDigits);
293
294 #ifndef U_HIDE_INTERNAL_API
295 /**
296 * Loads symbols for the specified currency into this instance.
297 *
298 * This method is internal. If you think it should be public, file a ticket.
299 *
300 * @internal
301 */
302 void setCurrency(const UChar* currency, UErrorCode& status);
303 #endif // U_HIDE_INTERNAL_API
304
305 /**
306 * Returns the locale for which this object was constructed.
307 * @stable ICU 2.6
308 */
309 inline Locale getLocale() const;
310
311 /**
312 * Returns the locale for this object. Two flavors are available:
313 * valid and actual locale.
314 * @stable ICU 2.8
315 */
316 Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
317
318 /**
319 * Get pattern string for 'CurrencySpacing' that can be applied to
320 * currency format.
321 * This API gets the CurrencySpacing data from ResourceBundle. The pattern can
322 * be empty if there is no data from current locale and its parent locales.
323 *
324 * @param type : UNUM_CURRENCY_MATCH, UNUM_CURRENCY_SURROUNDING_MATCH or UNUM_CURRENCY_INSERT.
325 * @param beforeCurrency : true if the pattern is for before currency symbol.
326 * false if the pattern is for after currency symbol.
327 * @param status: Input/output parameter, set to success or
328 * failure code upon return.
329 * @return pattern string for currencyMatch, surroundingMatch or spaceInsert.
330 * Return empty string if there is no data for this locale and its parent
331 * locales.
332 * @stable ICU 4.8
333 */
334 const UnicodeString& getPatternForCurrencySpacing(UCurrencySpacing type,
335 UBool beforeCurrency,
336 UErrorCode& status) const;
337 /**
338 * Set pattern string for 'CurrencySpacing' that can be applied to
339 * currency format.
340 *
341 * @param type : UNUM_CURRENCY_MATCH, UNUM_CURRENCY_SURROUNDING_MATCH or UNUM_CURRENCY_INSERT.
342 * @param beforeCurrency : true if the pattern is for before currency symbol.
343 * false if the pattern is for after currency symbol.
344 * @param pattern : pattern string to override current setting.
345 * @stable ICU 4.8
346 */
347 void setPatternForCurrencySpacing(UCurrencySpacing type,
348 UBool beforeCurrency,
349 const UnicodeString& pattern);
350
351 /**
352 * ICU "poor man's RTTI", returns a UClassID for the actual class.
353 *
354 * @stable ICU 2.2
355 */
356 virtual UClassID getDynamicClassID() const;
357
358 /**
359 * ICU "poor man's RTTI", returns a UClassID for this class.
360 *
361 * @stable ICU 2.2
362 */
363 static UClassID U_EXPORT2 getStaticClassID();
364
365 private:
366 DecimalFormatSymbols();
367
368 /**
369 * Initializes the symbols from the LocaleElements resource bundle.
370 * Note: The organization of LocaleElements badly needs to be
371 * cleaned up.
372 *
373 * @param locale The locale to get symbols for.
374 * @param success Input/output parameter, set to success or
375 * failure code upon return.
376 * @param useLastResortData determine if use last resort data
377 * @param ns The NumberingSystem to use; otherwise, fall
378 * back to the locale.
379 */
380 void initialize(const Locale& locale, UErrorCode& success,
381 UBool useLastResortData = FALSE, const NumberingSystem* ns = nullptr);
382
383 /**
384 * Initialize the symbols with default values.
385 */
386 void initialize();
387
388 public:
389
390 #ifndef U_HIDE_INTERNAL_API
391 /**
392 * @internal For ICU use only
393 */
394 inline UBool isCustomCurrencySymbol() const {
395 return fIsCustomCurrencySymbol;
396 }
397
398 /**
399 * @internal For ICU use only
400 */
401 inline UBool isCustomIntlCurrencySymbol() const {
402 return fIsCustomIntlCurrencySymbol;
403 }
404
405 /**
406 * @internal For ICU use only
407 */
408 inline UChar32 getCodePointZero() const {
409 return fCodePointZero;
410 }
411 #endif /* U_HIDE_INTERNAL_API */
412
413 /**
414 * _Internal_ function - more efficient version of getSymbol,
415 * returning a const reference to one of the symbol strings.
416 * The returned reference becomes invalid when the symbol is changed
417 * or when the DecimalFormatSymbols are destroyed.
418 * Note: moved \#ifndef U_HIDE_INTERNAL_API after this, since this is needed for inline in DecimalFormat
419 *
420 * This is not currently stable API, but if you think it should be stable,
421 * post a comment on the following ticket and the ICU team will take a look:
422 * http://bugs.icu-project.org/trac/ticket/13580
423 *
424 * @param symbol Constant to indicate a number format symbol.
425 * @return the format symbol by the param 'symbol'
426 * @internal
427 */
428 inline const UnicodeString& getConstSymbol(ENumberFormatSymbol symbol) const;
429
430 #ifndef U_HIDE_INTERNAL_API
431 /**
432 * Returns the const UnicodeString reference, like getConstSymbol,
433 * corresponding to the digit with the given value. This is equivalent
434 * to accessing the symbol from getConstSymbol with the corresponding
435 * key, such as kZeroDigitSymbol or kOneDigitSymbol.
436 *
437 * This is not currently stable API, but if you think it should be stable,
438 * post a comment on the following ticket and the ICU team will take a look:
439 * http://bugs.icu-project.org/trac/ticket/13580
440 *
441 * @param digit The digit, an integer between 0 and 9 inclusive.
442 * If outside the range 0 to 9, the zero digit is returned.
443 * @return the format symbol for the given digit.
444 * @internal This API is currently for ICU use only.
445 */
446 inline const UnicodeString& getConstDigitSymbol(int32_t digit) const;
447
448 /**
449 * Returns that pattern stored in currecy info. Internal API for use by NumberFormat API.
450 * @internal
451 */
452 inline const char16_t* getCurrencyPattern(void) const;
453 #endif /* U_HIDE_INTERNAL_API */
454
455 private:
456 /**
457 * Private symbol strings.
458 * They are either loaded from a resource bundle or otherwise owned.
459 * setSymbol() clones the symbol string.
460 * Readonly aliases can only come from a resource bundle, so that we can always
461 * use fastCopyFrom() with them.
462 *
463 * If DecimalFormatSymbols becomes subclassable and the status of fSymbols changes
464 * from private to protected,
465 * or when fSymbols can be set any other way that allows them to be readonly aliases
466 * to non-resource bundle strings,
467 * then regular UnicodeString copies must be used instead of fastCopyFrom().
468 *
469 */
470 UnicodeString fSymbols[kFormatSymbolCount];
471
472 /**
473 * Non-symbol variable for getConstSymbol(). Always empty.
474 */
475 UnicodeString fNoSymbol;
476
477 /**
478 * Dealing with code points is faster than dealing with strings when formatting. Because of
479 * this, we maintain a value containing the zero code point that is used whenever digitStrings
480 * represents a sequence of ten code points in order.
481 *
482 * <p>If the value stored here is positive, it means that the code point stored in this value
483 * corresponds to the digitStrings array, and codePointZero can be used instead of the
484 * digitStrings array for the purposes of efficient formatting; if -1, then digitStrings does
485 * *not* contain a sequence of code points, and it must be used directly.
486 *
487 * <p>It is assumed that codePointZero always shadows the value in digitStrings. codePointZero
488 * should never be set directly; rather, it should be updated only when digitStrings mutates.
489 * That is, the flow of information is digitStrings -> codePointZero, not the other way.
490 */
491 UChar32 fCodePointZero;
492
493 Locale locale;
494
495 char actualLocale[ULOC_FULLNAME_CAPACITY];
496 char validLocale[ULOC_FULLNAME_CAPACITY];
497 const char16_t* currPattern;
498
499 UnicodeString currencySpcBeforeSym[UNUM_CURRENCY_SPACING_COUNT];
500 UnicodeString currencySpcAfterSym[UNUM_CURRENCY_SPACING_COUNT];
501 UBool fIsCustomCurrencySymbol;
502 UBool fIsCustomIntlCurrencySymbol;
503 };
504
505 // -------------------------------------
506
507 inline UnicodeString
508 DecimalFormatSymbols::getSymbol(ENumberFormatSymbol symbol) const {
509 const UnicodeString *strPtr;
510 if(symbol < kFormatSymbolCount) {
511 strPtr = &fSymbols[symbol];
512 } else {
513 strPtr = &fNoSymbol;
514 }
515 return *strPtr;
516 }
517
518 // See comments above for this function. Not hidden with #ifdef U_HIDE_INTERNAL_API
519 inline const UnicodeString &
520 DecimalFormatSymbols::getConstSymbol(ENumberFormatSymbol symbol) const {
521 const UnicodeString *strPtr;
522 if(symbol < kFormatSymbolCount) {
523 strPtr = &fSymbols[symbol];
524 } else {
525 strPtr = &fNoSymbol;
526 }
527 return *strPtr;
528 }
529
530 #ifndef U_HIDE_INTERNAL_API
531 inline const UnicodeString& DecimalFormatSymbols::getConstDigitSymbol(int32_t digit) const {
532 if (digit < 0 || digit > 9) {
533 digit = 0;
534 }
535 if (digit == 0) {
536 return fSymbols[kZeroDigitSymbol];
537 }
538 ENumberFormatSymbol key = static_cast<ENumberFormatSymbol>(kOneDigitSymbol + digit - 1);
539 return fSymbols[key];
540 }
541 #endif /* U_HIDE_INTERNAL_API */
542
543 // -------------------------------------
544
545 inline void
546 DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value, const UBool propogateDigits = TRUE) {
547 if (symbol == kCurrencySymbol) {
548 fIsCustomCurrencySymbol = TRUE;
549 }
550 else if (symbol == kIntlCurrencySymbol) {
551 fIsCustomIntlCurrencySymbol = TRUE;
552 }
553 if(symbol<kFormatSymbolCount) {
554 fSymbols[symbol]=value;
555 }
556
557 // If the zero digit is being set to a known zero digit according to Unicode,
558 // then we automatically set the corresponding 1-9 digits
559 // Also record updates to fCodePointZero. Be conservative if in doubt.
560 if (symbol == kZeroDigitSymbol) {
561 UChar32 sym = value.char32At(0);
562 if ( propogateDigits && u_charDigitValue(sym) == 0 && value.countChar32() == 1 ) {
563 fCodePointZero = sym;
564 for ( int8_t i = 1 ; i<= 9 ; i++ ) {
565 sym++;
566 fSymbols[(int)kOneDigitSymbol+i-1] = UnicodeString(sym);
567 }
568 } else {
569 fCodePointZero = -1;
570 }
571 } else if (symbol >= kOneDigitSymbol && symbol <= kNineDigitSymbol) {
572 fCodePointZero = -1;
573 }
574 }
575
576 // -------------------------------------
577
578 inline Locale
579 DecimalFormatSymbols::getLocale() const {
580 return locale;
581 }
582
583 #ifndef U_HIDE_INTERNAL_API
584 inline const char16_t*
585 DecimalFormatSymbols::getCurrencyPattern() const {
586 return currPattern;
587 }
588 #endif /* U_HIDE_INTERNAL_API */
589
590 U_NAMESPACE_END
591
592 #endif /* #if !UCONFIG_NO_FORMATTING */
593
594 #endif /* U_SHOW_CPLUSPLUS_API */
595
596 #endif // _DCFMTSYM
597 //eof