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