icuSources/common/pluralmap.h

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