| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * Copyright (C) 1996-2016, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| * file name: ucol_res.cpp |
| * encoding: UTF-8 |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * Description: |
| * This file contains dependencies that the collation run-time doesn't normally |
| * need. This mainly contains resource bundle usage and collation meta information |
| * |
| * Modification history |
| * Date Name Comments |
| * 1996-1999 various members of ICU team maintained C API for collation framework |
| * 02/16/2001 synwee Added internal method getPrevSpecialCE |
| * 03/01/2001 synwee Added maxexpansion functionality. |
| * 03/16/2001 weiv Collation framework is rewritten in C and made UCA compliant |
| * 12/08/2004 grhoten Split part of ucol.cpp into ucol_res.cpp |
| * 2012-2014 markus Rewritten in C++ again. |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| #include "unicode/coll.h" |
| #include "unicode/localpointer.h" |
| #include "unicode/locid.h" |
| #include "unicode/tblcoll.h" |
| #include "unicode/ucol.h" |
| #include "unicode/uloc.h" |
| #include "unicode/unistr.h" |
| #include "unicode/ures.h" |
| #include "charstr.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "collationdatareader.h" |
| #include "collationroot.h" |
| #include "collationtailoring.h" |
| #include "resource.h" |
| #include "putilimp.h" |
| #include "uassert.h" |
| #include "ucln_in.h" |
| #include "ucol_imp.h" |
| #include "uenumimp.h" |
| #include "ulist.h" |
| #include "umutex.h" |
| #include "unifiedcache.h" |
| #include "uresimp.h" |
| #include "ustrenum.h" |
| #include "utracimp.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| namespace { |
| |
| static const UChar *rootRules = NULL; |
| static int32_t rootRulesLength = 0; |
| static UResourceBundle *rootBundle = NULL; |
| static UInitOnce gInitOnceUcolRes = U_INITONCE_INITIALIZER; |
| |
| } // namespace |
| |
| U_CDECL_BEGIN |
| |
| static UBool U_CALLCONV |
| ucol_res_cleanup() { |
| rootRules = NULL; |
| rootRulesLength = 0; |
| ures_close(rootBundle); |
| rootBundle = NULL; |
| gInitOnceUcolRes.reset(); |
| return TRUE; |
| } |
| |
| void U_CALLCONV |
| CollationLoader::loadRootRules(UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| rootBundle = ures_open(U_ICUDATA_COLL, kRootLocaleName, &errorCode); |
| if(U_FAILURE(errorCode)) { return; } |
| rootRules = ures_getStringByKey(rootBundle, "UCARules", &rootRulesLength, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| ures_close(rootBundle); |
| rootBundle = NULL; |
| return; |
| } |
| ucln_i18n_registerCleanup(UCLN_I18N_UCOL_RES, ucol_res_cleanup); |
| } |
| |
| U_CDECL_END |
| |
| void |
| CollationLoader::appendRootRules(UnicodeString &s) { |
| UErrorCode errorCode = U_ZERO_ERROR; |
| umtx_initOnce(gInitOnceUcolRes, CollationLoader::loadRootRules, errorCode); |
| if(U_SUCCESS(errorCode)) { |
| s.append(rootRules, rootRulesLength); |
| } |
| } |
| |
| void |
| CollationLoader::loadRules(const char *localeID, const char *collationType, |
| UnicodeString &rules, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| U_ASSERT(collationType != NULL && *collationType != 0); |
| // Copy the type for lowercasing. |
| char type[16]; |
| int32_t typeLength = static_cast<int32_t>(uprv_strlen(collationType)); |
| if(typeLength >= UPRV_LENGTHOF(type)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| uprv_memcpy(type, collationType, typeLength + 1); |
| T_CString_toLowerCase(type); |
| |
| LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, localeID, &errorCode)); |
| LocalUResourceBundlePointer collations( |
| ures_getByKey(bundle.getAlias(), "collations", NULL, &errorCode)); |
| LocalUResourceBundlePointer data( |
| ures_getByKeyWithFallback(collations.getAlias(), type, NULL, &errorCode)); |
| int32_t length; |
| const UChar *s = ures_getStringByKey(data.getAlias(), "Sequence", &length, &errorCode); |
| if(U_FAILURE(errorCode)) { return; } |
| |
| // No string pointer aliasing so that we need not hold onto the resource bundle. |
| rules.setTo(s, length); |
| if(rules.isBogus()) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| } |
| } |
| |
| template<> U_I18N_API |
| const CollationCacheEntry * |
| LocaleCacheKey<CollationCacheEntry>::createObject(const void *creationContext, |
| UErrorCode &errorCode) const { |
| CollationLoader *loader = |
| reinterpret_cast<CollationLoader *>( |
| const_cast<void *>(creationContext)); |
| return loader->createCacheEntry(errorCode); |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::loadTailoring(const Locale &locale, UErrorCode &errorCode) { |
| const CollationCacheEntry *rootEntry = CollationRoot::getRootCacheEntry(errorCode); |
| if(U_FAILURE(errorCode)) { return NULL; } |
| const char *name = locale.getName(); |
| if(*name == 0 || uprv_strcmp(name, "root") == 0) { |
| |
| // Have to add a ref. |
| rootEntry->addRef(); |
| return rootEntry; |
| } |
| |
| // Clear warning codes before loading where they get cached. |
| errorCode = U_ZERO_ERROR; |
| CollationLoader loader(rootEntry, locale, errorCode); |
| |
| // getCacheEntry adds a ref for us. |
| return loader.getCacheEntry(errorCode); |
| } |
| |
| CollationLoader::CollationLoader(const CollationCacheEntry *re, const Locale &requested, |
| UErrorCode &errorCode) |
| : cache(UnifiedCache::getInstance(errorCode)), rootEntry(re), |
| validLocale(re->validLocale), locale(requested), |
| typesTried(0), typeFallback(FALSE), |
| bundle(NULL), collations(NULL), data(NULL) { |
| type[0] = 0; |
| defaultType[0] = 0; |
| if(U_FAILURE(errorCode)) { return; } |
| |
| // Canonicalize the locale ID: Ignore all irrelevant keywords. |
| const char *baseName = locale.getBaseName(); |
| if(uprv_strcmp(locale.getName(), baseName) != 0) { |
| locale = Locale(baseName); |
| |
| // Fetch the collation type from the locale ID. |
| int32_t typeLength = requested.getKeywordValue("collation", |
| type, UPRV_LENGTHOF(type) - 1, errorCode); |
| if(U_FAILURE(errorCode)) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| type[typeLength] = 0; // in case of U_NOT_TERMINATED_WARNING |
| if(typeLength == 0) { |
| // No collation type. |
| } else if(uprv_stricmp(type, "default") == 0) { |
| // Ignore "default" (case-insensitive). |
| type[0] = 0; |
| } else { |
| // Copy the collation type. |
| T_CString_toLowerCase(type); |
| locale.setKeywordValue("collation", type, errorCode); |
| } |
| } |
| } |
| |
| CollationLoader::~CollationLoader() { |
| ures_close(data); |
| ures_close(collations); |
| ures_close(bundle); |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::createCacheEntry(UErrorCode &errorCode) { |
| // This is a linear lookup and fallback flow turned into a state machine. |
| // Most local variables have been turned into instance fields. |
| // In a cache miss, cache.get() calls CacheKey::createObject(), |
| // which means that we progress via recursion. |
| // loadFromCollations() will recurse to itself as well for collation type fallback. |
| if(bundle == NULL) { |
| return loadFromLocale(errorCode); |
| } else if(collations == NULL) { |
| return loadFromBundle(errorCode); |
| } else if(data == NULL) { |
| return loadFromCollations(errorCode); |
| } else { |
| return loadFromData(errorCode); |
| } |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::loadFromLocale(UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return NULL; } |
| U_ASSERT(bundle == NULL); |
| bundle = ures_openNoDefault(U_ICUDATA_COLL, locale.getBaseName(), &errorCode); |
| if(errorCode == U_MISSING_RESOURCE_ERROR) { |
| errorCode = U_USING_DEFAULT_WARNING; |
| |
| // Have to add that ref that we promise. |
| rootEntry->addRef(); |
| return rootEntry; |
| } |
| Locale requestedLocale(locale); |
| const char *vLocale = ures_getLocaleByType(bundle, ULOC_ACTUAL_LOCALE, &errorCode); |
| if(U_FAILURE(errorCode)) { return NULL; } |
| locale = validLocale = Locale(vLocale); // no type until loadFromCollations() |
| if(type[0] != 0) { |
| locale.setKeywordValue("collation", type, errorCode); |
| } |
| if(locale != requestedLocale) { |
| return getCacheEntry(errorCode); |
| } else { |
| return loadFromBundle(errorCode); |
| } |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::loadFromBundle(UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return NULL; } |
| U_ASSERT(collations == NULL); |
| // There are zero or more tailorings in the collations table. |
| collations = ures_getByKey(bundle, "collations", NULL, &errorCode); |
| if(errorCode == U_MISSING_RESOURCE_ERROR) { |
| errorCode = U_USING_DEFAULT_WARNING; |
| // Return the root tailoring with the validLocale, without collation type. |
| return makeCacheEntryFromRoot(validLocale, errorCode); |
| } |
| if(U_FAILURE(errorCode)) { return NULL; } |
| |
| // Fetch the default type from the data. |
| { |
| UErrorCode internalErrorCode = U_ZERO_ERROR; |
| LocalUResourceBundlePointer def( |
| ures_getByKeyWithFallback(collations, "default", NULL, &internalErrorCode)); |
| int32_t length; |
| const UChar *s = ures_getString(def.getAlias(), &length, &internalErrorCode); |
| if(U_SUCCESS(internalErrorCode) && 0 < length && length < UPRV_LENGTHOF(defaultType)) { |
| u_UCharsToChars(s, defaultType, length + 1); |
| } else { |
| uprv_strcpy(defaultType, "standard"); |
| } |
| } |
| |
| // Record which collation types we have looked for already, |
| // so that we do not deadlock in the cache. |
| // |
| // If there is no explicit type, then we look in the cache |
| // for the entry with the default type. |
| // If the explicit type is the default type, then we do not look in the cache |
| // for the entry with an empty type. |
| // Otherwise, two concurrent requests with opposite fallbacks would deadlock each other. |
| // Also, it is easier to always enter the next method with a non-empty type. |
| if(type[0] == 0) { |
| uprv_strcpy(type, defaultType); |
| typesTried |= TRIED_DEFAULT; |
| if(uprv_strcmp(type, "search") == 0) { |
| typesTried |= TRIED_SEARCH; |
| } |
| if(uprv_strcmp(type, "standard") == 0) { |
| typesTried |= TRIED_STANDARD; |
| } |
| locale.setKeywordValue("collation", type, errorCode); |
| return getCacheEntry(errorCode); |
| } else { |
| if(uprv_strcmp(type, defaultType) == 0) { |
| typesTried |= TRIED_DEFAULT; |
| } |
| if(uprv_strcmp(type, "search") == 0) { |
| typesTried |= TRIED_SEARCH; |
| } |
| if(uprv_strcmp(type, "standard") == 0) { |
| typesTried |= TRIED_STANDARD; |
| } |
| return loadFromCollations(errorCode); |
| } |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::loadFromCollations(UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return NULL; } |
| U_ASSERT(data == NULL); |
| // Load the collations/type tailoring, with type fallback. |
| LocalUResourceBundlePointer localData( |
| ures_getByKeyWithFallback(collations, type, NULL, &errorCode)); |
| int32_t typeLength = static_cast<int32_t>(uprv_strlen(type)); |
| if(errorCode == U_MISSING_RESOURCE_ERROR) { |
| errorCode = U_USING_DEFAULT_WARNING; |
| typeFallback = TRUE; |
| if((typesTried & TRIED_SEARCH) == 0 && |
| typeLength > 6 && uprv_strncmp(type, "search", 6) == 0) { |
| // fall back from something like "searchjl" to "search" |
| typesTried |= TRIED_SEARCH; |
| type[6] = 0; |
| } else if((typesTried & TRIED_DEFAULT) == 0) { |
| // fall back to the default type |
| typesTried |= TRIED_DEFAULT; |
| uprv_strcpy(type, defaultType); |
| } else if((typesTried & TRIED_STANDARD) == 0) { |
| // fall back to the "standard" type |
| typesTried |= TRIED_STANDARD; |
| uprv_strcpy(type, "standard"); |
| } else { |
| // Return the root tailoring with the validLocale, without collation type. |
| return makeCacheEntryFromRoot(validLocale, errorCode); |
| } |
| locale.setKeywordValue("collation", type, errorCode); |
| return getCacheEntry(errorCode); |
| } |
| if(U_FAILURE(errorCode)) { return NULL; } |
| |
| data = localData.orphan(); |
| const char *actualLocale = ures_getLocaleByType(data, ULOC_ACTUAL_LOCALE, &errorCode); |
| if(U_FAILURE(errorCode)) { return NULL; } |
| const char *vLocale = validLocale.getBaseName(); |
| UBool actualAndValidLocalesAreDifferent = Locale(actualLocale) != Locale(vLocale); |
| |
| // Set the collation types on the informational locales, |
| // except when they match the default types (for brevity and backwards compatibility). |
| // For the valid locale, suppress the default type. |
| if(uprv_strcmp(type, defaultType) != 0) { |
| validLocale.setKeywordValue("collation", type, errorCode); |
| if(U_FAILURE(errorCode)) { return NULL; } |
| } |
| |
| // Is this the same as the root collator? If so, then use that instead. |
| if((*actualLocale == 0 || uprv_strcmp(actualLocale, "root") == 0) && |
| uprv_strcmp(type, "standard") == 0) { |
| if(typeFallback) { |
| errorCode = U_USING_DEFAULT_WARNING; |
| } |
| return makeCacheEntryFromRoot(validLocale, errorCode); |
| } |
| |
| locale = Locale(actualLocale); |
| if(actualAndValidLocalesAreDifferent) { |
| locale.setKeywordValue("collation", type, errorCode); |
| const CollationCacheEntry *entry = getCacheEntry(errorCode); |
| return makeCacheEntry(validLocale, entry, errorCode); |
| } else { |
| return loadFromData(errorCode); |
| } |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::loadFromData(UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return NULL; } |
| LocalPointer<CollationTailoring> t(new CollationTailoring(rootEntry->tailoring->settings)); |
| if(t.isNull() || t->isBogus()) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| // deserialize |
| LocalUResourceBundlePointer binary(ures_getByKey(data, "%%CollationBin", NULL, &errorCode)); |
| // Note: U_MISSING_RESOURCE_ERROR --> The old code built from rules if available |
| // but that created undesirable dependencies. |
| int32_t length; |
| const uint8_t *inBytes = ures_getBinary(binary.getAlias(), &length, &errorCode); |
| CollationDataReader::read(rootEntry->tailoring, inBytes, length, *t, errorCode); |
| // Note: U_COLLATOR_VERSION_MISMATCH --> The old code built from rules if available |
| // but that created undesirable dependencies. |
| if(U_FAILURE(errorCode)) { return NULL; } |
| |
| // Try to fetch the optional rules string. |
| { |
| UErrorCode internalErrorCode = U_ZERO_ERROR; |
| int32_t len; |
| const UChar *s = ures_getStringByKey(data, "Sequence", &len, |
| &internalErrorCode); |
| if(U_SUCCESS(internalErrorCode)) { |
| t->rules.setTo(TRUE, s, len); |
| } |
| } |
| |
| const char *actualLocale = locale.getBaseName(); // without type |
| const char *vLocale = validLocale.getBaseName(); |
| UBool actualAndValidLocalesAreDifferent = Locale(actualLocale) != Locale(vLocale); |
| |
| // For the actual locale, suppress the default type *according to the actual locale*. |
| // For example, zh has default=pinyin and contains all of the Chinese tailorings. |
| // zh_Hant has default=stroke but has no other data. |
| // For the valid locale "zh_Hant" we need to suppress stroke. |
| // For the actual locale "zh" we need to suppress pinyin instead. |
| if(actualAndValidLocalesAreDifferent) { |
| // Opening a bundle for the actual locale should always succeed. |
| LocalUResourceBundlePointer actualBundle( |
| ures_open(U_ICUDATA_COLL, actualLocale, &errorCode)); |
| if(U_FAILURE(errorCode)) { return NULL; } |
| UErrorCode internalErrorCode = U_ZERO_ERROR; |
| LocalUResourceBundlePointer def( |
| ures_getByKeyWithFallback(actualBundle.getAlias(), "collations/default", NULL, |
| &internalErrorCode)); |
| int32_t len; |
| const UChar *s = ures_getString(def.getAlias(), &len, &internalErrorCode); |
| if(U_SUCCESS(internalErrorCode) && len < UPRV_LENGTHOF(defaultType)) { |
| u_UCharsToChars(s, defaultType, len + 1); |
| } else { |
| uprv_strcpy(defaultType, "standard"); |
| } |
| } |
| t->actualLocale = locale; |
| if(uprv_strcmp(type, defaultType) != 0) { |
| t->actualLocale.setKeywordValue("collation", type, errorCode); |
| } else if(uprv_strcmp(locale.getName(), locale.getBaseName()) != 0) { |
| // Remove the collation keyword if it was set. |
| t->actualLocale.setKeywordValue("collation", NULL, errorCode); |
| } |
| if(U_FAILURE(errorCode)) { return NULL; } |
| |
| if(typeFallback) { |
| errorCode = U_USING_DEFAULT_WARNING; |
| } |
| t->bundle = bundle; |
| bundle = NULL; |
| const CollationCacheEntry *entry = new CollationCacheEntry(validLocale, t.getAlias()); |
| if(entry == NULL) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return nullptr; |
| } else { |
| t.orphan(); |
| } |
| // Have to add that reference that we promise. |
| entry->addRef(); |
| return entry; |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::getCacheEntry(UErrorCode &errorCode) { |
| LocaleCacheKey<CollationCacheEntry> key(locale); |
| const CollationCacheEntry *entry = NULL; |
| cache->get(key, this, entry, errorCode); |
| return entry; |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::makeCacheEntryFromRoot( |
| const Locale &/*loc*/, |
| UErrorCode &errorCode) const { |
| if (U_FAILURE(errorCode)) { |
| return NULL; |
| } |
| rootEntry->addRef(); |
| return makeCacheEntry(validLocale, rootEntry, errorCode); |
| } |
| |
| const CollationCacheEntry * |
| CollationLoader::makeCacheEntry( |
| const Locale &loc, |
| const CollationCacheEntry *entryFromCache, |
| UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode) || loc == entryFromCache->validLocale) { |
| return entryFromCache; |
| } |
| CollationCacheEntry *entry = new CollationCacheEntry(loc, entryFromCache->tailoring); |
| if(entry == NULL) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| entryFromCache->removeRef(); |
| return NULL; |
| } |
| entry->addRef(); |
| entryFromCache->removeRef(); |
| return entry; |
| } |
| |
| U_NAMESPACE_END |
| |
| U_NAMESPACE_USE |
| |
| U_CAPI UCollator* |
| ucol_open(const char *loc, |
| UErrorCode *status) |
| { |
| UTRACE_ENTRY_OC(UTRACE_UCOL_OPEN); |
| UTRACE_DATA1(UTRACE_INFO, "locale = \"%s\"", loc); |
| UCollator *result = NULL; |
| |
| Collator *coll = Collator::createInstance(loc, *status); |
| if(U_SUCCESS(*status)) { |
| result = coll->toUCollator(); |
| } |
| UTRACE_EXIT_PTR_STATUS(result, *status); |
| return result; |
| } |
| |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_getDisplayName( const char *objLoc, |
| const char *dispLoc, |
| UChar *result, |
| int32_t resultLength, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return -1; |
| UnicodeString dst; |
| if(!(result==NULL && resultLength==0)) { |
| // NULL destination for pure preflighting: empty dummy string |
| // otherwise, alias the destination buffer |
| dst.setTo(result, 0, resultLength); |
| } |
| Collator::getDisplayName(Locale(objLoc), Locale(dispLoc), dst); |
| return dst.extract(result, resultLength, *status); |
| } |
| |
| U_CAPI const char* U_EXPORT2 |
| ucol_getAvailable(int32_t index) |
| { |
| int32_t count = 0; |
| const Locale *loc = Collator::getAvailableLocales(count); |
| if (loc != NULL && index < count) { |
| return loc[index].getName(); |
| } |
| return NULL; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_countAvailable() |
| { |
| int32_t count = 0; |
| Collator::getAvailableLocales(count); |
| return count; |
| } |
| |
| #if !UCONFIG_NO_SERVICE |
| U_CAPI UEnumeration* U_EXPORT2 |
| ucol_openAvailableLocales(UErrorCode *status) { |
| // This is a wrapper over Collator::getAvailableLocales() |
| if (U_FAILURE(*status)) { |
| return NULL; |
| } |
| StringEnumeration *s = icu::Collator::getAvailableLocales(); |
| if (s == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| return uenum_openFromStringEnumeration(s, status); |
| } |
| #endif |
| |
| // Note: KEYWORDS[0] != RESOURCE_NAME - alan |
| |
| static const char RESOURCE_NAME[] = "collations"; |
| |
| static const char* const KEYWORDS[] = { "collation" }; |
| |
| #define KEYWORD_COUNT UPRV_LENGTHOF(KEYWORDS) |
| |
| U_CAPI UEnumeration* U_EXPORT2 |
| ucol_getKeywords(UErrorCode *status) { |
| UEnumeration *result = NULL; |
| if (U_SUCCESS(*status)) { |
| return uenum_openCharStringsEnumeration(KEYWORDS, KEYWORD_COUNT, status); |
| } |
| return result; |
| } |
| |
| U_CAPI UEnumeration* U_EXPORT2 |
| ucol_getKeywordValues(const char *keyword, UErrorCode *status) { |
| if (U_FAILURE(*status)) { |
| return NULL; |
| } |
| // hard-coded to accept exactly one collation keyword |
| // modify if additional collation keyword is added later |
| if (keyword==NULL || uprv_strcmp(keyword, KEYWORDS[0])!=0) |
| { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| return ures_getKeywordValues(U_ICUDATA_COLL, RESOURCE_NAME, status); |
| } |
| |
| static const UEnumeration defaultKeywordValues = { |
| NULL, |
| NULL, |
| ulist_close_keyword_values_iterator, |
| ulist_count_keyword_values, |
| uenum_unextDefault, |
| ulist_next_keyword_value, |
| ulist_reset_keyword_values_iterator |
| }; |
| |
| namespace { |
| |
| struct KeywordsSink : public ResourceSink { |
| public: |
| KeywordsSink(UErrorCode &errorCode) : |
| values(ulist_createEmptyList(&errorCode)), hasDefault(FALSE) {} |
| virtual ~KeywordsSink(); |
| |
| virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/, |
| UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| ResourceTable collations = value.getTable(errorCode); |
| for (int32_t i = 0; collations.getKeyAndValue(i, key, value); ++i) { |
| UResType type = value.getType(); |
| if (type == URES_STRING) { |
| if (!hasDefault && uprv_strcmp(key, "default") == 0) { |
| CharString defcoll; |
| defcoll.appendInvariantChars(value.getUnicodeString(errorCode), errorCode); |
| if (U_SUCCESS(errorCode) && !defcoll.isEmpty()) { |
| char *ownedDefault = uprv_strdup(defcoll.data()); |
| if (ownedDefault == NULL) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| ulist_removeString(values, defcoll.data()); |
| ulist_addItemBeginList(values, ownedDefault, TRUE, &errorCode); |
| hasDefault = TRUE; |
| } |
| } |
| } else if (type == URES_TABLE && uprv_strncmp(key, "private-", 8) != 0) { |
| if (!ulist_containsString(values, key, (int32_t)uprv_strlen(key))) { |
| ulist_addItemEndList(values, key, FALSE, &errorCode); |
| } |
| } |
| if (U_FAILURE(errorCode)) { return; } |
| } |
| } |
| |
| UList *values; |
| UBool hasDefault; |
| }; |
| |
| KeywordsSink::~KeywordsSink() { |
| ulist_deleteList(values); |
| } |
| |
| } // namespace |
| |
| U_CAPI UEnumeration* U_EXPORT2 |
| ucol_getKeywordValuesForLocale(const char* /*key*/, const char* locale, |
| UBool /*commonlyUsed*/, UErrorCode* status) { |
| // Note: The parameter commonlyUsed is not used. |
| // The switch is in the method signature for consistency |
| // with other locale services. |
| |
| // Read available collation values from collation bundles. |
| LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, locale, status)); |
| KeywordsSink sink(*status); |
| ures_getAllItemsWithFallback(bundle.getAlias(), RESOURCE_NAME, sink, *status); |
| if (U_FAILURE(*status)) { return NULL; } |
| |
| UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration)); |
| if (en == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| memcpy(en, &defaultKeywordValues, sizeof(UEnumeration)); |
| ulist_resetList(sink.values); // Initialize the iterator. |
| en->context = sink.values; |
| sink.values = NULL; // Avoid deletion in the sink destructor. |
| return en; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity, |
| const char* keyword, const char* locale, |
| UBool* isAvailable, UErrorCode* status) |
| { |
| // N.B.: Resource name is "collations" but keyword is "collation" |
| return ures_getFunctionalEquivalent(result, resultCapacity, U_ICUDATA_COLL, |
| "collations", keyword, locale, |
| isAvailable, TRUE, status); |
| } |
| |
| #endif /* #if !UCONFIG_NO_COLLATION */ |
