icuSources/i18n/ucol_res.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 *   Copyright (C) 1996-2016, International Business Machines
   6 *   Corporation and others.  All Rights Reserved.
   7 *******************************************************************************
   8 *   file name:  ucol_res.cpp
   9 *   encoding:   UTF-8
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 * Description:
  14 * This file contains dependencies that the collation run-time doesn't normally
  15 * need. This mainly contains resource bundle usage and collation meta information
  16 *
  17 * Modification history
  18 * Date        Name      Comments
  19 * 1996-1999   various members of ICU team maintained C API for collation framework
  20 * 02/16/2001  synwee    Added internal method getPrevSpecialCE
  21 * 03/01/2001  synwee    Added maxexpansion functionality.
  22 * 03/16/2001  weiv      Collation framework is rewritten in C and made UCA compliant
  23 * 12/08/2004  grhoten   Split part of ucol.cpp into ucol_res.cpp
  24 * 2012-2014   markus    Rewritten in C++ again.
  25 */
  26
  27 #include "unicode/utypes.h"
  28
  29 #if !UCONFIG_NO_COLLATION
  30
  31 #include "unicode/coll.h"
  32 #include "unicode/localpointer.h"
  33 #include "unicode/locid.h"
  34 #include "unicode/tblcoll.h"
  35 #include "unicode/ucol.h"
  36 #include "unicode/uloc.h"
  37 #include "unicode/unistr.h"
  38 #include "unicode/ures.h"
  39 #include "charstr.h"
  40 #include "cmemory.h"
  41 #include "cstring.h"
  42 #include "collationdatareader.h"
  43 #include "collationroot.h"
  44 #include "collationtailoring.h"
  45 #include "resource.h"
  46 #include "putilimp.h"
  47 #include "uassert.h"
  48 #include "ucln_in.h"
  49 #include "ucol_imp.h"
  50 #include "uenumimp.h"
  51 #include "ulist.h"
  52 #include "umutex.h"
  53 #include "unifiedcache.h"
  54 #include "uresimp.h"
  55 #include "ustrenum.h"
  56 #include "utracimp.h"
  57
  58 U_NAMESPACE_BEGIN
  59
  60 namespace {
  61
  62 static const UChar *rootRules = NULL;
  63 static int32_t rootRulesLength = 0;
  64 static UResourceBundle *rootBundle = NULL;
  65 static UInitOnce gInitOnceUcolRes = U_INITONCE_INITIALIZER;
  66
  67 }  // namespace
  68
  69 U_CDECL_BEGIN
  70
  71 static UBool U_CALLCONV
  72 ucol_res_cleanup() {
  73     rootRules = NULL;
  74     rootRulesLength = 0;
  75     ures_close(rootBundle);
  76     rootBundle = NULL;
  77     gInitOnceUcolRes.reset();
  78     return TRUE;
  79 }
  80
  81 void U_CALLCONV
  82 CollationLoader::loadRootRules(UErrorCode &errorCode) {
  83     if(U_FAILURE(errorCode)) { return; }
  84     rootBundle = ures_open(U_ICUDATA_COLL, kRootLocaleName, &errorCode);
  85     if(U_FAILURE(errorCode)) { return; }
  86     rootRules = ures_getStringByKey(rootBundle, "UCARules", &rootRulesLength, &errorCode);
  87     if(U_FAILURE(errorCode)) {
  88         ures_close(rootBundle);
  89         rootBundle = NULL;
  90         return;
  91     }
  92     ucln_i18n_registerCleanup(UCLN_I18N_UCOL_RES, ucol_res_cleanup);
  93 }
  94
  95 U_CDECL_END
  96
  97 void
  98 CollationLoader::appendRootRules(UnicodeString &s) {
  99     UErrorCode errorCode = U_ZERO_ERROR;
 100     umtx_initOnce(gInitOnceUcolRes, CollationLoader::loadRootRules, errorCode);
 101     if(U_SUCCESS(errorCode)) {
 102         s.append(rootRules, rootRulesLength);
 103     }
 104 }
 105
 106 void
 107 CollationLoader::loadRules(const char *localeID, const char *collationType,
 108                            UnicodeString &rules, UErrorCode &errorCode) {
 109     if(U_FAILURE(errorCode)) { return; }
 110     U_ASSERT(collationType != NULL && *collationType != 0);
 111     // Copy the type for lowercasing.
 112     char type[16];
 113     int32_t typeLength = static_cast<int32_t>(uprv_strlen(collationType));
 114     if(typeLength >= UPRV_LENGTHOF(type)) {
 115         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 116         return;
 117     }
 118     uprv_memcpy(type, collationType, typeLength + 1);
 119     T_CString_toLowerCase(type);
 120
 121     LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, localeID, &errorCode));
 122     LocalUResourceBundlePointer collations(
 123             ures_getByKey(bundle.getAlias(), "collations", NULL, &errorCode));
 124     LocalUResourceBundlePointer data(
 125             ures_getByKeyWithFallback(collations.getAlias(), type, NULL, &errorCode));
 126     int32_t length;
 127     const UChar *s =  ures_getStringByKey(data.getAlias(), "Sequence", &length, &errorCode);
 128     if(U_FAILURE(errorCode)) { return; }
 129
 130     // No string pointer aliasing so that we need not hold onto the resource bundle.
 131     rules.setTo(s, length);
 132     if(rules.isBogus()) {
 133         errorCode = U_MEMORY_ALLOCATION_ERROR;
 134     }
 135 }
 136
 137 template<> U_I18N_API
 138 const CollationCacheEntry *
 139 LocaleCacheKey<CollationCacheEntry>::createObject(const void *creationContext,
 140                                                   UErrorCode &errorCode) const {
 141     CollationLoader *loader =
 142             reinterpret_cast<CollationLoader *>(
 143                     const_cast<void *>(creationContext));
 144     return loader->createCacheEntry(errorCode);
 145 }
 146
 147 const CollationCacheEntry *
 148 CollationLoader::loadTailoring(const Locale &locale, UErrorCode &errorCode) {
 149     const CollationCacheEntry *rootEntry = CollationRoot::getRootCacheEntry(errorCode);
 150     if(U_FAILURE(errorCode)) { return NULL; }
 151     const char *name = locale.getName();
 152     if(*name == 0 || uprv_strcmp(name, "root") == 0) {
 153
 154         // Have to add a ref.
 155         rootEntry->addRef();
 156         return rootEntry;
 157     }
 158
 159     // Clear warning codes before loading where they get cached.
 160     errorCode = U_ZERO_ERROR;
 161     CollationLoader loader(rootEntry, locale, errorCode);
 162
 163     // getCacheEntry adds a ref for us.
 164     return loader.getCacheEntry(errorCode);
 165 }
 166
 167 CollationLoader::CollationLoader(const CollationCacheEntry *re, const Locale &requested,
 168                                  UErrorCode &errorCode)
 169         : cache(UnifiedCache::getInstance(errorCode)), rootEntry(re),
 170           validLocale(re->validLocale), locale(requested),
 171           typesTried(0), typeFallback(FALSE),
 172           bundle(NULL), collations(NULL), data(NULL) {
 173     type[0] = 0;
 174     defaultType[0] = 0;
 175     if(U_FAILURE(errorCode)) { return; }
 176
 177     // Canonicalize the locale ID: Ignore all irrelevant keywords.
 178     const char *baseName = locale.getBaseName();
 179     if(uprv_strcmp(locale.getName(), baseName) != 0) {
 180         locale = Locale(baseName);
 181
 182         // Fetch the collation type from the locale ID.
 183         int32_t typeLength = requested.getKeywordValue("collation",
 184                 type, UPRV_LENGTHOF(type) - 1, errorCode);
 185         if(U_FAILURE(errorCode)) {
 186             errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 187             return;
 188         }
 189         type[typeLength] = 0;  // in case of U_NOT_TERMINATED_WARNING
 190         if(typeLength == 0) {
 191             // No collation type.
 192         } else if(uprv_stricmp(type, "default") == 0) {
 193             // Ignore "default" (case-insensitive).
 194             type[0] = 0;
 195         } else {
 196             // Copy the collation type.
 197             T_CString_toLowerCase(type);
 198             locale.setKeywordValue("collation", type, errorCode);
 199         }
 200     }
 201 }
 202
 203 CollationLoader::~CollationLoader() {
 204     ures_close(data);
 205     ures_close(collations);
 206     ures_close(bundle);
 207 }
 208
 209 const CollationCacheEntry *
 210 CollationLoader::createCacheEntry(UErrorCode &errorCode) {
 211     // This is a linear lookup and fallback flow turned into a state machine.
 212     // Most local variables have been turned into instance fields.
 213     // In a cache miss, cache.get() calls CacheKey::createObject(),
 214     // which means that we progress via recursion.
 215     // loadFromCollations() will recurse to itself as well for collation type fallback.
 216     if(bundle == NULL) {
 217         return loadFromLocale(errorCode);
 218     } else if(collations == NULL) {
 219         return loadFromBundle(errorCode);
 220     } else if(data == NULL) {
 221         return loadFromCollations(errorCode);
 222     } else {
 223         return loadFromData(errorCode);
 224     }
 225 }
 226
 227 const CollationCacheEntry *
 228 CollationLoader::loadFromLocale(UErrorCode &errorCode) {
 229     if(U_FAILURE(errorCode)) { return NULL; }
 230     U_ASSERT(bundle == NULL);
 231     bundle = ures_openNoDefault(U_ICUDATA_COLL, locale.getBaseName(), &errorCode);
 232     if(errorCode == U_MISSING_RESOURCE_ERROR) {
 233         errorCode = U_USING_DEFAULT_WARNING;
 234
 235         // Have to add that ref that we promise.
 236         rootEntry->addRef();
 237         return rootEntry;
 238     }
 239     Locale requestedLocale(locale);
 240     const char *vLocale = ures_getLocaleByType(bundle, ULOC_ACTUAL_LOCALE, &errorCode);
 241     if(U_FAILURE(errorCode)) { return NULL; }
 242     locale = validLocale = Locale(vLocale);  // no type until loadFromCollations()
 243     if(type[0] != 0) {
 244         locale.setKeywordValue("collation", type, errorCode);
 245     }
 246     if(locale != requestedLocale) {
 247         return getCacheEntry(errorCode);
 248     } else {
 249         return loadFromBundle(errorCode);
 250     }
 251 }
 252
 253 const CollationCacheEntry *
 254 CollationLoader::loadFromBundle(UErrorCode &errorCode) {
 255     if(U_FAILURE(errorCode)) { return NULL; }
 256     U_ASSERT(collations == NULL);
 257     // There are zero or more tailorings in the collations table.
 258     collations = ures_getByKey(bundle, "collations", NULL, &errorCode);
 259     if(errorCode == U_MISSING_RESOURCE_ERROR) {
 260         errorCode = U_USING_DEFAULT_WARNING;
 261         // Return the root tailoring with the validLocale, without collation type.
 262         return makeCacheEntryFromRoot(validLocale, errorCode);
 263     }
 264     if(U_FAILURE(errorCode)) { return NULL; }
 265
 266     // Fetch the default type from the data.
 267     {
 268         UErrorCode internalErrorCode = U_ZERO_ERROR;
 269         LocalUResourceBundlePointer def(
 270                 ures_getByKeyWithFallback(collations, "default", NULL, &internalErrorCode));
 271         int32_t length;
 272         const UChar *s = ures_getString(def.getAlias(), &length, &internalErrorCode);
 273         if(U_SUCCESS(internalErrorCode) && 0 < length && length < UPRV_LENGTHOF(defaultType)) {
 274             u_UCharsToChars(s, defaultType, length + 1);
 275         } else {
 276             uprv_strcpy(defaultType, "standard");
 277         }
 278     }
 279
 280     // Record which collation types we have looked for already,
 281     // so that we do not deadlock in the cache.
 282     //
 283     // If there is no explicit type, then we look in the cache
 284     // for the entry with the default type.
 285     // If the explicit type is the default type, then we do not look in the cache
 286     // for the entry with an empty type.
 287     // Otherwise, two concurrent requests with opposite fallbacks would deadlock each other.
 288     // Also, it is easier to always enter the next method with a non-empty type.
 289     if(type[0] == 0) {
 290         uprv_strcpy(type, defaultType);
 291         typesTried |= TRIED_DEFAULT;
 292         if(uprv_strcmp(type, "search") == 0) {
 293             typesTried |= TRIED_SEARCH;
 294         }
 295         if(uprv_strcmp(type, "standard") == 0) {
 296             typesTried |= TRIED_STANDARD;
 297         }
 298         locale.setKeywordValue("collation", type, errorCode);
 299         return getCacheEntry(errorCode);
 300     } else {
 301         if(uprv_strcmp(type, defaultType) == 0) {
 302             typesTried |= TRIED_DEFAULT;
 303         }
 304         if(uprv_strcmp(type, "search") == 0) {
 305             typesTried |= TRIED_SEARCH;
 306         }
 307         if(uprv_strcmp(type, "standard") == 0) {
 308             typesTried |= TRIED_STANDARD;
 309         }
 310         return loadFromCollations(errorCode);
 311     }
 312 }
 313
 314 const CollationCacheEntry *
 315 CollationLoader::loadFromCollations(UErrorCode &errorCode) {
 316     if(U_FAILURE(errorCode)) { return NULL; }
 317     U_ASSERT(data == NULL);
 318     // Load the collations/type tailoring, with type fallback.
 319     LocalUResourceBundlePointer localData(
 320             ures_getByKeyWithFallback(collations, type, NULL, &errorCode));
 321     int32_t typeLength = static_cast<int32_t>(uprv_strlen(type));
 322     if(errorCode == U_MISSING_RESOURCE_ERROR) {
 323         errorCode = U_USING_DEFAULT_WARNING;
 324         typeFallback = TRUE;
 325         if((typesTried & TRIED_SEARCH) == 0 &&
 326                 typeLength > 6 && uprv_strncmp(type, "search", 6) == 0) {
 327             // fall back from something like "searchjl" to "search"
 328             typesTried |= TRIED_SEARCH;
 329             type[6] = 0;
 330         } else if((typesTried & TRIED_DEFAULT) == 0) {
 331             // fall back to the default type
 332             typesTried |= TRIED_DEFAULT;
 333             uprv_strcpy(type, defaultType);
 334         } else if((typesTried & TRIED_STANDARD) == 0) {
 335             // fall back to the "standard" type
 336             typesTried |= TRIED_STANDARD;
 337             uprv_strcpy(type, "standard");
 338         } else {
 339             // Return the root tailoring with the validLocale, without collation type.
 340             return makeCacheEntryFromRoot(validLocale, errorCode);
 341         }
 342         locale.setKeywordValue("collation", type, errorCode);
 343         return getCacheEntry(errorCode);
 344     }
 345     if(U_FAILURE(errorCode)) { return NULL; }
 346
 347     data = localData.orphan();
 348     const char *actualLocale = ures_getLocaleByType(data, ULOC_ACTUAL_LOCALE, &errorCode);
 349     if(U_FAILURE(errorCode)) { return NULL; }
 350     const char *vLocale = validLocale.getBaseName();
 351     UBool actualAndValidLocalesAreDifferent = Locale(actualLocale) != Locale(vLocale);
 352
 353     // Set the collation types on the informational locales,
 354     // except when they match the default types (for brevity and backwards compatibility).
 355     // For the valid locale, suppress the default type.
 356     if(uprv_strcmp(type, defaultType) != 0) {
 357         validLocale.setKeywordValue("collation", type, errorCode);
 358         if(U_FAILURE(errorCode)) { return NULL; }
 359     }
 360
 361     // Is this the same as the root collator? If so, then use that instead.
 362     if((*actualLocale == 0 || uprv_strcmp(actualLocale, "root") == 0) &&
 363             uprv_strcmp(type, "standard") == 0) {
 364         if(typeFallback) {
 365             errorCode = U_USING_DEFAULT_WARNING;
 366         }
 367         return makeCacheEntryFromRoot(validLocale, errorCode);
 368     }
 369
 370     locale = Locale(actualLocale);
 371     if(actualAndValidLocalesAreDifferent) {
 372         locale.setKeywordValue("collation", type, errorCode);
 373         const CollationCacheEntry *entry = getCacheEntry(errorCode);
 374         return makeCacheEntry(validLocale, entry, errorCode);
 375     } else {
 376         return loadFromData(errorCode);
 377     }
 378 }
 379
 380 const CollationCacheEntry *
 381 CollationLoader::loadFromData(UErrorCode &errorCode) {
 382     if(U_FAILURE(errorCode)) { return NULL; }
 383     LocalPointer<CollationTailoring> t(new CollationTailoring(rootEntry->tailoring->settings));
 384     if(t.isNull() || t->isBogus()) {
 385         errorCode = U_MEMORY_ALLOCATION_ERROR;
 386         return NULL;
 387     }
 388
 389     // deserialize
 390     LocalUResourceBundlePointer binary(ures_getByKey(data, "%%CollationBin", NULL, &errorCode));
 391     // Note: U_MISSING_RESOURCE_ERROR --> The old code built from rules if available
 392     // but that created undesirable dependencies.
 393     int32_t length;
 394     const uint8_t *inBytes = ures_getBinary(binary.getAlias(), &length, &errorCode);
 395     CollationDataReader::read(rootEntry->tailoring, inBytes, length, *t, errorCode);
 396     // Note: U_COLLATOR_VERSION_MISMATCH --> The old code built from rules if available
 397     // but that created undesirable dependencies.
 398     if(U_FAILURE(errorCode)) { return NULL; }
 399
 400     // Try to fetch the optional rules string.
 401     {
 402         UErrorCode internalErrorCode = U_ZERO_ERROR;
 403         int32_t len;
 404         const UChar *s = ures_getStringByKey(data, "Sequence", &len,
 405                                              &internalErrorCode);
 406         if(U_SUCCESS(internalErrorCode)) {
 407             t->rules.setTo(TRUE, s, len);
 408         }
 409     }
 410
 411     const char *actualLocale = locale.getBaseName();  // without type
 412     const char *vLocale = validLocale.getBaseName();
 413     UBool actualAndValidLocalesAreDifferent = Locale(actualLocale) != Locale(vLocale);
 414
 415     // For the actual locale, suppress the default type *according to the actual locale*.
 416     // For example, zh has default=pinyin and contains all of the Chinese tailorings.
 417     // zh_Hant has default=stroke but has no other data.
 418     // For the valid locale "zh_Hant" we need to suppress stroke.
 419     // For the actual locale "zh" we need to suppress pinyin instead.
 420     if(actualAndValidLocalesAreDifferent) {
 421         // Opening a bundle for the actual locale should always succeed.
 422         LocalUResourceBundlePointer actualBundle(
 423                 ures_open(U_ICUDATA_COLL, actualLocale, &errorCode));
 424         if(U_FAILURE(errorCode)) { return NULL; }
 425         UErrorCode internalErrorCode = U_ZERO_ERROR;
 426         LocalUResourceBundlePointer def(
 427                 ures_getByKeyWithFallback(actualBundle.getAlias(), "collations/default", NULL,
 428                                           &internalErrorCode));
 429         int32_t len;
 430         const UChar *s = ures_getString(def.getAlias(), &len, &internalErrorCode);
 431         if(U_SUCCESS(internalErrorCode) && len < UPRV_LENGTHOF(defaultType)) {
 432             u_UCharsToChars(s, defaultType, len + 1);
 433         } else {
 434             uprv_strcpy(defaultType, "standard");
 435         }
 436     }
 437     t->actualLocale = locale;
 438     if(uprv_strcmp(type, defaultType) != 0) {
 439         t->actualLocale.setKeywordValue("collation", type, errorCode);
 440     } else if(uprv_strcmp(locale.getName(), locale.getBaseName()) != 0) {
 441         // Remove the collation keyword if it was set.
 442         t->actualLocale.setKeywordValue("collation", NULL, errorCode);
 443     }
 444     if(U_FAILURE(errorCode)) { return NULL; }
 445
 446     if(typeFallback) {
 447         errorCode = U_USING_DEFAULT_WARNING;
 448     }
 449     t->bundle = bundle;
 450     bundle = NULL;
 451     const CollationCacheEntry *entry = new CollationCacheEntry(validLocale, t.getAlias());
 452     if(entry == NULL) {
 453         errorCode = U_MEMORY_ALLOCATION_ERROR;
 454         return nullptr;
 455     } else {
 456         t.orphan();
 457     }
 458     // Have to add that reference that we promise.
 459     entry->addRef();
 460     return entry;
 461 }
 462
 463 const CollationCacheEntry *
 464 CollationLoader::getCacheEntry(UErrorCode &errorCode) {
 465     LocaleCacheKey<CollationCacheEntry> key(locale);
 466     const CollationCacheEntry *entry = NULL;
 467     cache->get(key, this, entry, errorCode);
 468     return entry;
 469 }
 470
 471 const CollationCacheEntry *
 472 CollationLoader::makeCacheEntryFromRoot(
 473         const Locale &/*loc*/,
 474         UErrorCode &errorCode) const {
 475     if (U_FAILURE(errorCode)) {
 476         return NULL;
 477     }
 478     rootEntry->addRef();
 479     return makeCacheEntry(validLocale, rootEntry, errorCode);
 480 }
 481
 482 const CollationCacheEntry *
 483 CollationLoader::makeCacheEntry(
 484         const Locale &loc,
 485         const CollationCacheEntry *entryFromCache,
 486         UErrorCode &errorCode) {
 487     if(U_FAILURE(errorCode) || loc == entryFromCache->validLocale) {
 488         return entryFromCache;
 489     }
 490     CollationCacheEntry *entry = new CollationCacheEntry(loc, entryFromCache->tailoring);
 491     if(entry == NULL) {
 492         errorCode = U_MEMORY_ALLOCATION_ERROR;
 493         entryFromCache->removeRef();
 494         return NULL;
 495     }
 496     entry->addRef();
 497     entryFromCache->removeRef();
 498     return entry;
 499 }
 500
 501 U_NAMESPACE_END
 502
 503 U_NAMESPACE_USE
 504
 505 U_CAPI UCollator*
 506 ucol_open(const char *loc,
 507           UErrorCode *status)
 508 {
 509     UTRACE_ENTRY_OC(UTRACE_UCOL_OPEN);
 510     UTRACE_DATA1(UTRACE_INFO, "locale = \"%s\"", loc);
 511     UCollator *result = NULL;
 512
 513     Collator *coll = Collator::createInstance(loc, *status);
 514     if(U_SUCCESS(*status)) {
 515         result = coll->toUCollator();
 516     }
 517     UTRACE_EXIT_PTR_STATUS(result, *status);
 518     return result;
 519 }
 520
 521
 522 U_CAPI int32_t U_EXPORT2
 523 ucol_getDisplayName(    const    char        *objLoc,
 524                     const    char        *dispLoc,
 525                     UChar             *result,
 526                     int32_t         resultLength,
 527                     UErrorCode        *status)
 528 {
 529     if(U_FAILURE(*status)) return -1;
 530     UnicodeString dst;
 531     if(!(result==NULL && resultLength==0)) {
 532         // NULL destination for pure preflighting: empty dummy string
 533         // otherwise, alias the destination buffer
 534         dst.setTo(result, 0, resultLength);
 535     }
 536     Collator::getDisplayName(Locale(objLoc), Locale(dispLoc), dst);
 537     return dst.extract(result, resultLength, *status);
 538 }
 539
 540 U_CAPI const char* U_EXPORT2
 541 ucol_getAvailable(int32_t index)
 542 {
 543     int32_t count = 0;
 544     const Locale *loc = Collator::getAvailableLocales(count);
 545     if (loc != NULL && index < count) {
 546         return loc[index].getName();
 547     }
 548     return NULL;
 549 }
 550
 551 U_CAPI int32_t U_EXPORT2
 552 ucol_countAvailable()
 553 {
 554     int32_t count = 0;
 555     Collator::getAvailableLocales(count);
 556     return count;
 557 }
 558
 559 #if !UCONFIG_NO_SERVICE
 560 U_CAPI UEnumeration* U_EXPORT2
 561 ucol_openAvailableLocales(UErrorCode *status) {
 562     // This is a wrapper over Collator::getAvailableLocales()
 563     if (U_FAILURE(*status)) {
 564         return NULL;
 565     }
 566     StringEnumeration *s = icu::Collator::getAvailableLocales();
 567     if (s == NULL) {
 568         *status = U_MEMORY_ALLOCATION_ERROR;
 569         return NULL;
 570     }
 571     return uenum_openFromStringEnumeration(s, status);
 572 }
 573 #endif
 574
 575 // Note: KEYWORDS[0] != RESOURCE_NAME - alan
 576
 577 static const char RESOURCE_NAME[] = "collations";
 578
 579 static const char* const KEYWORDS[] = { "collation" };
 580
 581 #define KEYWORD_COUNT UPRV_LENGTHOF(KEYWORDS)
 582
 583 U_CAPI UEnumeration* U_EXPORT2
 584 ucol_getKeywords(UErrorCode *status) {
 585     UEnumeration *result = NULL;
 586     if (U_SUCCESS(*status)) {
 587         return uenum_openCharStringsEnumeration(KEYWORDS, KEYWORD_COUNT, status);
 588     }
 589     return result;
 590 }
 591
 592 U_CAPI UEnumeration* U_EXPORT2
 593 ucol_getKeywordValues(const char *keyword, UErrorCode *status) {
 594     if (U_FAILURE(*status)) {
 595         return NULL;
 596     }
 597     // hard-coded to accept exactly one collation keyword
 598     // modify if additional collation keyword is added later
 599     if (keyword==NULL || uprv_strcmp(keyword, KEYWORDS[0])!=0)
 600     {
 601         *status = U_ILLEGAL_ARGUMENT_ERROR;
 602         return NULL;
 603     }
 604     return ures_getKeywordValues(U_ICUDATA_COLL, RESOURCE_NAME, status);
 605 }
 606
 607 static const UEnumeration defaultKeywordValues = {
 608     NULL,
 609     NULL,
 610     ulist_close_keyword_values_iterator,
 611     ulist_count_keyword_values,
 612     uenum_unextDefault,
 613     ulist_next_keyword_value,
 614     ulist_reset_keyword_values_iterator
 615 };
 616
 617 namespace {
 618
 619 struct KeywordsSink : public ResourceSink {
 620 public:
 621     KeywordsSink(UErrorCode &errorCode) :
 622             values(ulist_createEmptyList(&errorCode)), hasDefault(FALSE) {}
 623     virtual ~KeywordsSink();
 624
 625     virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/,
 626                      UErrorCode &errorCode) {
 627         if (U_FAILURE(errorCode)) { return; }
 628         ResourceTable collations = value.getTable(errorCode);
 629         for (int32_t i = 0; collations.getKeyAndValue(i, key, value); ++i) {
 630             UResType type = value.getType();
 631             if (type == URES_STRING) {
 632                 if (!hasDefault && uprv_strcmp(key, "default") == 0) {
 633                     CharString defcoll;
 634                     defcoll.appendInvariantChars(value.getUnicodeString(errorCode), errorCode);
 635                     if (U_SUCCESS(errorCode) && !defcoll.isEmpty()) {
 636                         char *ownedDefault = uprv_strdup(defcoll.data());
 637                         if (ownedDefault == NULL) {
 638                             errorCode = U_MEMORY_ALLOCATION_ERROR;
 639                             return;
 640                         }
 641                         ulist_removeString(values, defcoll.data());
 642                         ulist_addItemBeginList(values, ownedDefault, TRUE, &errorCode);
 643                         hasDefault = TRUE;
 644                     }
 645                 }
 646             } else if (type == URES_TABLE && uprv_strncmp(key, "private-", 8) != 0) {
 647                 if (!ulist_containsString(values, key, (int32_t)uprv_strlen(key))) {
 648                     ulist_addItemEndList(values, key, FALSE, &errorCode);
 649                 }
 650             }
 651             if (U_FAILURE(errorCode)) { return; }
 652         }
 653     }
 654
 655     UList *values;
 656     UBool hasDefault;
 657 };
 658
 659 KeywordsSink::~KeywordsSink() {
 660     ulist_deleteList(values);
 661 }
 662
 663 }  // namespace
 664
 665 U_CAPI UEnumeration* U_EXPORT2
 666 ucol_getKeywordValuesForLocale(const char* /*key*/, const char* locale,
 667                                UBool /*commonlyUsed*/, UErrorCode* status) {
 668     // Note: The parameter commonlyUsed is not used.
 669     // The switch is in the method signature for consistency
 670     // with other locale services.
 671
 672     // Read available collation values from collation bundles.
 673     LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_COLL, locale, status));
 674     KeywordsSink sink(*status);
 675     ures_getAllItemsWithFallback(bundle.getAlias(), RESOURCE_NAME, sink, *status);
 676     if (U_FAILURE(*status)) { return NULL; }
 677
 678     UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration));
 679     if (en == NULL) {
 680         *status = U_MEMORY_ALLOCATION_ERROR;
 681         return NULL;
 682     }
 683     memcpy(en, &defaultKeywordValues, sizeof(UEnumeration));
 684     ulist_resetList(sink.values);  // Initialize the iterator.
 685     en->context = sink.values;
 686     sink.values = NULL;  // Avoid deletion in the sink destructor.
 687     return en;
 688 }
 689
 690 U_CAPI int32_t U_EXPORT2
 691 ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
 692                              const char* keyword, const char* locale,
 693                              UBool* isAvailable, UErrorCode* status)
 694 {
 695     // N.B.: Resource name is "collations" but keyword is "collation"
 696     return ures_getFunctionalEquivalent(result, resultCapacity, U_ICUDATA_COLL,
 697         "collations", keyword, locale,
 698         isAvailable, TRUE, status);
 699 }
 700
 701 #endif /* #if !UCONFIG_NO_COLLATION */