| /* |
| ****************************************************************************** |
| * Copyright (C) 1996-2014, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ****************************************************************************** |
| */ |
| |
| /** |
| * File coll.cpp |
| * |
| * Created by: Helena Shih |
| * |
| * Modification History: |
| * |
| * Date Name Description |
| * 2/5/97 aliu Modified createDefault to load collation data from |
| * binary files when possible. Added related methods |
| * createCollationFromFile, chopLocale, createPathName. |
| * 2/11/97 aliu Added methods addToCache, findInCache, which implement |
| * a Collation cache. Modified createDefault to look in |
| * cache first, and also to store newly created Collation |
| * objects in the cache. Modified to not use gLocPath. |
| * 2/12/97 aliu Modified to create objects from RuleBasedCollator cache. |
| * Moved cache out of Collation class. |
| * 2/13/97 aliu Moved several methods out of this class and into |
| * RuleBasedCollator, with modifications. Modified |
| * createDefault() to call new RuleBasedCollator(Locale&) |
| * constructor. General clean up and documentation. |
| * 2/20/97 helena Added clone, operator==, operator!=, operator=, and copy |
| * constructor. |
| * 05/06/97 helena Added memory allocation error detection. |
| * 05/08/97 helena Added createInstance(). |
| * 6/20/97 helena Java class name change. |
| * 04/23/99 stephen Removed EDecompositionMode, merged with |
| * Normalizer::EMode |
| * 11/23/9 srl Inlining of some critical functions |
| * 01/29/01 synwee Modified into a C++ wrapper calling C APIs (ucol.h) |
| * 2012-2014 markus Rewritten in C++ again. |
| */ |
| |
| #include "utypeinfo.h" // for 'typeid' to work |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| #include "starboard/client_porting/poem/assert_poem.h" |
| #include "starboard/client_porting/poem/string_poem.h" |
| #include "unicode/coll.h" |
| #include "unicode/tblcoll.h" |
| #include "collationdata.h" |
| #include "collationroot.h" |
| #include "collationtailoring.h" |
| #include "ucol_imp.h" |
| #include "cstring.h" |
| #include "cmemory.h" |
| #include "umutex.h" |
| #include "servloc.h" |
| #include "uassert.h" |
| #include "ustrenum.h" |
| #include "uresimp.h" |
| #include "ucln_in.h" |
| |
| static icu::Locale* availableLocaleList = NULL; |
| static int32_t availableLocaleListCount; |
| static icu::ICULocaleService* gService = NULL; |
| static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER; |
| static icu::UInitOnce gAvailableLocaleListInitOnce; |
| |
| /** |
| * Release all static memory held by collator. |
| */ |
| U_CDECL_BEGIN |
| static UBool U_CALLCONV collator_cleanup(void) { |
| #if !UCONFIG_NO_SERVICE |
| if (gService) { |
| delete gService; |
| gService = NULL; |
| } |
| gServiceInitOnce.reset(); |
| #endif |
| if (availableLocaleList) { |
| delete []availableLocaleList; |
| availableLocaleList = NULL; |
| } |
| availableLocaleListCount = 0; |
| gAvailableLocaleListInitOnce.reset(); |
| return TRUE; |
| } |
| |
| U_CDECL_END |
| |
| U_NAMESPACE_BEGIN |
| |
| #if !UCONFIG_NO_SERVICE |
| |
| // ------------------------------------------ |
| // |
| // Registration |
| // |
| |
| //------------------------------------------- |
| |
| CollatorFactory::~CollatorFactory() {} |
| |
| //------------------------------------------- |
| |
| UBool |
| CollatorFactory::visible(void) const { |
| return TRUE; |
| } |
| |
| //------------------------------------------- |
| |
| UnicodeString& |
| CollatorFactory::getDisplayName(const Locale& objectLocale, |
| const Locale& displayLocale, |
| UnicodeString& result) |
| { |
| return objectLocale.getDisplayName(displayLocale, result); |
| } |
| |
| // ------------------------------------- |
| |
| class ICUCollatorFactory : public ICUResourceBundleFactory { |
| public: |
| ICUCollatorFactory() : ICUResourceBundleFactory(UnicodeString(U_ICUDATA_COLL, -1, US_INV)) { } |
| virtual ~ICUCollatorFactory(); |
| protected: |
| virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const; |
| }; |
| |
| ICUCollatorFactory::~ICUCollatorFactory() {} |
| |
| UObject* |
| ICUCollatorFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const { |
| if (handlesKey(key, status)) { |
| const LocaleKey& lkey = (const LocaleKey&)key; |
| Locale loc; |
| // make sure the requested locale is correct |
| // default LocaleFactory uses currentLocale since that's the one vetted by handlesKey |
| // but for ICU rb resources we use the actual one since it will fallback again |
| lkey.canonicalLocale(loc); |
| |
| return Collator::makeInstance(loc, status); |
| } |
| return NULL; |
| } |
| |
| // ------------------------------------- |
| |
| class ICUCollatorService : public ICULocaleService { |
| public: |
| ICUCollatorService() |
| : ICULocaleService(UNICODE_STRING_SIMPLE("Collator")) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| registerFactory(new ICUCollatorFactory(), status); |
| } |
| |
| virtual ~ICUCollatorService(); |
| |
| virtual UObject* cloneInstance(UObject* instance) const { |
| return ((Collator*)instance)->clone(); |
| } |
| |
| virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* actualID, UErrorCode& status) const { |
| LocaleKey& lkey = (LocaleKey&)key; |
| if (actualID) { |
| // Ugly Hack Alert! We return an empty actualID to signal |
| // to callers that this is a default object, not a "real" |
| // service-created object. (TODO remove in 3.0) [aliu] |
| actualID->truncate(0); |
| } |
| Locale loc(""); |
| lkey.canonicalLocale(loc); |
| return Collator::makeInstance(loc, status); |
| } |
| |
| virtual UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const { |
| UnicodeString ar; |
| if (actualReturn == NULL) { |
| actualReturn = &ar; |
| } |
| return (Collator*)ICULocaleService::getKey(key, actualReturn, status); |
| } |
| |
| virtual UBool isDefault() const { |
| return countFactories() == 1; |
| } |
| }; |
| |
| ICUCollatorService::~ICUCollatorService() {} |
| |
| // ------------------------------------- |
| |
| static void U_CALLCONV initService() { |
| gService = new ICUCollatorService(); |
| ucln_i18n_registerCleanup(UCLN_I18N_COLLATOR, collator_cleanup); |
| } |
| |
| |
| static ICULocaleService* |
| getService(void) |
| { |
| umtx_initOnce(gServiceInitOnce, &initService); |
| return gService; |
| } |
| |
| // ------------------------------------- |
| |
| static inline UBool |
| hasService(void) |
| { |
| UBool retVal = !gServiceInitOnce.isReset() && (getService() != NULL); |
| return retVal; |
| } |
| |
| #endif /* UCONFIG_NO_SERVICE */ |
| |
| static void U_CALLCONV |
| initAvailableLocaleList(UErrorCode &status) { |
| U_ASSERT(availableLocaleListCount == 0); |
| U_ASSERT(availableLocaleList == NULL); |
| // for now, there is a hardcoded list, so just walk through that list and set it up. |
| UResourceBundle *index = NULL; |
| UResourceBundle installed; |
| int32_t i = 0; |
| |
| ures_initStackObject(&installed); |
| index = ures_openDirect(U_ICUDATA_COLL, "res_index", &status); |
| ures_getByKey(index, "InstalledLocales", &installed, &status); |
| |
| if(U_SUCCESS(status)) { |
| availableLocaleListCount = ures_getSize(&installed); |
| availableLocaleList = new Locale[availableLocaleListCount]; |
| |
| if (availableLocaleList != NULL) { |
| ures_resetIterator(&installed); |
| while(ures_hasNext(&installed)) { |
| const char *tempKey = NULL; |
| ures_getNextString(&installed, NULL, &tempKey, &status); |
| availableLocaleList[i++] = Locale(tempKey); |
| } |
| } |
| U_ASSERT(availableLocaleListCount == i); |
| ures_close(&installed); |
| } |
| ures_close(index); |
| ucln_i18n_registerCleanup(UCLN_I18N_COLLATOR, collator_cleanup); |
| } |
| |
| static UBool isAvailableLocaleListInitialized(UErrorCode &status) { |
| umtx_initOnce(gAvailableLocaleListInitOnce, &initAvailableLocaleList, status); |
| return U_SUCCESS(status); |
| } |
| |
| |
| // Collator public methods ----------------------------------------------- |
| |
| namespace { |
| |
| static const struct { |
| const char *name; |
| UColAttribute attr; |
| } collAttributes[] = { |
| { "colStrength", UCOL_STRENGTH }, |
| { "colBackwards", UCOL_FRENCH_COLLATION }, |
| { "colCaseLevel", UCOL_CASE_LEVEL }, |
| { "colCaseFirst", UCOL_CASE_FIRST }, |
| { "colAlternate", UCOL_ALTERNATE_HANDLING }, |
| { "colNormalization", UCOL_NORMALIZATION_MODE }, |
| { "colNumeric", UCOL_NUMERIC_COLLATION } |
| }; |
| |
| static const struct { |
| const char *name; |
| UColAttributeValue value; |
| } collAttributeValues[] = { |
| { "primary", UCOL_PRIMARY }, |
| { "secondary", UCOL_SECONDARY }, |
| { "tertiary", UCOL_TERTIARY }, |
| { "quaternary", UCOL_QUATERNARY }, |
| // Note: Not supporting typo "quarternary" because it was never supported in locale IDs. |
| { "identical", UCOL_IDENTICAL }, |
| { "no", UCOL_OFF }, |
| { "yes", UCOL_ON }, |
| { "shifted", UCOL_SHIFTED }, |
| { "non-ignorable", UCOL_NON_IGNORABLE }, |
| { "lower", UCOL_LOWER_FIRST }, |
| { "upper", UCOL_UPPER_FIRST } |
| }; |
| |
| static const char *collReorderCodes[UCOL_REORDER_CODE_LIMIT - UCOL_REORDER_CODE_FIRST] = { |
| "space", "punct", "symbol", "currency", "digit" |
| }; |
| |
| int32_t getReorderCode(const char *s) { |
| for (int32_t i = 0; i < UPRV_LENGTHOF(collReorderCodes); ++i) { |
| if (uprv_stricmp(s, collReorderCodes[i]) == 0) { |
| return UCOL_REORDER_CODE_FIRST + i; |
| } |
| } |
| // Not supporting "others" = UCOL_REORDER_CODE_OTHERS |
| // as a synonym for Zzzz = USCRIPT_UNKNOWN for now: |
| // Avoid introducing synonyms/aliases. |
| return -1; |
| } |
| |
| /** |
| * Sets collation attributes according to locale keywords. See |
| * http://www.unicode.org/reports/tr35/tr35-collation.html#Collation_Settings |
| * |
| * Using "alias" keywords and values where defined: |
| * http://www.unicode.org/reports/tr35/tr35.html#Old_Locale_Extension_Syntax |
| * http://unicode.org/repos/cldr/trunk/common/bcp47/collation.xml |
| */ |
| void setAttributesFromKeywords(const Locale &loc, Collator &coll, UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { |
| return; |
| } |
| if (uprv_strcmp(loc.getName(), loc.getBaseName()) == 0) { |
| // No keywords. |
| return; |
| } |
| char value[1024]; // The reordering value could be long. |
| // Check for collation keywords that were already deprecated |
| // before any were supported in createInstance() (except for "collation"). |
| int32_t length = loc.getKeywordValue("colHiraganaQuaternary", value, UPRV_LENGTHOF(value), errorCode); |
| if (U_FAILURE(errorCode)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (length != 0) { |
| errorCode = U_UNSUPPORTED_ERROR; |
| return; |
| } |
| length = loc.getKeywordValue("variableTop", value, UPRV_LENGTHOF(value), errorCode); |
| if (U_FAILURE(errorCode)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (length != 0) { |
| errorCode = U_UNSUPPORTED_ERROR; |
| return; |
| } |
| // Parse known collation keywords, ignore others. |
| if (errorCode == U_STRING_NOT_TERMINATED_WARNING) { |
| errorCode = U_ZERO_ERROR; |
| } |
| for (int32_t i = 0; i < UPRV_LENGTHOF(collAttributes); ++i) { |
| length = loc.getKeywordValue(collAttributes[i].name, value, UPRV_LENGTHOF(value), errorCode); |
| if (U_FAILURE(errorCode) || errorCode == U_STRING_NOT_TERMINATED_WARNING) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (length == 0) { continue; } |
| for (int32_t j = 0;; ++j) { |
| if (j == UPRV_LENGTHOF(collAttributeValues)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (uprv_stricmp(value, collAttributeValues[j].name) == 0) { |
| coll.setAttribute(collAttributes[i].attr, collAttributeValues[j].value, errorCode); |
| break; |
| } |
| } |
| } |
| length = loc.getKeywordValue("colReorder", value, UPRV_LENGTHOF(value), errorCode); |
| if (U_FAILURE(errorCode) || errorCode == U_STRING_NOT_TERMINATED_WARNING) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (length != 0) { |
| int32_t codes[USCRIPT_CODE_LIMIT + UCOL_REORDER_CODE_LIMIT - UCOL_REORDER_CODE_FIRST]; |
| int32_t codesLength = 0; |
| char *scriptName = value; |
| for (;;) { |
| if (codesLength == UPRV_LENGTHOF(codes)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| char *limit = scriptName; |
| char c; |
| while ((c = *limit) != 0 && c != '-') { ++limit; } |
| *limit = 0; |
| int32_t code; |
| if ((limit - scriptName) == 4) { |
| // Strict parsing, accept only 4-letter script codes, not long names. |
| code = u_getPropertyValueEnum(UCHAR_SCRIPT, scriptName); |
| } else { |
| code = getReorderCode(scriptName); |
| } |
| if (code < 0) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| codes[codesLength++] = code; |
| if (c == 0) { break; } |
| scriptName = limit + 1; |
| } |
| coll.setReorderCodes(codes, codesLength, errorCode); |
| } |
| length = loc.getKeywordValue("kv", value, UPRV_LENGTHOF(value), errorCode); |
| if (U_FAILURE(errorCode) || errorCode == U_STRING_NOT_TERMINATED_WARNING) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (length != 0) { |
| int32_t code = getReorderCode(value); |
| if (code < 0) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| coll.setMaxVariable((UColReorderCode)code, errorCode); |
| } |
| if (U_FAILURE(errorCode)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| } |
| |
| } // namespace |
| |
| Collator* U_EXPORT2 Collator::createInstance(UErrorCode& success) |
| { |
| return createInstance(Locale::getDefault(), success); |
| } |
| |
| Collator* U_EXPORT2 Collator::createInstance(const Locale& desiredLocale, |
| UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| return 0; |
| if (desiredLocale.isBogus()) { |
| // Locale constructed from malformed locale ID or language tag. |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| Collator* coll; |
| #if !UCONFIG_NO_SERVICE |
| if (hasService()) { |
| Locale actualLoc; |
| coll = (Collator*)gService->get(desiredLocale, &actualLoc, status); |
| } else |
| #endif |
| { |
| coll = makeInstance(desiredLocale, status); |
| } |
| setAttributesFromKeywords(desiredLocale, *coll, status); |
| if (U_FAILURE(status)) { |
| delete coll; |
| return NULL; |
| } |
| return coll; |
| } |
| |
| |
| Collator* Collator::makeInstance(const Locale& desiredLocale, UErrorCode& status) { |
| const CollationCacheEntry *entry = CollationLoader::loadTailoring(desiredLocale, status); |
| if (U_SUCCESS(status)) { |
| Collator *result = new RuleBasedCollator(entry); |
| if (result != NULL) { |
| // Both the unified cache's get() and the RBC constructor |
| // did addRef(). Undo one of them. |
| entry->removeRef(); |
| return result; |
| } |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| if (entry != NULL) { |
| // Undo the addRef() from the cache.get(). |
| entry->removeRef(); |
| } |
| return NULL; |
| } |
| |
| Collator * |
| Collator::safeClone() const { |
| return clone(); |
| } |
| |
| // implement deprecated, previously abstract method |
| Collator::EComparisonResult Collator::compare(const UnicodeString& source, |
| const UnicodeString& target) const |
| { |
| UErrorCode ec = U_ZERO_ERROR; |
| return (EComparisonResult)compare(source, target, ec); |
| } |
| |
| // implement deprecated, previously abstract method |
| Collator::EComparisonResult Collator::compare(const UnicodeString& source, |
| const UnicodeString& target, |
| int32_t length) const |
| { |
| UErrorCode ec = U_ZERO_ERROR; |
| return (EComparisonResult)compare(source, target, length, ec); |
| } |
| |
| // implement deprecated, previously abstract method |
| Collator::EComparisonResult Collator::compare(const UChar* source, int32_t sourceLength, |
| const UChar* target, int32_t targetLength) |
| const |
| { |
| UErrorCode ec = U_ZERO_ERROR; |
| return (EComparisonResult)compare(source, sourceLength, target, targetLength, ec); |
| } |
| |
| UCollationResult Collator::compare(UCharIterator &/*sIter*/, |
| UCharIterator &/*tIter*/, |
| UErrorCode &status) const { |
| if(U_SUCCESS(status)) { |
| // Not implemented in the base class. |
| status = U_UNSUPPORTED_ERROR; |
| } |
| return UCOL_EQUAL; |
| } |
| |
| UCollationResult Collator::compareUTF8(const StringPiece &source, |
| const StringPiece &target, |
| UErrorCode &status) const { |
| if(U_FAILURE(status)) { |
| return UCOL_EQUAL; |
| } |
| UCharIterator sIter, tIter; |
| uiter_setUTF8(&sIter, source.data(), source.length()); |
| uiter_setUTF8(&tIter, target.data(), target.length()); |
| return compare(sIter, tIter, status); |
| } |
| |
| UBool Collator::equals(const UnicodeString& source, |
| const UnicodeString& target) const |
| { |
| UErrorCode ec = U_ZERO_ERROR; |
| return (compare(source, target, ec) == UCOL_EQUAL); |
| } |
| |
| UBool Collator::greaterOrEqual(const UnicodeString& source, |
| const UnicodeString& target) const |
| { |
| UErrorCode ec = U_ZERO_ERROR; |
| return (compare(source, target, ec) != UCOL_LESS); |
| } |
| |
| UBool Collator::greater(const UnicodeString& source, |
| const UnicodeString& target) const |
| { |
| UErrorCode ec = U_ZERO_ERROR; |
| return (compare(source, target, ec) == UCOL_GREATER); |
| } |
| |
| // this API ignores registered collators, since it returns an |
| // array of indefinite lifetime |
| const Locale* U_EXPORT2 Collator::getAvailableLocales(int32_t& count) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| Locale *result = NULL; |
| count = 0; |
| if (isAvailableLocaleListInitialized(status)) |
| { |
| result = availableLocaleList; |
| count = availableLocaleListCount; |
| } |
| return result; |
| } |
| |
| UnicodeString& U_EXPORT2 Collator::getDisplayName(const Locale& objectLocale, |
| const Locale& displayLocale, |
| UnicodeString& name) |
| { |
| #if !UCONFIG_NO_SERVICE |
| if (hasService()) { |
| UnicodeString locNameStr; |
| LocaleUtility::initNameFromLocale(objectLocale, locNameStr); |
| return gService->getDisplayName(locNameStr, name, displayLocale); |
| } |
| #endif |
| return objectLocale.getDisplayName(displayLocale, name); |
| } |
| |
| UnicodeString& U_EXPORT2 Collator::getDisplayName(const Locale& objectLocale, |
| UnicodeString& name) |
| { |
| return getDisplayName(objectLocale, Locale::getDefault(), name); |
| } |
| |
| /* This is useless information */ |
| /*void Collator::getVersion(UVersionInfo versionInfo) const |
| { |
| if (versionInfo!=NULL) |
| uprv_memcpy(versionInfo, fVersion, U_MAX_VERSION_LENGTH); |
| } |
| */ |
| |
| // UCollator protected constructor destructor ---------------------------- |
| |
| /** |
| * Default constructor. |
| * Constructor is different from the old default Collator constructor. |
| * The task for determing the default collation strength and normalization mode |
| * is left to the child class. |
| */ |
| Collator::Collator() |
| : UObject() |
| { |
| } |
| |
| /** |
| * Constructor. |
| * Empty constructor, does not handle the arguments. |
| * This constructor is done for backward compatibility with 1.7 and 1.8. |
| * The task for handling the argument collation strength and normalization |
| * mode is left to the child class. |
| * @param collationStrength collation strength |
| * @param decompositionMode |
| * @deprecated 2.4 use the default constructor instead |
| */ |
| Collator::Collator(UCollationStrength, UNormalizationMode ) |
| : UObject() |
| { |
| } |
| |
| Collator::~Collator() |
| { |
| } |
| |
| Collator::Collator(const Collator &other) |
| : UObject(other) |
| { |
| } |
| |
| UBool Collator::operator==(const Collator& other) const |
| { |
| // Subclasses: Call this method and then add more specific checks. |
| return typeid(*this) == typeid(other); |
| } |
| |
| UBool Collator::operator!=(const Collator& other) const |
| { |
| return (UBool)!(*this == other); |
| } |
| |
| int32_t U_EXPORT2 Collator::getBound(const uint8_t *source, |
| int32_t sourceLength, |
| UColBoundMode boundType, |
| uint32_t noOfLevels, |
| uint8_t *result, |
| int32_t resultLength, |
| UErrorCode &status) |
| { |
| return ucol_getBound(source, sourceLength, boundType, noOfLevels, result, resultLength, &status); |
| } |
| |
| void |
| Collator::setLocales(const Locale& /* requestedLocale */, const Locale& /* validLocale */, const Locale& /*actualLocale*/) { |
| } |
| |
| UnicodeSet *Collator::getTailoredSet(UErrorCode &status) const |
| { |
| if(U_FAILURE(status)) { |
| return NULL; |
| } |
| // everything can be changed |
| return new UnicodeSet(0, 0x10FFFF); |
| } |
| |
| // ------------------------------------- |
| |
| #if !UCONFIG_NO_SERVICE |
| URegistryKey U_EXPORT2 |
| Collator::registerInstance(Collator* toAdopt, const Locale& locale, UErrorCode& status) |
| { |
| if (U_SUCCESS(status)) { |
| // Set the collator locales while registering so that createInstance() |
| // need not guess whether the collator's locales are already set properly |
| // (as they are by the data loader). |
| toAdopt->setLocales(locale, locale, locale); |
| return getService()->registerInstance(toAdopt, locale, status); |
| } |
| return NULL; |
| } |
| |
| // ------------------------------------- |
| |
| class CFactory : public LocaleKeyFactory { |
| private: |
| CollatorFactory* _delegate; |
| Hashtable* _ids; |
| |
| public: |
| CFactory(CollatorFactory* delegate, UErrorCode& status) |
| : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE) |
| , _delegate(delegate) |
| , _ids(NULL) |
| { |
| if (U_SUCCESS(status)) { |
| int32_t count = 0; |
| _ids = new Hashtable(status); |
| if (_ids) { |
| const UnicodeString * idlist = _delegate->getSupportedIDs(count, status); |
| for (int i = 0; i < count; ++i) { |
| _ids->put(idlist[i], (void*)this, status); |
| if (U_FAILURE(status)) { |
| delete _ids; |
| _ids = NULL; |
| return; |
| } |
| } |
| } else { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| } |
| } |
| |
| virtual ~CFactory(); |
| |
| virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const; |
| |
| protected: |
| virtual const Hashtable* getSupportedIDs(UErrorCode& status) const |
| { |
| if (U_SUCCESS(status)) { |
| return _ids; |
| } |
| return NULL; |
| } |
| |
| virtual UnicodeString& |
| getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const; |
| }; |
| |
| CFactory::~CFactory() |
| { |
| delete _delegate; |
| delete _ids; |
| } |
| |
| UObject* |
| CFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const |
| { |
| if (handlesKey(key, status)) { |
| const LocaleKey& lkey = (const LocaleKey&)key; |
| Locale validLoc; |
| lkey.currentLocale(validLoc); |
| return _delegate->createCollator(validLoc); |
| } |
| return NULL; |
| } |
| |
| UnicodeString& |
| CFactory::getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const |
| { |
| if ((_coverage & 0x1) == 0) { |
| UErrorCode status = U_ZERO_ERROR; |
| const Hashtable* ids = getSupportedIDs(status); |
| if (ids && (ids->get(id) != NULL)) { |
| Locale loc; |
| LocaleUtility::initLocaleFromName(id, loc); |
| return _delegate->getDisplayName(loc, locale, result); |
| } |
| } |
| result.setToBogus(); |
| return result; |
| } |
| |
| URegistryKey U_EXPORT2 |
| Collator::registerFactory(CollatorFactory* toAdopt, UErrorCode& status) |
| { |
| if (U_SUCCESS(status)) { |
| CFactory* f = new CFactory(toAdopt, status); |
| if (f) { |
| return getService()->registerFactory(f, status); |
| } |
| status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| return NULL; |
| } |
| |
| // ------------------------------------- |
| |
| UBool U_EXPORT2 |
| Collator::unregister(URegistryKey key, UErrorCode& status) |
| { |
| if (U_SUCCESS(status)) { |
| if (hasService()) { |
| return gService->unregister(key, status); |
| } |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| return FALSE; |
| } |
| #endif /* UCONFIG_NO_SERVICE */ |
| |
| class CollationLocaleListEnumeration : public StringEnumeration { |
| private: |
| int32_t index; |
| public: |
| static UClassID U_EXPORT2 getStaticClassID(void); |
| virtual UClassID getDynamicClassID(void) const; |
| public: |
| CollationLocaleListEnumeration() |
| : index(0) |
| { |
| // The global variables should already be initialized. |
| //isAvailableLocaleListInitialized(status); |
| } |
| |
| virtual ~CollationLocaleListEnumeration(); |
| |
| virtual StringEnumeration * clone() const |
| { |
| CollationLocaleListEnumeration *result = new CollationLocaleListEnumeration(); |
| if (result) { |
| result->index = index; |
| } |
| return result; |
| } |
| |
| virtual int32_t count(UErrorCode &/*status*/) const { |
| return availableLocaleListCount; |
| } |
| |
| virtual const char* next(int32_t* resultLength, UErrorCode& /*status*/) { |
| const char* result; |
| if(index < availableLocaleListCount) { |
| result = availableLocaleList[index++].getName(); |
| if(resultLength != NULL) { |
| *resultLength = (int32_t)uprv_strlen(result); |
| } |
| } else { |
| if(resultLength != NULL) { |
| *resultLength = 0; |
| } |
| result = NULL; |
| } |
| return result; |
| } |
| |
| virtual const UnicodeString* snext(UErrorCode& status) { |
| int32_t resultLength = 0; |
| const char *s = next(&resultLength, status); |
| return setChars(s, resultLength, status); |
| } |
| |
| virtual void reset(UErrorCode& /*status*/) { |
| index = 0; |
| } |
| }; |
| |
| CollationLocaleListEnumeration::~CollationLocaleListEnumeration() {} |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationLocaleListEnumeration) |
| |
| |
| // ------------------------------------- |
| |
| StringEnumeration* U_EXPORT2 |
| Collator::getAvailableLocales(void) |
| { |
| #if !UCONFIG_NO_SERVICE |
| if (hasService()) { |
| return getService()->getAvailableLocales(); |
| } |
| #endif /* UCONFIG_NO_SERVICE */ |
| UErrorCode status = U_ZERO_ERROR; |
| if (isAvailableLocaleListInitialized(status)) { |
| return new CollationLocaleListEnumeration(); |
| } |
| return NULL; |
| } |
| |
| StringEnumeration* U_EXPORT2 |
| Collator::getKeywords(UErrorCode& status) { |
| return UStringEnumeration::fromUEnumeration( |
| ucol_getKeywords(&status), status); |
| } |
| |
| StringEnumeration* U_EXPORT2 |
| Collator::getKeywordValues(const char *keyword, UErrorCode& status) { |
| return UStringEnumeration::fromUEnumeration( |
| ucol_getKeywordValues(keyword, &status), status); |
| } |
| |
| StringEnumeration* U_EXPORT2 |
| Collator::getKeywordValuesForLocale(const char* key, const Locale& locale, |
| UBool commonlyUsed, UErrorCode& status) { |
| return UStringEnumeration::fromUEnumeration( |
| ucol_getKeywordValuesForLocale( |
| key, locale.getName(), commonlyUsed, &status), |
| status); |
| } |
| |
| Locale U_EXPORT2 |
| Collator::getFunctionalEquivalent(const char* keyword, const Locale& locale, |
| UBool& isAvailable, UErrorCode& status) { |
| // This is a wrapper over ucol_getFunctionalEquivalent |
| char loc[ULOC_FULLNAME_CAPACITY]; |
| /*int32_t len =*/ ucol_getFunctionalEquivalent(loc, sizeof(loc), |
| keyword, locale.getName(), &isAvailable, &status); |
| if (U_FAILURE(status)) { |
| *loc = 0; // root |
| } |
| return Locale::createFromName(loc); |
| } |
| |
| Collator::ECollationStrength |
| Collator::getStrength(void) const { |
| UErrorCode intStatus = U_ZERO_ERROR; |
| return (ECollationStrength)getAttribute(UCOL_STRENGTH, intStatus); |
| } |
| |
| void |
| Collator::setStrength(ECollationStrength newStrength) { |
| UErrorCode intStatus = U_ZERO_ERROR; |
| setAttribute(UCOL_STRENGTH, (UColAttributeValue)newStrength, intStatus); |
| } |
| |
| Collator & |
| Collator::setMaxVariable(UColReorderCode /*group*/, UErrorCode &errorCode) { |
| if (U_SUCCESS(errorCode)) { |
| errorCode = U_UNSUPPORTED_ERROR; |
| } |
| return *this; |
| } |
| |
| UColReorderCode |
| Collator::getMaxVariable() const { |
| return UCOL_REORDER_CODE_PUNCTUATION; |
| } |
| |
| int32_t |
| Collator::getReorderCodes(int32_t* /* dest*/, |
| int32_t /* destCapacity*/, |
| UErrorCode& status) const |
| { |
| if (U_SUCCESS(status)) { |
| status = U_UNSUPPORTED_ERROR; |
| } |
| return 0; |
| } |
| |
| void |
| Collator::setReorderCodes(const int32_t* /* reorderCodes */, |
| int32_t /* reorderCodesLength */, |
| UErrorCode& status) |
| { |
| if (U_SUCCESS(status)) { |
| status = U_UNSUPPORTED_ERROR; |
| } |
| } |
| |
| int32_t |
| Collator::getEquivalentReorderCodes(int32_t reorderCode, |
| int32_t *dest, int32_t capacity, |
| UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return 0; } |
| if(capacity < 0 || (dest == NULL && capacity > 0)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| const CollationData *baseData = CollationRoot::getData(errorCode); |
| if(U_FAILURE(errorCode)) { return 0; } |
| return baseData->getEquivalentScripts(reorderCode, dest, capacity, errorCode); |
| } |
| |
| int32_t |
| Collator::internalGetShortDefinitionString(const char * /*locale*/, |
| char * /*buffer*/, |
| int32_t /*capacity*/, |
| UErrorCode &status) const { |
| if(U_SUCCESS(status)) { |
| status = U_UNSUPPORTED_ERROR; /* Shouldn't happen, internal function */ |
| } |
| return 0; |
| } |
| |
| UCollationResult |
| Collator::internalCompareUTF8(const char *left, int32_t leftLength, |
| const char *right, int32_t rightLength, |
| UErrorCode &errorCode) const { |
| if(U_FAILURE(errorCode)) { return UCOL_EQUAL; } |
| if((left == NULL && leftLength != 0) || (right == NULL && rightLength != 0)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return UCOL_EQUAL; |
| } |
| return compareUTF8( |
| StringPiece(left, (leftLength < 0) ? uprv_strlen(left) : leftLength), |
| StringPiece(right, (rightLength < 0) ? uprv_strlen(right) : rightLength), |
| errorCode); |
| } |
| |
| int32_t |
| Collator::internalNextSortKeyPart(UCharIterator * /*iter*/, uint32_t /*state*/[2], |
| uint8_t * /*dest*/, int32_t /*count*/, UErrorCode &errorCode) const { |
| if (U_SUCCESS(errorCode)) { |
| errorCode = U_UNSUPPORTED_ERROR; |
| } |
| return 0; |
| } |
| |
| // UCollator private data members ---------------------------------------- |
| |
| /* This is useless information */ |
| /*const UVersionInfo Collator::fVersion = {1, 1, 0, 0};*/ |
| |
| // ------------------------------------- |
| |
| U_NAMESPACE_END |
| |
| #endif /* #if !UCONFIG_NO_COLLATION */ |
| |
| /* eof */ |
