source/i18n/unicode/currpinf.h

   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) 2009-2015, International Business Machines Corporation and         *
   6  * others. All Rights Reserved.                                                *
   7  *******************************************************************************
   8  */
   9 #ifndef CURRPINF_H
  10 #define CURRPINF_H
  11
  12 #include "unicode/utypes.h"
  13
  14 /**
  15  * \file
  16  * \brief C++ API: Currency Plural Information used by Decimal Format
  17  */
  18
  19 #if !UCONFIG_NO_FORMATTING
  20
  21 #include "unicode/unistr.h"
  22
  23 U_NAMESPACE_BEGIN
  24
  25 class Locale;
  26 class PluralRules;
  27 class Hashtable;
  28
  29 /**
  30  * This class represents the information needed by
  31  * DecimalFormat to format currency plural,
  32  * such as "3.00 US dollars" or "1.00 US dollar".
  33  * DecimalFormat creates for itself an instance of
  34  * CurrencyPluralInfo from its locale data.
  35  * If you need to change any of these symbols, you can get the
  36  * CurrencyPluralInfo object from your
  37  * DecimalFormat and modify it.
  38  *
  39  * Following are the information needed for currency plural format and parse:
  40  * locale information,
  41  * plural rule of the locale,
  42  * currency plural pattern of the locale.
  43  *
  44  * @stable ICU 4.2
  45  */
  46 class  U_I18N_API CurrencyPluralInfo : public UObject {
  47 public:
  48
  49     /**
  50      * Create a CurrencyPluralInfo object for the default locale.
  51      * @param status output param set to success/failure code on exit
  52      * @stable ICU 4.2
  53      */
  54     CurrencyPluralInfo(UErrorCode& status);
  55
  56     /**
  57      * Create a CurrencyPluralInfo object for the given locale.
  58      * @param locale the locale
  59      * @param status output param set to success/failure code on exit
  60      * @stable ICU 4.2
  61      */
  62     CurrencyPluralInfo(const Locale& locale, UErrorCode& status);
  63
  64     /**
  65      * Copy constructor
  66      *
  67      * @stable ICU 4.2
  68      */
  69     CurrencyPluralInfo(const CurrencyPluralInfo& info);
  70
  71
  72     /**
  73      * Assignment operator
  74      *
  75      * @stable ICU 4.2
  76      */
  77     CurrencyPluralInfo& operator=(const CurrencyPluralInfo& info);
  78
  79
  80     /**
  81      * Destructor
  82      *
  83      * @stable ICU 4.2
  84      */
  85     virtual ~CurrencyPluralInfo();
  86
  87
  88     /**
  89      * Equal operator.
  90      *
  91      * @stable ICU 4.2
  92      */
  93     UBool operator==(const CurrencyPluralInfo& info) const;
  94
  95
  96     /**
  97      * Not equal operator
  98      *
  99      * @stable ICU 4.2
 100      */
 101     UBool operator!=(const CurrencyPluralInfo& info) const;
 102
 103
 104     /**
 105      * Clone
 106      *
 107      * @stable ICU 4.2
 108      */
 109     CurrencyPluralInfo* clone() const;
 110
 111
 112     /**
 113      * Gets plural rules of this locale, used for currency plural format
 114      *
 115      * @return plural rule
 116      * @stable ICU 4.2
 117      */
 118     const PluralRules* getPluralRules() const;
 119
 120     /**
 121      * Given a plural count, gets currency plural pattern of this locale,
 122      * used for currency plural format
 123      *
 124      * @param  pluralCount currency plural count
 125      * @param  result      output param to receive the pattern
 126      * @return a currency plural pattern based on plural count
 127      * @stable ICU 4.2
 128      */
 129     UnicodeString& getCurrencyPluralPattern(const UnicodeString& pluralCount,
 130                                             UnicodeString& result) const;
 131
 132     /**
 133      * Get locale
 134      *
 135      * @return locale
 136      * @stable ICU 4.2
 137      */
 138     const Locale& getLocale() const;
 139
 140     /**
 141      * Set plural rules.
 142      * The plural rule is set when CurrencyPluralInfo
 143      * instance is created.
 144      * You can call this method to reset plural rules only if you want
 145      * to modify the default plural rule of the locale.
 146      *
 147      * @param ruleDescription new plural rule description
 148      * @param status output param set to success/failure code on exit
 149      * @stable ICU 4.2
 150      */
 151     void setPluralRules(const UnicodeString& ruleDescription,
 152                         UErrorCode& status);
 153
 154     /**
 155      * Set currency plural pattern.
 156      * The currency plural pattern is set when CurrencyPluralInfo
 157      * instance is created.
 158      * You can call this method to reset currency plural pattern only if
 159      * you want to modify the default currency plural pattern of the locale.
 160      *
 161      * @param pluralCount the plural count for which the currency pattern will
 162      *                    be overridden.
 163      * @param pattern     the new currency plural pattern
 164      * @param status      output param set to success/failure code on exit
 165      * @stable ICU 4.2
 166      */
 167     void setCurrencyPluralPattern(const UnicodeString& pluralCount,
 168                                   const UnicodeString& pattern,
 169                                   UErrorCode& status);
 170
 171     /**
 172      * Set locale
 173      *
 174      * @param loc     the new locale to set
 175      * @param status  output param set to success/failure code on exit
 176      * @stable ICU 4.2
 177      */
 178     void setLocale(const Locale& loc, UErrorCode& status);
 179
 180     /**
 181      * ICU "poor man's RTTI", returns a UClassID for the actual class.
 182      *
 183      * @stable ICU 4.2
 184      */
 185     virtual UClassID getDynamicClassID() const;
 186
 187     /**
 188      * ICU "poor man's RTTI", returns a UClassID for this class.
 189      *
 190      * @stable ICU 4.2
 191      */
 192     static UClassID U_EXPORT2 getStaticClassID();
 193
 194 private:
 195     friend class DecimalFormat;
 196     friend class DecimalFormatImpl;
 197
 198     void initialize(const Locale& loc, UErrorCode& status);
 199
 200     void setupCurrencyPluralPattern(const Locale& loc, UErrorCode& status);
 201
 202     /*
 203      * delete hash table
 204      *
 205      * @param hTable  hash table to be deleted
 206      */
 207     void deleteHash(Hashtable* hTable);
 208
 209
 210     /*
 211      * initialize hash table
 212      *
 213      * @param status   output param set to success/failure code on exit
 214      * @return         hash table initialized
 215      */
 216     Hashtable* initHash(UErrorCode& status);
 217
 218
 219
 220     /**
 221      * copy hash table
 222      *
 223      * @param source   the source to copy from
 224      * @param target   the target to copy to
 225      * @param status   error code
 226      */
 227     void copyHash(const Hashtable* source, Hashtable* target, UErrorCode& status);
 228
 229     //-------------------- private data member ---------------------
 230     // map from plural count to currency plural pattern, for example
 231     // a plural pattern defined in "CurrencyUnitPatterns" is
 232     // "one{{0} {1}}", in which "one" is a plural count
 233     // and "{0} {1}" is a currency plural pattern".
 234     // The currency plural pattern saved in this mapping is the pattern
 235     // defined in "CurrencyUnitPattern" by replacing
 236     // {0} with the number format pattern,
 237     // and {1} with 3 currency sign.
 238     Hashtable* fPluralCountToCurrencyUnitPattern;
 239
 240     /*
 241      * The plural rule is used to format currency plural name,
 242      * for example: "3.00 US Dollars".
 243      * If there are 3 currency signs in the currency patttern,
 244      * the 3 currency signs will be replaced by currency plural name.
 245      */
 246     PluralRules* fPluralRules;
 247
 248     // locale
 249     Locale* fLocale;
 250 };
 251
 252
 253 inline UBool
 254 CurrencyPluralInfo::operator!=(const CurrencyPluralInfo& info) const {              return !operator==(info);                                                   }
 255
 256 U_NAMESPACE_END
 257
 258 #endif /* #if !UCONFIG_NO_FORMATTING */
 259
 260 #endif // _CURRPINFO
 261 //eof