293 lines
8.5 KiB
C++
293 lines
8.5 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
******************************************************************************
|
|
* Copyright (C) 2015, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
******************************************************************************
|
|
*
|
|
* File pluralmap.h - PluralMap class that maps plural categories to values.
|
|
******************************************************************************
|
|
*/
|
|
|
|
#ifndef __PLURAL_MAP_H__
|
|
#define __PLURAL_MAP_H__
|
|
|
|
#include "unicode/uobject.h"
|
|
#include "cmemory.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
class UnicodeString;
|
|
|
|
class U_COMMON_API PluralMapBase : public UMemory {
|
|
public:
|
|
/**
|
|
* The names of all the plural categories. NONE is not an actual plural
|
|
* category, but rather represents the absense of a plural category.
|
|
*/
|
|
enum Category {
|
|
NONE = -1,
|
|
OTHER,
|
|
ZERO,
|
|
ONE,
|
|
TWO,
|
|
FEW,
|
|
MANY,
|
|
CATEGORY_COUNT
|
|
};
|
|
|
|
/**
|
|
* Converts a category name such as "zero", "one", "two", "few", "many"
|
|
* or "other" to a category enum. Returns NONE for an unrecognized
|
|
* category name.
|
|
*/
|
|
static Category toCategory(const char *categoryName);
|
|
|
|
/**
|
|
* Converts a category name such as "zero", "one", "two", "few", "many"
|
|
* or "other" to a category enum. Returns NONE for urecongized
|
|
* category name.
|
|
*/
|
|
static Category toCategory(const UnicodeString &categoryName);
|
|
|
|
/**
|
|
* Converts a category to a name.
|
|
* Passing NONE or CATEGORY_COUNT for category returns NULL.
|
|
*/
|
|
static const char *getCategoryName(Category category);
|
|
};
|
|
|
|
/**
|
|
* A Map of plural categories to values. It maintains ownership of the
|
|
* values.
|
|
*
|
|
* Type T is the value type. T must provide the followng:
|
|
* 1) Default constructor
|
|
* 2) Copy constructor
|
|
* 3) Assignment operator
|
|
* 4) Must extend UMemory
|
|
*/
|
|
template<typename T>
|
|
class PluralMap : public PluralMapBase {
|
|
public:
|
|
/**
|
|
* Other category is maps to a copy of the default value.
|
|
*/
|
|
PluralMap() : fOtherVariant() {
|
|
initializeNew();
|
|
}
|
|
|
|
/**
|
|
* Other category is mapped to otherVariant.
|
|
*/
|
|
PluralMap(const T &otherVariant) : fOtherVariant(otherVariant) {
|
|
initializeNew();
|
|
}
|
|
|
|
PluralMap(const PluralMap<T> &other) : fOtherVariant(other.fOtherVariant) {
|
|
fVariants[0] = &fOtherVariant;
|
|
for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
|
|
fVariants[i] = other.fVariants[i] ?
|
|
new T(*other.fVariants[i]) : NULL;
|
|
}
|
|
}
|
|
|
|
PluralMap<T> &operator=(const PluralMap<T> &other) {
|
|
if (this == &other) {
|
|
return *this;
|
|
}
|
|
for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) {
|
|
if (fVariants[i] != NULL && other.fVariants[i] != NULL) {
|
|
*fVariants[i] = *other.fVariants[i];
|
|
} else if (fVariants[i] != NULL) {
|
|
delete fVariants[i];
|
|
fVariants[i] = NULL;
|
|
} else if (other.fVariants[i] != NULL) {
|
|
fVariants[i] = new T(*other.fVariants[i]);
|
|
} else {
|
|
// do nothing
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
~PluralMap() {
|
|
for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
|
|
delete fVariants[i];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes all mappings and makes 'other' point to the default value.
|
|
*/
|
|
void clear() {
|
|
*fVariants[0] = T();
|
|
for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
|
|
delete fVariants[i];
|
|
fVariants[i] = NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Iterates through the mappings in this instance, set index to NONE
|
|
* prior to using. Call next repeatedly to get the values until it
|
|
* returns NULL. Each time next returns, caller may pass index
|
|
* to getCategoryName() to get the name of the plural category.
|
|
* When this function returns NULL, index is CATEGORY_COUNT
|
|
*/
|
|
const T *next(Category &index) const {
|
|
int32_t idx = index;
|
|
++idx;
|
|
for (; idx < UPRV_LENGTHOF(fVariants); ++idx) {
|
|
if (fVariants[idx] != NULL) {
|
|
index = static_cast<Category>(idx);
|
|
return fVariants[idx];
|
|
}
|
|
}
|
|
index = static_cast<Category>(idx);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* non const version of next.
|
|
*/
|
|
T *nextMutable(Category &index) {
|
|
const T *result = next(index);
|
|
return const_cast<T *>(result);
|
|
}
|
|
|
|
/**
|
|
* Returns the 'other' variant.
|
|
* Same as calling get(OTHER).
|
|
*/
|
|
const T &getOther() const {
|
|
return get(OTHER);
|
|
}
|
|
|
|
/**
|
|
* Returns the value associated with a category.
|
|
* If no value found, or v is NONE or CATEGORY_COUNT, falls
|
|
* back to returning the value for the 'other' category.
|
|
*/
|
|
const T &get(Category v) const {
|
|
int32_t index = v;
|
|
if (index < 0 || index >= UPRV_LENGTHOF(fVariants) || fVariants[index] == NULL) {
|
|
return *fVariants[0];
|
|
}
|
|
return *fVariants[index];
|
|
}
|
|
|
|
/**
|
|
* Convenience routine to get the value by category name. Otherwise
|
|
* works just like get(Category).
|
|
*/
|
|
const T &get(const char *category) const {
|
|
return get(toCategory(category));
|
|
}
|
|
|
|
/**
|
|
* Convenience routine to get the value by category name as a
|
|
* UnicodeString. Otherwise works just like get(category).
|
|
*/
|
|
const T &get(const UnicodeString &category) const {
|
|
return get(toCategory(category));
|
|
}
|
|
|
|
/**
|
|
* Returns a pointer to the value associated with a category
|
|
* that caller can safely modify. If the value was defaulting to the 'other'
|
|
* variant because no explicit value was stored, this method creates a
|
|
* new value using the default constructor at the returned pointer.
|
|
*
|
|
* @param category the category with the value to change.
|
|
* @param status error returned here if index is NONE or CATEGORY_COUNT
|
|
* or memory could not be allocated, or any other error happens.
|
|
*/
|
|
T *getMutable(
|
|
Category category,
|
|
UErrorCode &status) {
|
|
return getMutable(category, NULL, status);
|
|
}
|
|
|
|
/**
|
|
* Convenience routine to get a mutable pointer to a value by category name.
|
|
* Otherwise works just like getMutable(Category, UErrorCode &).
|
|
* reports an error if the category name is invalid.
|
|
*/
|
|
T *getMutable(
|
|
const char *category,
|
|
UErrorCode &status) {
|
|
return getMutable(toCategory(category), NULL, status);
|
|
}
|
|
|
|
/**
|
|
* Just like getMutable(Category, UErrorCode &) but copies defaultValue to
|
|
* returned pointer if it was defaulting to the 'other' variant
|
|
* because no explicit value was stored.
|
|
*/
|
|
T *getMutableWithDefault(
|
|
Category category,
|
|
const T &defaultValue,
|
|
UErrorCode &status) {
|
|
return getMutable(category, &defaultValue, status);
|
|
}
|
|
|
|
/**
|
|
* Returns TRUE if this object equals rhs.
|
|
*/
|
|
UBool equals(
|
|
const PluralMap<T> &rhs,
|
|
UBool (*eqFunc)(const T &, const T &)) const {
|
|
for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) {
|
|
if (fVariants[i] == rhs.fVariants[i]) {
|
|
continue;
|
|
}
|
|
if (fVariants[i] == NULL || rhs.fVariants[i] == NULL) {
|
|
return FALSE;
|
|
}
|
|
if (!eqFunc(*fVariants[i], *rhs.fVariants[i])) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
private:
|
|
T fOtherVariant;
|
|
T* fVariants[6];
|
|
|
|
T *getMutable(
|
|
Category category,
|
|
const T *defaultValue,
|
|
UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
return NULL;
|
|
}
|
|
int32_t index = category;
|
|
if (index < 0 || index >= UPRV_LENGTHOF(fVariants)) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
if (fVariants[index] == NULL) {
|
|
fVariants[index] = defaultValue == NULL ?
|
|
new T() : new T(*defaultValue);
|
|
}
|
|
if (!fVariants[index]) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return fVariants[index];
|
|
}
|
|
|
|
void initializeNew() {
|
|
fVariants[0] = &fOtherVariant;
|
|
for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
|
|
fVariants[i] = NULL;
|
|
}
|
|
}
|
|
};
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif
|