Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 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 | /** |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 237 | * Returns true if this object equals rhs. |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 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) { |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 247 | return false; |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 248 | } |
| 249 | if (!eqFunc(*fVariants[i], *rhs.fVariants[i])) { |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 250 | return false; |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 251 | } |
| 252 | } |
Victor Chang | ce4bf3c | 2021-01-19 16:34:24 +0000 | [diff] [blame] | 253 | return true; |
Victor Chang | 7322950 | 2020-09-17 13:39:19 +0100 | [diff] [blame] | 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 |