1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ****************************************************************************** 5 * Copyright (C) 2015, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ****************************************************************************** 8 * 9 * File pluralmap.h - PluralMap class that maps plural categories to values. 10 ****************************************************************************** 11 */ 12 13 #ifndef __PLURAL_MAP_H__ 14 #define __PLURAL_MAP_H__ 15 16 #include "unicode/uobject.h" 17 #include "cmemory.h" 18 19 U_NAMESPACE_BEGIN 20 21 class UnicodeString; 22 23 class U_COMMON_API PluralMapBase : public UMemory { 24 public: 25 /** 26 * The names of all the plural categories. NONE is not an actual plural 27 * category, but rather represents the absense of a plural category. 28 */ 29 enum Category { 30 NONE = -1, 31 OTHER, 32 ZERO, 33 ONE, 34 TWO, 35 FEW, 36 MANY, 37 CATEGORY_COUNT 38 }; 39 40 /** 41 * Converts a category name such as "zero", "one", "two", "few", "many" 42 * or "other" to a category enum. Returns NONE for an unrecognized 43 * category name. 44 */ 45 static Category toCategory(const char *categoryName); 46 47 /** 48 * Converts a category name such as "zero", "one", "two", "few", "many" 49 * or "other" to a category enum. Returns NONE for urecongized 50 * category name. 51 */ 52 static Category toCategory(const UnicodeString &categoryName); 53 54 /** 55 * Converts a category to a name. 56 * Passing NONE or CATEGORY_COUNT for category returns NULL. 57 */ 58 static const char *getCategoryName(Category category); 59 }; 60 61 /** 62 * A Map of plural categories to values. It maintains ownership of the 63 * values. 64 * 65 * Type T is the value type. T must provide the followng: 66 * 1) Default constructor 67 * 2) Copy constructor 68 * 3) Assignment operator 69 * 4) Must extend UMemory 70 */ 71 template<typename T> 72 class PluralMap : public PluralMapBase { 73 public: 74 /** 75 * Other category is maps to a copy of the default value. 76 */ 77 PluralMap() : fOtherVariant() { 78 initializeNew(); 79 } 80 81 /** 82 * Other category is mapped to otherVariant. 83 */ 84 PluralMap(const T &otherVariant) : fOtherVariant(otherVariant) { 85 initializeNew(); 86 } 87 88 PluralMap(const PluralMap<T> &other) : fOtherVariant(other.fOtherVariant) { 89 fVariants[0] = &fOtherVariant; 90 for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 91 fVariants[i] = other.fVariants[i] ? 92 new T(*other.fVariants[i]) : NULL; 93 } 94 } 95 96 PluralMap<T> &operator=(const PluralMap<T> &other) { 97 if (this == &other) { 98 return *this; 99 } 100 for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) { 101 if (fVariants[i] != NULL && other.fVariants[i] != NULL) { 102 *fVariants[i] = *other.fVariants[i]; 103 } else if (fVariants[i] != NULL) { 104 delete fVariants[i]; 105 fVariants[i] = NULL; 106 } else if (other.fVariants[i] != NULL) { 107 fVariants[i] = new T(*other.fVariants[i]); 108 } else { 109 // do nothing 110 } 111 } 112 return *this; 113 } 114 115 ~PluralMap() { 116 for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 117 delete fVariants[i]; 118 } 119 } 120 121 /** 122 * Removes all mappings and makes 'other' point to the default value. 123 */ 124 void clear() { 125 *fVariants[0] = T(); 126 for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 127 delete fVariants[i]; 128 fVariants[i] = NULL; 129 } 130 } 131 132 /** 133 * Iterates through the mappings in this instance, set index to NONE 134 * prior to using. Call next repeatedly to get the values until it 135 * returns NULL. Each time next returns, caller may pass index 136 * to getCategoryName() to get the name of the plural category. 137 * When this function returns NULL, index is CATEGORY_COUNT 138 */ 139 const T *next(Category &index) const { 140 int32_t idx = index; 141 ++idx; 142 for (; idx < UPRV_LENGTHOF(fVariants); ++idx) { 143 if (fVariants[idx] != NULL) { 144 index = static_cast<Category>(idx); 145 return fVariants[idx]; 146 } 147 } 148 index = static_cast<Category>(idx); 149 return NULL; 150 } 151 152 /** 153 * non const version of next. 154 */ 155 T *nextMutable(Category &index) { 156 const T *result = next(index); 157 return const_cast<T *>(result); 158 } 159 160 /** 161 * Returns the 'other' variant. 162 * Same as calling get(OTHER). 163 */ 164 const T &getOther() const { 165 return get(OTHER); 166 } 167 168 /** 169 * Returns the value associated with a category. 170 * If no value found, or v is NONE or CATEGORY_COUNT, falls 171 * back to returning the value for the 'other' category. 172 */ 173 const T &get(Category v) const { 174 int32_t index = v; 175 if (index < 0 || index >= UPRV_LENGTHOF(fVariants) || fVariants[index] == NULL) { 176 return *fVariants[0]; 177 } 178 return *fVariants[index]; 179 } 180 181 /** 182 * Convenience routine to get the value by category name. Otherwise 183 * works just like get(Category). 184 */ 185 const T &get(const char *category) const { 186 return get(toCategory(category)); 187 } 188 189 /** 190 * Convenience routine to get the value by category name as a 191 * UnicodeString. Otherwise works just like get(category). 192 */ 193 const T &get(const UnicodeString &category) const { 194 return get(toCategory(category)); 195 } 196 197 /** 198 * Returns a pointer to the value associated with a category 199 * that caller can safely modify. If the value was defaulting to the 'other' 200 * variant because no explicit value was stored, this method creates a 201 * new value using the default constructor at the returned pointer. 202 * 203 * @param category the category with the value to change. 204 * @param status error returned here if index is NONE or CATEGORY_COUNT 205 * or memory could not be allocated, or any other error happens. 206 */ 207 T *getMutable( 208 Category category, 209 UErrorCode &status) { 210 return getMutable(category, NULL, status); 211 } 212 213 /** 214 * Convenience routine to get a mutable pointer to a value by category name. 215 * Otherwise works just like getMutable(Category, UErrorCode &). 216 * reports an error if the category name is invalid. 217 */ 218 T *getMutable( 219 const char *category, 220 UErrorCode &status) { 221 return getMutable(toCategory(category), NULL, status); 222 } 223 224 /** 225 * Just like getMutable(Category, UErrorCode &) but copies defaultValue to 226 * returned pointer if it was defaulting to the 'other' variant 227 * because no explicit value was stored. 228 */ 229 T *getMutableWithDefault( 230 Category category, 231 const T &defaultValue, 232 UErrorCode &status) { 233 return getMutable(category, &defaultValue, status); 234 } 235 236 /** 237 * Returns TRUE if this object equals rhs. 238 */ 239 UBool equals( 240 const PluralMap<T> &rhs, 241 UBool (*eqFunc)(const T &, const T &)) const { 242 for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) { 243 if (fVariants[i] == rhs.fVariants[i]) { 244 continue; 245 } 246 if (fVariants[i] == NULL || rhs.fVariants[i] == NULL) { 247 return FALSE; 248 } 249 if (!eqFunc(*fVariants[i], *rhs.fVariants[i])) { 250 return FALSE; 251 } 252 } 253 return TRUE; 254 } 255 256 private: 257 T fOtherVariant; 258 T* fVariants[6]; 259 260 T *getMutable( 261 Category category, 262 const T *defaultValue, 263 UErrorCode &status) { 264 if (U_FAILURE(status)) { 265 return NULL; 266 } 267 int32_t index = category; 268 if (index < 0 || index >= UPRV_LENGTHOF(fVariants)) { 269 status = U_ILLEGAL_ARGUMENT_ERROR; 270 return NULL; 271 } 272 if (fVariants[index] == NULL) { 273 fVariants[index] = defaultValue == NULL ? 274 new T() : new T(*defaultValue); 275 } 276 if (!fVariants[index]) { 277 status = U_MEMORY_ALLOCATION_ERROR; 278 } 279 return fVariants[index]; 280 } 281 282 void initializeNew() { 283 fVariants[0] = &fOtherVariant; 284 for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 285 fVariants[i] = NULL; 286 } 287 } 288 }; 289 290 U_NAMESPACE_END 291 292 #endif 293
