icuSources/i18n/coll.cpp

   1 /*
   2  ******************************************************************************
   3  * Copyright (C) 1996-2014, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ******************************************************************************
   6  */
   7
   8 /**
   9  * File coll.cpp
  10  *
  11  * Created by: Helena Shih
  12  *
  13  * Modification History:
  14  *
  15  *  Date        Name        Description
  16  *  2/5/97      aliu        Modified createDefault to load collation data from
  17  *                          binary files when possible.  Added related methods
  18  *                          createCollationFromFile, chopLocale, createPathName.
  19  *  2/11/97     aliu        Added methods addToCache, findInCache, which implement
  20  *                          a Collation cache.  Modified createDefault to look in
  21  *                          cache first, and also to store newly created Collation
  22  *                          objects in the cache.  Modified to not use gLocPath.
  23  *  2/12/97     aliu        Modified to create objects from RuleBasedCollator cache.
  24  *                          Moved cache out of Collation class.
  25  *  2/13/97     aliu        Moved several methods out of this class and into
  26  *                          RuleBasedCollator, with modifications.  Modified
  27  *                          createDefault() to call new RuleBasedCollator(Locale&)
  28  *                          constructor.  General clean up and documentation.
  29  *  2/20/97     helena      Added clone, operator==, operator!=, operator=, and copy
  30  *                          constructor.
  31  * 05/06/97     helena      Added memory allocation error detection.
  32  * 05/08/97     helena      Added createInstance().
  33  *  6/20/97     helena      Java class name change.
  34  * 04/23/99     stephen     Removed EDecompositionMode, merged with
  35  *                          Normalizer::EMode
  36  * 11/23/9      srl         Inlining of some critical functions
  37  * 01/29/01     synwee      Modified into a C++ wrapper calling C APIs (ucol.h)
  38  * 2012-2014    markus      Rewritten in C++ again.
  39  */
  40
  41 #include "utypeinfo.h"  // for 'typeid' to work
  42
  43 #include "unicode/utypes.h"
  44
  45 #if !UCONFIG_NO_COLLATION
  46
  47 #include "unicode/coll.h"
  48 #include "unicode/tblcoll.h"
  49 #include "collationdata.h"
  50 #include "collationroot.h"
  51 #include "collationtailoring.h"
  52 #include "ucol_imp.h"
  53 #include "cstring.h"
  54 #include "cmemory.h"
  55 #include "umutex.h"
  56 #include "servloc.h"
  57 #include "uassert.h"
  58 #include "ustrenum.h"
  59 #include "uresimp.h"
  60 #include "ucln_in.h"
  61
  62 static icu::Locale* availableLocaleList = NULL;
  63 static int32_t  availableLocaleListCount;
  64 static icu::ICULocaleService* gService = NULL;
  65 static icu::UInitOnce gServiceInitOnce = U_INITONCE_INITIALIZER;
  66 static icu::UInitOnce gAvailableLocaleListInitOnce;
  67
  68 /**
  69  * Release all static memory held by collator.
  70  */
  71 U_CDECL_BEGIN
  72 static UBool U_CALLCONV collator_cleanup(void) {
  73 #if !UCONFIG_NO_SERVICE
  74     if (gService) {
  75         delete gService;
  76         gService = NULL;
  77     }
  78     gServiceInitOnce.reset();
  79 #endif
  80     if (availableLocaleList) {
  81         delete []availableLocaleList;
  82         availableLocaleList = NULL;
  83     }
  84     availableLocaleListCount = 0;
  85     gAvailableLocaleListInitOnce.reset();
  86     return TRUE;
  87 }
  88
  89 U_CDECL_END
  90
  91 U_NAMESPACE_BEGIN
  92
  93 #if !UCONFIG_NO_SERVICE
  94
  95 // ------------------------------------------
  96 //
  97 // Registration
  98 //
  99
 100 //-------------------------------------------
 101
 102 CollatorFactory::~CollatorFactory() {}
 103
 104 //-------------------------------------------
 105
 106 UBool
 107 CollatorFactory::visible(void) const {
 108     return TRUE;
 109 }
 110
 111 //-------------------------------------------
 112
 113 UnicodeString&
 114 CollatorFactory::getDisplayName(const Locale& objectLocale,
 115                                 const Locale& displayLocale,
 116                                 UnicodeString& result)
 117 {
 118   return objectLocale.getDisplayName(displayLocale, result);
 119 }
 120
 121 // -------------------------------------
 122
 123 class ICUCollatorFactory : public ICUResourceBundleFactory {
 124  public:
 125     ICUCollatorFactory() : ICUResourceBundleFactory(UnicodeString(U_ICUDATA_COLL, -1, US_INV)) { }
 126     virtual ~ICUCollatorFactory();
 127  protected:
 128     virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
 129 };
 130
 131 ICUCollatorFactory::~ICUCollatorFactory() {}
 132
 133 UObject*
 134 ICUCollatorFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const {
 135     if (handlesKey(key, status)) {
 136         const LocaleKey& lkey = (const LocaleKey&)key;
 137         Locale loc;
 138         // make sure the requested locale is correct
 139         // default LocaleFactory uses currentLocale since that's the one vetted by handlesKey
 140         // but for ICU rb resources we use the actual one since it will fallback again
 141         lkey.canonicalLocale(loc);
 142
 143         return Collator::makeInstance(loc, status);
 144     }
 145     return NULL;
 146 }
 147
 148 // -------------------------------------
 149
 150 class ICUCollatorService : public ICULocaleService {
 151 public:
 152     ICUCollatorService()
 153         : ICULocaleService(UNICODE_STRING_SIMPLE("Collator"))
 154     {
 155         UErrorCode status = U_ZERO_ERROR;
 156         registerFactory(new ICUCollatorFactory(), status);
 157     }
 158
 159     virtual ~ICUCollatorService();
 160
 161     virtual UObject* cloneInstance(UObject* instance) const {
 162         return ((Collator*)instance)->clone();
 163     }
 164
 165     virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* actualID, UErrorCode& status) const {
 166         LocaleKey& lkey = (LocaleKey&)key;
 167         if (actualID) {
 168             // Ugly Hack Alert! We return an empty actualID to signal
 169             // to callers that this is a default object, not a "real"
 170             // service-created object. (TODO remove in 3.0) [aliu]
 171             actualID->truncate(0);
 172         }
 173         Locale loc("");
 174         lkey.canonicalLocale(loc);
 175         return Collator::makeInstance(loc, status);
 176     }
 177
 178     virtual UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const {
 179         UnicodeString ar;
 180         if (actualReturn == NULL) {
 181             actualReturn = &ar;
 182         }
 183         return (Collator*)ICULocaleService::getKey(key, actualReturn, status);
 184     }
 185
 186     virtual UBool isDefault() const {
 187         return countFactories() == 1;
 188     }
 189 };
 190
 191 ICUCollatorService::~ICUCollatorService() {}
 192
 193 // -------------------------------------
 194
 195 static void U_CALLCONV initService() {
 196     gService = new ICUCollatorService();
 197     ucln_i18n_registerCleanup(UCLN_I18N_COLLATOR, collator_cleanup);
 198 }
 199
 200
 201 static ICULocaleService*
 202 getService(void)
 203 {
 204     umtx_initOnce(gServiceInitOnce, &initService);
 205     return gService;
 206 }
 207
 208 // -------------------------------------
 209
 210 static inline UBool
 211 hasService(void)
 212 {
 213     UBool retVal = !gServiceInitOnce.isReset() && (getService() != NULL);
 214     return retVal;
 215 }
 216
 217 #endif /* UCONFIG_NO_SERVICE */
 218
 219 static void U_CALLCONV
 220 initAvailableLocaleList(UErrorCode &status) {
 221     U_ASSERT(availableLocaleListCount == 0);
 222     U_ASSERT(availableLocaleList == NULL);
 223     // for now, there is a hardcoded list, so just walk through that list and set it up.
 224     UResourceBundle *index = NULL;
 225     UResourceBundle installed;
 226     int32_t i = 0;
 227
 228     ures_initStackObject(&installed);
 229     index = ures_openDirect(U_ICUDATA_COLL, "res_index", &status);
 230     ures_getByKey(index, "InstalledLocales", &installed, &status);
 231
 232     if(U_SUCCESS(status)) {
 233         availableLocaleListCount = ures_getSize(&installed);
 234         availableLocaleList = new Locale[availableLocaleListCount];
 235
 236         if (availableLocaleList != NULL) {
 237             ures_resetIterator(&installed);
 238             while(ures_hasNext(&installed)) {
 239                 const char *tempKey = NULL;
 240                 ures_getNextString(&installed, NULL, &tempKey, &status);
 241                 availableLocaleList[i++] = Locale(tempKey);
 242             }
 243         }
 244         U_ASSERT(availableLocaleListCount == i);
 245         ures_close(&installed);
 246     }
 247     ures_close(index);
 248     ucln_i18n_registerCleanup(UCLN_I18N_COLLATOR, collator_cleanup);
 249 }
 250
 251 static UBool isAvailableLocaleListInitialized(UErrorCode &status) {
 252     umtx_initOnce(gAvailableLocaleListInitOnce, &initAvailableLocaleList, status);
 253     return U_SUCCESS(status);
 254 }
 255
 256
 257 // Collator public methods -----------------------------------------------
 258
 259 namespace {
 260
 261 static const struct {
 262     const char *name;
 263     UColAttribute attr;
 264 } collAttributes[] = {
 265     { "colStrength", UCOL_STRENGTH },
 266     { "colBackwards", UCOL_FRENCH_COLLATION },
 267     { "colCaseLevel", UCOL_CASE_LEVEL },
 268     { "colCaseFirst", UCOL_CASE_FIRST },
 269     { "colAlternate", UCOL_ALTERNATE_HANDLING },
 270     { "colNormalization", UCOL_NORMALIZATION_MODE },
 271     { "colNumeric", UCOL_NUMERIC_COLLATION }
 272 };
 273
 274 static const struct {
 275     const char *name;
 276     UColAttributeValue value;
 277 } collAttributeValues[] = {
 278     { "primary", UCOL_PRIMARY },
 279     { "secondary", UCOL_SECONDARY },
 280     { "tertiary", UCOL_TERTIARY },
 281     { "quaternary", UCOL_QUATERNARY },
 282     // Note: Not supporting typo "quarternary" because it was never supported in locale IDs.
 283     { "identical", UCOL_IDENTICAL },
 284     { "no", UCOL_OFF },
 285     { "yes", UCOL_ON },
 286     { "shifted", UCOL_SHIFTED },
 287     { "non-ignorable", UCOL_NON_IGNORABLE },
 288     { "lower", UCOL_LOWER_FIRST },
 289     { "upper", UCOL_UPPER_FIRST }
 290 };
 291
 292 static const char *collReorderCodes[UCOL_REORDER_CODE_LIMIT - UCOL_REORDER_CODE_FIRST] = {
 293     "space", "punct", "symbol", "currency", "digit"
 294 };
 295
 296 int32_t getReorderCode(const char *s) {
 297     for (int32_t i = 0; i < UPRV_LENGTHOF(collReorderCodes); ++i) {
 298         if (uprv_stricmp(s, collReorderCodes[i]) == 0) {
 299             return UCOL_REORDER_CODE_FIRST + i;
 300         }
 301     }
 302     // Not supporting "others" = UCOL_REORDER_CODE_OTHERS
 303     // as a synonym for Zzzz = USCRIPT_UNKNOWN for now:
 304     // Avoid introducing synonyms/aliases.
 305     return -1;
 306 }
 307
 308 /**
 309  * Sets collation attributes according to locale keywords. See
 310  * http://www.unicode.org/reports/tr35/tr35-collation.html#Collation_Settings
 311  *
 312  * Using "alias" keywords and values where defined:
 313  * http://www.unicode.org/reports/tr35/tr35.html#Old_Locale_Extension_Syntax
 314  * http://unicode.org/repos/cldr/trunk/common/bcp47/collation.xml
 315  */
 316 void setAttributesFromKeywords(const Locale &loc, Collator &coll, UErrorCode &errorCode) {
 317     if (U_FAILURE(errorCode)) {
 318         return;
 319     }
 320     if (uprv_strcmp(loc.getName(), loc.getBaseName()) == 0) {
 321         // No keywords.
 322         return;
 323     }
 324     char value[1024];  // The reordering value could be long.
 325     // Check for collation keywords that were already deprecated
 326     // before any were supported in createInstance() (except for "collation").
 327     int32_t length = loc.getKeywordValue("colHiraganaQuaternary", value, UPRV_LENGTHOF(value), errorCode);
 328     if (U_FAILURE(errorCode)) {
 329         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 330         return;
 331     }
 332     if (length != 0) {
 333         errorCode = U_UNSUPPORTED_ERROR;
 334         return;
 335     }
 336     length = loc.getKeywordValue("variableTop", value, UPRV_LENGTHOF(value), errorCode);
 337     if (U_FAILURE(errorCode)) {
 338         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 339         return;
 340     }
 341     if (length != 0) {
 342         errorCode = U_UNSUPPORTED_ERROR;
 343         return;
 344     }
 345     // Parse known collation keywords, ignore others.
 346     if (errorCode == U_STRING_NOT_TERMINATED_WARNING) {
 347         errorCode = U_ZERO_ERROR;
 348     }
 349     for (int32_t i = 0; i < UPRV_LENGTHOF(collAttributes); ++i) {
 350         length = loc.getKeywordValue(collAttributes[i].name, value, UPRV_LENGTHOF(value), errorCode);
 351         if (U_FAILURE(errorCode) || errorCode == U_STRING_NOT_TERMINATED_WARNING) {
 352             errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 353             return;
 354         }
 355         if (length == 0) { continue; }
 356         for (int32_t j = 0;; ++j) {
 357             if (j == UPRV_LENGTHOF(collAttributeValues)) {
 358                 errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 359                 return;
 360             }
 361             if (uprv_stricmp(value, collAttributeValues[j].name) == 0) {
 362                 coll.setAttribute(collAttributes[i].attr, collAttributeValues[j].value, errorCode);
 363                 break;
 364             }
 365         }
 366     }
 367     length = loc.getKeywordValue("colReorder", value, UPRV_LENGTHOF(value), errorCode);
 368     if (U_FAILURE(errorCode) || errorCode == U_STRING_NOT_TERMINATED_WARNING) {
 369         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 370         return;
 371     }
 372     if (length != 0) {
 373         int32_t codes[USCRIPT_CODE_LIMIT + UCOL_REORDER_CODE_LIMIT - UCOL_REORDER_CODE_FIRST];
 374         int32_t codesLength = 0;
 375         char *scriptName = value;
 376         for (;;) {
 377             if (codesLength == UPRV_LENGTHOF(codes)) {
 378                 errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 379                 return;
 380             }
 381             char *limit = scriptName;
 382             char c;
 383             while ((c = *limit) != 0 && c != '-') { ++limit; }
 384             *limit = 0;
 385             int32_t code;
 386             if ((limit - scriptName) == 4) {
 387                 // Strict parsing, accept only 4-letter script codes, not long names.
 388                 code = u_getPropertyValueEnum(UCHAR_SCRIPT, scriptName);
 389             } else {
 390                 code = getReorderCode(scriptName);
 391             }
 392             if (code < 0) {
 393                 errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 394                 return;
 395             }
 396             codes[codesLength++] = code;
 397             if (c == 0) { break; }
 398             scriptName = limit + 1;
 399         }
 400         coll.setReorderCodes(codes, codesLength, errorCode);
 401     }
 402     length = loc.getKeywordValue("kv", value, UPRV_LENGTHOF(value), errorCode);
 403     if (U_FAILURE(errorCode) || errorCode == U_STRING_NOT_TERMINATED_WARNING) {
 404         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 405         return;
 406     }
 407     if (length != 0) {
 408         int32_t code = getReorderCode(value);
 409         if (code < 0) {
 410             errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 411             return;
 412         }
 413         coll.setMaxVariable((UColReorderCode)code, errorCode);
 414     }
 415     if (U_FAILURE(errorCode)) {
 416         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 417     }
 418 }
 419
 420 }  // namespace
 421
 422 Collator* U_EXPORT2 Collator::createInstance(UErrorCode& success)
 423 {
 424     return createInstance(Locale::getDefault(), success);
 425 }
 426
 427 Collator* U_EXPORT2 Collator::createInstance(const Locale& desiredLocale,
 428                                    UErrorCode& status)
 429 {
 430     if (U_FAILURE(status))
 431         return 0;
 432     if (desiredLocale.isBogus()) {
 433         // Locale constructed from malformed locale ID or language tag.
 434         status = U_ILLEGAL_ARGUMENT_ERROR;
 435         return NULL;
 436     }
 437
 438     Collator* coll;
 439 #if !UCONFIG_NO_SERVICE
 440     if (hasService()) {
 441         Locale actualLoc;
 442         coll = (Collator*)gService->get(desiredLocale, &actualLoc, status);
 443     } else
 444 #endif
 445     {
 446         coll = makeInstance(desiredLocale, status);
 447     }
 448     setAttributesFromKeywords(desiredLocale, *coll, status);
 449     if (U_FAILURE(status)) {
 450         delete coll;
 451         return NULL;
 452     }
 453     return coll;
 454 }
 455
 456
 457 Collator* Collator::makeInstance(const Locale&  desiredLocale, UErrorCode& status) {
 458     const CollationCacheEntry *entry = CollationLoader::loadTailoring(desiredLocale, status);
 459     if (U_SUCCESS(status)) {
 460         Collator *result = new RuleBasedCollator(entry);
 461         if (result != NULL) {
 462             // Both the unified cache's get() and the RBC constructor
 463             // did addRef(). Undo one of them.
 464             entry->removeRef();
 465             return result;
 466         }
 467         status = U_MEMORY_ALLOCATION_ERROR;
 468     }
 469     if (entry != NULL) {
 470         // Undo the addRef() from the cache.get().
 471         entry->removeRef();
 472     }
 473     return NULL;
 474 }
 475
 476 Collator *
 477 Collator::safeClone() const {
 478     return clone();
 479 }
 480
 481 // implement deprecated, previously abstract method
 482 Collator::EComparisonResult Collator::compare(const UnicodeString& source,
 483                                     const UnicodeString& target) const
 484 {
 485     UErrorCode ec = U_ZERO_ERROR;
 486     return (EComparisonResult)compare(source, target, ec);
 487 }
 488
 489 // implement deprecated, previously abstract method
 490 Collator::EComparisonResult Collator::compare(const UnicodeString& source,
 491                                     const UnicodeString& target,
 492                                     int32_t length) const
 493 {
 494     UErrorCode ec = U_ZERO_ERROR;
 495     return (EComparisonResult)compare(source, target, length, ec);
 496 }
 497
 498 // implement deprecated, previously abstract method
 499 Collator::EComparisonResult Collator::compare(const UChar* source, int32_t sourceLength,
 500                                     const UChar* target, int32_t targetLength)
 501                                     const
 502 {
 503     UErrorCode ec = U_ZERO_ERROR;
 504     return (EComparisonResult)compare(source, sourceLength, target, targetLength, ec);
 505 }
 506
 507 UCollationResult Collator::compare(UCharIterator &/*sIter*/,
 508                                    UCharIterator &/*tIter*/,
 509                                    UErrorCode &status) const {
 510     if(U_SUCCESS(status)) {
 511         // Not implemented in the base class.
 512         status = U_UNSUPPORTED_ERROR;
 513     }
 514     return UCOL_EQUAL;
 515 }
 516
 517 UCollationResult Collator::compareUTF8(const StringPiece &source,
 518                                        const StringPiece &target,
 519                                        UErrorCode &status) const {
 520     if(U_FAILURE(status)) {
 521         return UCOL_EQUAL;
 522     }
 523     UCharIterator sIter, tIter;
 524     uiter_setUTF8(&sIter, source.data(), source.length());
 525     uiter_setUTF8(&tIter, target.data(), target.length());
 526     return compare(sIter, tIter, status);
 527 }
 528
 529 UBool Collator::equals(const UnicodeString& source,
 530                        const UnicodeString& target) const
 531 {
 532     UErrorCode ec = U_ZERO_ERROR;
 533     return (compare(source, target, ec) == UCOL_EQUAL);
 534 }
 535
 536 UBool Collator::greaterOrEqual(const UnicodeString& source,
 537                                const UnicodeString& target) const
 538 {
 539     UErrorCode ec = U_ZERO_ERROR;
 540     return (compare(source, target, ec) != UCOL_LESS);
 541 }
 542
 543 UBool Collator::greater(const UnicodeString& source,
 544                         const UnicodeString& target) const
 545 {
 546     UErrorCode ec = U_ZERO_ERROR;
 547     return (compare(source, target, ec) == UCOL_GREATER);
 548 }
 549
 550 // this API  ignores registered collators, since it returns an
 551 // array of indefinite lifetime
 552 const Locale* U_EXPORT2 Collator::getAvailableLocales(int32_t& count)
 553 {
 554     UErrorCode status = U_ZERO_ERROR;
 555     Locale *result = NULL;
 556     count = 0;
 557     if (isAvailableLocaleListInitialized(status))
 558     {
 559         result = availableLocaleList;
 560         count = availableLocaleListCount;
 561     }
 562     return result;
 563 }
 564
 565 UnicodeString& U_EXPORT2 Collator::getDisplayName(const Locale& objectLocale,
 566                                         const Locale& displayLocale,
 567                                         UnicodeString& name)
 568 {
 569 #if !UCONFIG_NO_SERVICE
 570     if (hasService()) {
 571         UnicodeString locNameStr;
 572         LocaleUtility::initNameFromLocale(objectLocale, locNameStr);
 573         return gService->getDisplayName(locNameStr, name, displayLocale);
 574     }
 575 #endif
 576     return objectLocale.getDisplayName(displayLocale, name);
 577 }
 578
 579 UnicodeString& U_EXPORT2 Collator::getDisplayName(const Locale& objectLocale,
 580                                         UnicodeString& name)
 581 {
 582     return getDisplayName(objectLocale, Locale::getDefault(), name);
 583 }
 584
 585 /* This is useless information */
 586 /*void Collator::getVersion(UVersionInfo versionInfo) const
 587 {
 588   if (versionInfo!=NULL)
 589     uprv_memcpy(versionInfo, fVersion, U_MAX_VERSION_LENGTH);
 590 }
 591 */
 592
 593 // UCollator protected constructor destructor ----------------------------
 594
 595 /**
 596 * Default constructor.
 597 * Constructor is different from the old default Collator constructor.
 598 * The task for determing the default collation strength and normalization mode
 599 * is left to the child class.
 600 */
 601 Collator::Collator()
 602 : UObject()
 603 {
 604 }
 605
 606 /**
 607 * Constructor.
 608 * Empty constructor, does not handle the arguments.
 609 * This constructor is done for backward compatibility with 1.7 and 1.8.
 610 * The task for handling the argument collation strength and normalization
 611 * mode is left to the child class.
 612 * @param collationStrength collation strength
 613 * @param decompositionMode
 614 * @deprecated 2.4 use the default constructor instead
 615 */
 616 Collator::Collator(UCollationStrength, UNormalizationMode )
 617 : UObject()
 618 {
 619 }
 620
 621 Collator::~Collator()
 622 {
 623 }
 624
 625 Collator::Collator(const Collator &other)
 626     : UObject(other)
 627 {
 628 }
 629
 630 UBool Collator::operator==(const Collator& other) const
 631 {
 632     // Subclasses: Call this method and then add more specific checks.
 633     return typeid(*this) == typeid(other);
 634 }
 635
 636 UBool Collator::operator!=(const Collator& other) const
 637 {
 638     return (UBool)!(*this == other);
 639 }
 640
 641 int32_t U_EXPORT2 Collator::getBound(const uint8_t       *source,
 642                            int32_t             sourceLength,
 643                            UColBoundMode       boundType,
 644                            uint32_t            noOfLevels,
 645                            uint8_t             *result,
 646                            int32_t             resultLength,
 647                            UErrorCode          &status)
 648 {
 649     return ucol_getBound(source, sourceLength, boundType, noOfLevels, result, resultLength, &status);
 650 }
 651
 652 void
 653 Collator::setLocales(const Locale& /* requestedLocale */, const Locale& /* validLocale */, const Locale& /*actualLocale*/) {
 654 }
 655
 656 UnicodeSet *Collator::getTailoredSet(UErrorCode &status) const
 657 {
 658     if(U_FAILURE(status)) {
 659         return NULL;
 660     }
 661     // everything can be changed
 662     return new UnicodeSet(0, 0x10FFFF);
 663 }
 664
 665 // -------------------------------------
 666
 667 #if !UCONFIG_NO_SERVICE
 668 URegistryKey U_EXPORT2
 669 Collator::registerInstance(Collator* toAdopt, const Locale& locale, UErrorCode& status)
 670 {
 671     if (U_SUCCESS(status)) {
 672         // Set the collator locales while registering so that createInstance()
 673         // need not guess whether the collator's locales are already set properly
 674         // (as they are by the data loader).
 675         toAdopt->setLocales(locale, locale, locale);
 676         return getService()->registerInstance(toAdopt, locale, status);
 677     }
 678     return NULL;
 679 }
 680
 681 // -------------------------------------
 682
 683 class CFactory : public LocaleKeyFactory {
 684 private:
 685     CollatorFactory* _delegate;
 686     Hashtable* _ids;
 687
 688 public:
 689     CFactory(CollatorFactory* delegate, UErrorCode& status)
 690         : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
 691         , _delegate(delegate)
 692         , _ids(NULL)
 693     {
 694         if (U_SUCCESS(status)) {
 695             int32_t count = 0;
 696             _ids = new Hashtable(status);
 697             if (_ids) {
 698                 const UnicodeString * idlist = _delegate->getSupportedIDs(count, status);
 699                 for (int i = 0; i < count; ++i) {
 700                     _ids->put(idlist[i], (void*)this, status);
 701                     if (U_FAILURE(status)) {
 702                         delete _ids;
 703                         _ids = NULL;
 704                         return;
 705                     }
 706                 }
 707             } else {
 708                 status = U_MEMORY_ALLOCATION_ERROR;
 709             }
 710         }
 711     }
 712
 713     virtual ~CFactory();
 714
 715     virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
 716
 717 protected:
 718     virtual const Hashtable* getSupportedIDs(UErrorCode& status) const
 719     {
 720         if (U_SUCCESS(status)) {
 721             return _ids;
 722         }
 723         return NULL;
 724     }
 725
 726     virtual UnicodeString&
 727         getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
 728 };
 729
 730 CFactory::~CFactory()
 731 {
 732     delete _delegate;
 733     delete _ids;
 734 }
 735
 736 UObject*
 737 CFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const
 738 {
 739     if (handlesKey(key, status)) {
 740         const LocaleKey& lkey = (const LocaleKey&)key;
 741         Locale validLoc;
 742         lkey.currentLocale(validLoc);
 743         return _delegate->createCollator(validLoc);
 744     }
 745     return NULL;
 746 }
 747
 748 UnicodeString&
 749 CFactory::getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const
 750 {
 751     if ((_coverage & 0x1) == 0) {
 752         UErrorCode status = U_ZERO_ERROR;
 753         const Hashtable* ids = getSupportedIDs(status);
 754         if (ids && (ids->get(id) != NULL)) {
 755             Locale loc;
 756             LocaleUtility::initLocaleFromName(id, loc);
 757             return _delegate->getDisplayName(loc, locale, result);
 758         }
 759     }
 760     result.setToBogus();
 761     return result;
 762 }
 763
 764 URegistryKey U_EXPORT2
 765 Collator::registerFactory(CollatorFactory* toAdopt, UErrorCode& status)
 766 {
 767     if (U_SUCCESS(status)) {
 768         CFactory* f = new CFactory(toAdopt, status);
 769         if (f) {
 770             return getService()->registerFactory(f, status);
 771         }
 772         status = U_MEMORY_ALLOCATION_ERROR;
 773     }
 774     return NULL;
 775 }
 776
 777 // -------------------------------------
 778
 779 UBool U_EXPORT2
 780 Collator::unregister(URegistryKey key, UErrorCode& status)
 781 {
 782     if (U_SUCCESS(status)) {
 783         if (hasService()) {
 784             return gService->unregister(key, status);
 785         }
 786         status = U_ILLEGAL_ARGUMENT_ERROR;
 787     }
 788     return FALSE;
 789 }
 790 #endif /* UCONFIG_NO_SERVICE */
 791
 792 class CollationLocaleListEnumeration : public StringEnumeration {
 793 private:
 794     int32_t index;
 795 public:
 796     static UClassID U_EXPORT2 getStaticClassID(void);
 797     virtual UClassID getDynamicClassID(void) const;
 798 public:
 799     CollationLocaleListEnumeration()
 800         : index(0)
 801     {
 802         // The global variables should already be initialized.
 803         //isAvailableLocaleListInitialized(status);
 804     }
 805
 806     virtual ~CollationLocaleListEnumeration();
 807
 808     virtual StringEnumeration * clone() const
 809     {
 810         CollationLocaleListEnumeration *result = new CollationLocaleListEnumeration();
 811         if (result) {
 812             result->index = index;
 813         }
 814         return result;
 815     }
 816
 817     virtual int32_t count(UErrorCode &/*status*/) const {
 818         return availableLocaleListCount;
 819     }
 820
 821     virtual const char* next(int32_t* resultLength, UErrorCode& /*status*/) {
 822         const char* result;
 823         if(index < availableLocaleListCount) {
 824             result = availableLocaleList[index++].getName();
 825             if(resultLength != NULL) {
 826                 *resultLength = (int32_t)uprv_strlen(result);
 827             }
 828         } else {
 829             if(resultLength != NULL) {
 830                 *resultLength = 0;
 831             }
 832             result = NULL;
 833         }
 834         return result;
 835     }
 836
 837     virtual const UnicodeString* snext(UErrorCode& status) {
 838         int32_t resultLength = 0;
 839         const char *s = next(&resultLength, status);
 840         return setChars(s, resultLength, status);
 841     }
 842
 843     virtual void reset(UErrorCode& /*status*/) {
 844         index = 0;
 845     }
 846 };
 847
 848 CollationLocaleListEnumeration::~CollationLocaleListEnumeration() {}
 849
 850 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationLocaleListEnumeration)
 851
 852
 853 // -------------------------------------
 854
 855 StringEnumeration* U_EXPORT2
 856 Collator::getAvailableLocales(void)
 857 {
 858 #if !UCONFIG_NO_SERVICE
 859     if (hasService()) {
 860         return getService()->getAvailableLocales();
 861     }
 862 #endif /* UCONFIG_NO_SERVICE */
 863     UErrorCode status = U_ZERO_ERROR;
 864     if (isAvailableLocaleListInitialized(status)) {
 865         return new CollationLocaleListEnumeration();
 866     }
 867     return NULL;
 868 }
 869
 870 StringEnumeration* U_EXPORT2
 871 Collator::getKeywords(UErrorCode& status) {
 872     return UStringEnumeration::fromUEnumeration(
 873             ucol_getKeywords(&status), status);
 874 }
 875
 876 StringEnumeration* U_EXPORT2
 877 Collator::getKeywordValues(const char *keyword, UErrorCode& status) {
 878     return UStringEnumeration::fromUEnumeration(
 879             ucol_getKeywordValues(keyword, &status), status);
 880 }
 881
 882 StringEnumeration* U_EXPORT2
 883 Collator::getKeywordValuesForLocale(const char* key, const Locale& locale,
 884                                     UBool commonlyUsed, UErrorCode& status) {
 885     return UStringEnumeration::fromUEnumeration(
 886             ucol_getKeywordValuesForLocale(
 887                     key, locale.getName(), commonlyUsed, &status),
 888             status);
 889 }
 890
 891 Locale U_EXPORT2
 892 Collator::getFunctionalEquivalent(const char* keyword, const Locale& locale,
 893                                   UBool& isAvailable, UErrorCode& status) {
 894     // This is a wrapper over ucol_getFunctionalEquivalent
 895     char loc[ULOC_FULLNAME_CAPACITY];
 896     /*int32_t len =*/ ucol_getFunctionalEquivalent(loc, sizeof(loc),
 897                     keyword, locale.getName(), &isAvailable, &status);
 898     if (U_FAILURE(status)) {
 899         *loc = 0; // root
 900     }
 901     return Locale::createFromName(loc);
 902 }
 903
 904 Collator::ECollationStrength
 905 Collator::getStrength(void) const {
 906     UErrorCode intStatus = U_ZERO_ERROR;
 907     return (ECollationStrength)getAttribute(UCOL_STRENGTH, intStatus);
 908 }
 909
 910 void
 911 Collator::setStrength(ECollationStrength newStrength) {
 912     UErrorCode intStatus = U_ZERO_ERROR;
 913     setAttribute(UCOL_STRENGTH, (UColAttributeValue)newStrength, intStatus);
 914 }
 915
 916 Collator &
 917 Collator::setMaxVariable(UColReorderCode /*group*/, UErrorCode &errorCode) {
 918     if (U_SUCCESS(errorCode)) {
 919         errorCode = U_UNSUPPORTED_ERROR;
 920     }
 921     return *this;
 922 }
 923
 924 UColReorderCode
 925 Collator::getMaxVariable() const {
 926     return UCOL_REORDER_CODE_PUNCTUATION;
 927 }
 928
 929 int32_t
 930 Collator::getReorderCodes(int32_t* /* dest*/,
 931                           int32_t /* destCapacity*/,
 932                           UErrorCode& status) const
 933 {
 934     if (U_SUCCESS(status)) {
 935         status = U_UNSUPPORTED_ERROR;
 936     }
 937     return 0;
 938 }
 939
 940 void
 941 Collator::setReorderCodes(const int32_t* /* reorderCodes */,
 942                           int32_t /* reorderCodesLength */,
 943                           UErrorCode& status)
 944 {
 945     if (U_SUCCESS(status)) {
 946         status = U_UNSUPPORTED_ERROR;
 947     }
 948 }
 949
 950 int32_t
 951 Collator::getEquivalentReorderCodes(int32_t reorderCode,
 952                                     int32_t *dest, int32_t capacity,
 953                                     UErrorCode &errorCode) {
 954     if(U_FAILURE(errorCode)) { return 0; }
 955     if(capacity < 0 || (dest == NULL && capacity > 0)) {
 956         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 957         return 0;
 958     }
 959     const CollationData *baseData = CollationRoot::getData(errorCode);
 960     if(U_FAILURE(errorCode)) { return 0; }
 961     return baseData->getEquivalentScripts(reorderCode, dest, capacity, errorCode);
 962 }
 963
 964 int32_t
 965 Collator::internalGetShortDefinitionString(const char * /*locale*/,
 966                                                              char * /*buffer*/,
 967                                                              int32_t /*capacity*/,
 968                                                              UErrorCode &status) const {
 969   if(U_SUCCESS(status)) {
 970     status = U_UNSUPPORTED_ERROR; /* Shouldn't happen, internal function */
 971   }
 972   return 0;
 973 }
 974
 975 UCollationResult
 976 Collator::internalCompareUTF8(const char *left, int32_t leftLength,
 977                               const char *right, int32_t rightLength,
 978                               UErrorCode &errorCode) const {
 979     if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
 980     if((left == NULL && leftLength != 0) || (right == NULL && rightLength != 0)) {
 981         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
 982         return UCOL_EQUAL;
 983     }
 984     return compareUTF8(
 985             StringPiece(left, (leftLength < 0) ? uprv_strlen(left) : leftLength),
 986             StringPiece(right, (rightLength < 0) ? uprv_strlen(right) : rightLength),
 987             errorCode);
 988 }
 989
 990 int32_t
 991 Collator::internalNextSortKeyPart(UCharIterator * /*iter*/, uint32_t /*state*/[2],
 992                                   uint8_t * /*dest*/, int32_t /*count*/, UErrorCode &errorCode) const {
 993     if (U_SUCCESS(errorCode)) {
 994         errorCode = U_UNSUPPORTED_ERROR;
 995     }
 996     return 0;
 997 }
 998
 999 // UCollator private data members ----------------------------------------
1000
1001 /* This is useless information */
1002 /*const UVersionInfo Collator::fVersion = {1, 1, 0, 0};*/
1003
1004 // -------------------------------------
1005
1006 U_NAMESPACE_END
1007
1008 #endif /* #if !UCONFIG_NO_COLLATION */
1009
1010 /* eof */