icuSources/i18n/unicode/dcfmtsym.h

   1 /*
   2 ********************************************************************************
   3 *   Copyright (C) 1997-2006, 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
  30 #if !UCONFIG_NO_FORMATTING
  31
  32 #include "unicode/uobject.h"
  33 #include "unicode/locid.h"
  34
  35 /**
  36  * \file
  37  * \brief C++ API: Symbols for formatting numbers.
  38  */
  39
  40
  41 U_NAMESPACE_BEGIN
  42
  43 /**
  44  * This class represents the set of symbols needed by DecimalFormat
  45  * to format numbers. DecimalFormat creates for itself an instance of
  46  * DecimalFormatSymbols from its locale data.  If you need to change any
  47  * of these symbols, you can get the DecimalFormatSymbols object from
  48  * your DecimalFormat and modify it.
  49  * <P>
  50  * Here are the special characters used in the parts of the
  51  * subpattern, with notes on their usage.
  52  * <pre>
  53  * \code
  54  *        Symbol   Meaning
  55  *          0      a digit
  56  *          #      a digit, zero shows as absent
  57  *          .      placeholder for decimal separator
  58  *          ,      placeholder for grouping separator.
  59  *          ;      separates formats.
  60  *          -      default negative prefix.
  61  *          %      divide by 100 and show as percentage
  62  *          X      any other characters can be used in the prefix or suffix
  63  *          '      used to quote special characters in a prefix or suffix.
  64  * \endcode
  65  *  </pre>
  66  * [Notes]
  67  * <P>
  68  * If there is no explicit negative subpattern, - is prefixed to the
  69  * positive form. That is, "0.00" alone is equivalent to "0.00;-0.00".
  70  * <P>
  71  * The grouping separator is commonly used for thousands, but in some
  72  * countries for ten-thousands. The interval is a constant number of
  73  * digits between the grouping characters, such as 100,000,000 or 1,0000,0000.
  74  * If you supply a pattern with multiple grouping characters, the interval
  75  * between the last one and the end of the integer is the one that is
  76  * used. So "#,##,###,####" == "######,####" == "##,####,####".
  77  * <P>
  78  * This class only handles localized digits where the 10 digits are
  79  * contiguous in Unicode, from 0 to 9. Other digits sets (such as
  80  * superscripts) would need a different subclass.
  81  */
  82 class U_I18N_API DecimalFormatSymbols : public UObject {
  83 public:
  84     /**
  85      * Constants for specifying a number format symbol.
  86      * @stable ICU 2.0
  87      */
  88     enum ENumberFormatSymbol {
  89         /** The decimal separator */
  90         kDecimalSeparatorSymbol,
  91         /** The grouping separator */
  92         kGroupingSeparatorSymbol,
  93         /** The pattern separator */
  94         kPatternSeparatorSymbol,
  95         /** The percent sign */
  96         kPercentSymbol,
  97         /** Zero*/
  98         kZeroDigitSymbol,
  99         /** Character representing a digit in the pattern */
 100         kDigitSymbol,
 101         /** The minus sign */
 102         kMinusSignSymbol,
 103         /** The plus sign */
 104         kPlusSignSymbol,
 105         /** The currency symbol */
 106         kCurrencySymbol,
 107         /** The international currency symbol */
 108         kIntlCurrencySymbol,
 109         /** The monetary separator */
 110         kMonetarySeparatorSymbol,
 111         /** The exponential symbol */
 112         kExponentialSymbol,
 113         /** Per mill symbol - replaces kPermillSymbol */
 114         kPerMillSymbol,
 115         /** Escape padding character */
 116         kPadEscapeSymbol,
 117         /** Infinity symbol */
 118         kInfinitySymbol,
 119         /** Nan symbol */
 120         kNaNSymbol,
 121         /** Significant digit symbol
 122          * @stable ICU 3.0 */
 123         kSignificantDigitSymbol,
 124         /** The monetary grouping separator
 125          * @draft ICU 3.6
 126          */
 127         kMonetaryGroupingSeparatorSymbol,
 128         /** count symbol constants */
 129         kFormatSymbolCount
 130     };
 131
 132     /**
 133      * Create a DecimalFormatSymbols object for the given locale.
 134      *
 135      * @param locale    The locale to get symbols for.
 136      * @param status    Input/output parameter, set to success or
 137      *                  failure code upon return.
 138      * @stable ICU 2.0
 139      */
 140     DecimalFormatSymbols(const Locale& locale, UErrorCode& status);
 141
 142     /**
 143      * Create a DecimalFormatSymbols object for the default locale.
 144      * This constructor will not fail.  If the resource file data is
 145      * not available, it will use hard-coded last-resort data and
 146      * set status to U_USING_FALLBACK_ERROR.
 147      *
 148      * @param status    Input/output parameter, set to success or
 149      *                  failure code upon return.
 150      * @stable ICU 2.0
 151      */
 152     DecimalFormatSymbols( UErrorCode& status);
 153
 154     /**
 155      * Copy constructor.
 156      * @stable ICU 2.0
 157      */
 158     DecimalFormatSymbols(const DecimalFormatSymbols&);
 159
 160     /**
 161      * Assignment operator.
 162      * @stable ICU 2.0
 163      */
 164     DecimalFormatSymbols& operator=(const DecimalFormatSymbols&);
 165
 166     /**
 167      * Destructor.
 168      * @stable ICU 2.0
 169      */
 170     virtual ~DecimalFormatSymbols();
 171
 172     /**
 173      * Return true if another object is semantically equal to this one.
 174      *
 175      * @param other    the object to be compared with.
 176      * @return         true if another object is semantically equal to this one.
 177      * @stable ICU 2.0
 178      */
 179     UBool operator==(const DecimalFormatSymbols& other) const;
 180
 181     /**
 182      * Return true if another object is semantically unequal to this one.
 183      *
 184      * @param other    the object to be compared with.
 185      * @return         true if another object is semantically unequal to this one.
 186      * @stable ICU 2.0
 187      */
 188     UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); }
 189
 190     /**
 191      * Get one of the format symbols by its enum constant.
 192      * Each symbol is stored as a string so that graphemes
 193      * (characters with modifyer letters) can be used.
 194      *
 195      * @param symbol    Constant to indicate a number format symbol.
 196      * @return    the format symbols by the param 'symbol'
 197      * @stable ICU 2.0
 198      */
 199     inline UnicodeString getSymbol(ENumberFormatSymbol symbol) const;
 200
 201     /**
 202      * Set one of the format symbols by its enum constant.
 203      * Each symbol is stored as a string so that graphemes
 204      * (characters with modifyer letters) can be used.
 205      *
 206      * @param symbol    Constant to indicate a number format symbol.
 207      * @param value     value of the format sybmol
 208      * @stable ICU 2.0
 209      */
 210     void setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value);
 211
 212     /**
 213      * Returns the locale for which this object was constructed.
 214      * @stable ICU 2.6
 215      */
 216     inline Locale getLocale() const;
 217
 218     /**
 219      * Returns the locale for this object. Two flavors are available:
 220      * valid and actual locale.
 221      * @stable ICU 2.8
 222      */
 223     Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
 224
 225     /**
 226      * ICU "poor man's RTTI", returns a UClassID for the actual class.
 227      *
 228      * @stable ICU 2.2
 229      */
 230     virtual UClassID getDynamicClassID() const;
 231
 232     /**
 233      * ICU "poor man's RTTI", returns a UClassID for this class.
 234      *
 235      * @stable ICU 2.2
 236      */
 237     static UClassID U_EXPORT2 getStaticClassID();
 238
 239 private:
 240     DecimalFormatSymbols(); // default constructor not implemented
 241
 242     /**
 243      * Initializes the symbols from the LocaleElements resource bundle.
 244      * Note: The organization of LocaleElements badly needs to be
 245      * cleaned up.
 246      *
 247      * @param locale               The locale to get symbols for.
 248      * @param success              Input/output parameter, set to success or
 249      *                             failure code upon return.
 250      * @param useLastResortData    determine if use last resort data
 251      */
 252     void initialize(const Locale& locale, UErrorCode& success, UBool useLastResortData = FALSE);
 253
 254     /**
 255      * Initialize the symbols from the given array of UnicodeStrings.
 256      * The array must be of the correct size.
 257      *
 258      * @param numberElements    the number format symbols
 259      * @param numberElementsLength length of numberElements
 260      */
 261     void initialize(const UChar** numberElements, int32_t *numberElementsStrLen, int32_t numberElementsLength);
 262
 263     /**
 264      * Initialize the symbols with default values.
 265      */
 266     void initialize();
 267
 268     void setCurrencyForSymbols();
 269
 270 public:
 271     /**
 272      * _Internal_ function - more efficient version of getSymbol,
 273      * returning a const reference to one of the symbol strings.
 274      * The returned reference becomes invalid when the symbol is changed
 275      * or when the DecimalFormatSymbols are destroyed.
 276      * ### TODO markus 2002oct11: Consider proposing getConstSymbol() to be really public.
 277      *
 278      * @param symbol Constant to indicate a number format symbol.
 279      * @return the format symbol by the param 'symbol'
 280      * @internal
 281      */
 282     inline const UnicodeString &getConstSymbol(ENumberFormatSymbol symbol) const;
 283
 284     /**
 285      * Returns that pattern stored in currecy info. Internal API for use by NumberFormat API.
 286      * @internal
 287      */
 288     inline const UChar* getCurrencyPattern(void) const;
 289
 290 private:
 291     /**
 292      * Private symbol strings.
 293      * They are either loaded from a resource bundle or otherwise owned.
 294      * setSymbol() clones the symbol string.
 295      * Readonly aliases can only come from a resource bundle, so that we can always
 296      * use fastCopyFrom() with them.
 297      *
 298      * If DecimalFormatSymbols becomes subclassable and the status of fSymbols changes
 299      * from private to protected,
 300      * or when fSymbols can be set any other way that allows them to be readonly aliases
 301      * to non-resource bundle strings,
 302      * then regular UnicodeString copies must be used instead of fastCopyFrom().
 303      *
 304      * @internal
 305      */
 306     UnicodeString fSymbols[kFormatSymbolCount];
 307
 308     /**
 309      * Non-symbol variable for getConstSymbol(). Always empty.
 310      * @internal
 311      */
 312     UnicodeString fNoSymbol;
 313
 314     Locale locale;
 315
 316     char actualLocale[ULOC_FULLNAME_CAPACITY];
 317     char validLocale[ULOC_FULLNAME_CAPACITY];
 318     const UChar* currPattern;
 319 };
 320
 321 // -------------------------------------
 322
 323 inline UnicodeString
 324 DecimalFormatSymbols::getSymbol(ENumberFormatSymbol symbol) const {
 325     const UnicodeString *strPtr;
 326     if(symbol < kFormatSymbolCount) {
 327         strPtr = &fSymbols[symbol];
 328     } else {
 329         strPtr = &fNoSymbol;
 330     }
 331     return *strPtr;
 332 }
 333
 334 inline const UnicodeString &
 335 DecimalFormatSymbols::getConstSymbol(ENumberFormatSymbol symbol) const {
 336     const UnicodeString *strPtr;
 337     if(symbol < kFormatSymbolCount) {
 338         strPtr = &fSymbols[symbol];
 339     } else {
 340         strPtr = &fNoSymbol;
 341     }
 342     return *strPtr;
 343 }
 344
 345 // -------------------------------------
 346
 347 inline void
 348 DecimalFormatSymbols::setSymbol(ENumberFormatSymbol symbol, const UnicodeString &value) {
 349     if(symbol<kFormatSymbolCount) {
 350         fSymbols[symbol]=value;
 351     }
 352 }
 353
 354 // -------------------------------------
 355
 356 inline Locale
 357 DecimalFormatSymbols::getLocale() const {
 358     return locale;
 359 }
 360
 361 inline const UChar*
 362 DecimalFormatSymbols::getCurrencyPattern() const {
 363     return currPattern;
 364 }
 365 U_NAMESPACE_END
 366
 367 #endif /* #if !UCONFIG_NO_FORMATTING */
 368
 369 #endif // _DCFMTSYM
 370 //eof