icuSources/i18n/coll.cpp

   1 /*
   2  ******************************************************************************
   3  * Copyright (C) 1996-2010, 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  */
  39
  40 #include "unicode/utypes.h"
  41
  42 #if !UCONFIG_NO_COLLATION
  43
  44 #include "unicode/coll.h"
  45 #include "unicode/tblcoll.h"
  46 #include "ucol_imp.h"
  47 #include "cstring.h"
  48 #include "cmemory.h"
  49 #include "umutex.h"
  50 #include "servloc.h"
  51 #include "ustrenum.h"
  52 #include "uresimp.h"
  53 #include "ucln_in.h"
  54
  55 static U_NAMESPACE_QUALIFIER Locale* availableLocaleList = NULL;
  56 static int32_t  availableLocaleListCount;
  57 static U_NAMESPACE_QUALIFIER ICULocaleService* gService = NULL;
  58
  59 /**
  60  * Release all static memory held by collator.
  61  */
  62 U_CDECL_BEGIN
  63 static UBool U_CALLCONV collator_cleanup(void) {
  64 #if !UCONFIG_NO_SERVICE
  65     if (gService) {
  66         delete gService;
  67         gService = NULL;
  68     }
  69 #endif
  70     if (availableLocaleList) {
  71         delete []availableLocaleList;
  72         availableLocaleList = NULL;
  73     }
  74     availableLocaleListCount = 0;
  75
  76     return TRUE;
  77 }
  78
  79 U_CDECL_END
  80
  81 U_NAMESPACE_BEGIN
  82
  83 #if !UCONFIG_NO_SERVICE
  84
  85 // ------------------------------------------
  86 //
  87 // Registration
  88 //
  89
  90 //-------------------------------------------
  91
  92 CollatorFactory::~CollatorFactory() {}
  93
  94 //-------------------------------------------
  95
  96 UBool
  97 CollatorFactory::visible(void) const {
  98     return TRUE;
  99 }
 100
 101 //-------------------------------------------
 102
 103 UnicodeString&
 104 CollatorFactory::getDisplayName(const Locale& objectLocale,
 105                                 const Locale& displayLocale,
 106                                 UnicodeString& result)
 107 {
 108   return objectLocale.getDisplayName(displayLocale, result);
 109 }
 110
 111 // -------------------------------------
 112
 113 class ICUCollatorFactory : public ICUResourceBundleFactory {
 114  public:
 115     ICUCollatorFactory():  ICUResourceBundleFactory(UnicodeString(U_ICUDATA_COLL, -1, US_INV)) { }
 116  protected:
 117     virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
 118 };
 119
 120 UObject*
 121 ICUCollatorFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const {
 122     if (handlesKey(key, status)) {
 123         const LocaleKey& lkey = (const LocaleKey&)key;
 124         Locale loc;
 125         // make sure the requested locale is correct
 126         // default LocaleFactory uses currentLocale since that's the one vetted by handlesKey
 127         // but for ICU rb resources we use the actual one since it will fallback again
 128         lkey.canonicalLocale(loc);
 129
 130         return Collator::makeInstance(loc, status);
 131     }
 132     return NULL;
 133 }
 134
 135 // -------------------------------------
 136
 137 class ICUCollatorService : public ICULocaleService {
 138 public:
 139     ICUCollatorService()
 140         : ICULocaleService(UNICODE_STRING_SIMPLE("Collator"))
 141     {
 142         UErrorCode status = U_ZERO_ERROR;
 143         registerFactory(new ICUCollatorFactory(), status);
 144     }
 145
 146     virtual UObject* cloneInstance(UObject* instance) const {
 147         return ((Collator*)instance)->clone();
 148     }
 149
 150     virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* actualID, UErrorCode& status) const {
 151         LocaleKey& lkey = (LocaleKey&)key;
 152         if (actualID) {
 153             // Ugly Hack Alert! We return an empty actualID to signal
 154             // to callers that this is a default object, not a "real"
 155             // service-created object. (TODO remove in 3.0) [aliu]
 156             actualID->truncate(0);
 157         }
 158         Locale loc("");
 159         lkey.canonicalLocale(loc);
 160         return Collator::makeInstance(loc, status);
 161     }
 162
 163     virtual UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const {
 164         UnicodeString ar;
 165         if (actualReturn == NULL) {
 166             actualReturn = &ar;
 167         }
 168         Collator* result = (Collator*)ICULocaleService::getKey(key, actualReturn, status);
 169         // Ugly Hack Alert! If the actualReturn length is zero, this
 170         // means we got a default object, not a "real" service-created
 171         // object.  We don't call setLocales() on a default object,
 172         // because that will overwrite its correct built-in locale
 173         // metadata (valid & actual) with our incorrect data (all we
 174         // have is the requested locale). (TODO remove in 3.0) [aliu]
 175         if (result && actualReturn->length() > 0) {
 176             const LocaleKey& lkey = (const LocaleKey&)key;
 177             Locale canonicalLocale("");
 178             Locale currentLocale("");
 179
 180             LocaleUtility::initLocaleFromName(*actualReturn, currentLocale);
 181             result->setLocales(lkey.canonicalLocale(canonicalLocale), currentLocale, currentLocale);
 182         }
 183         return result;
 184     }
 185
 186     virtual UBool isDefault() const {
 187         return countFactories() == 1;
 188     }
 189 };
 190
 191 // -------------------------------------
 192
 193 static ICULocaleService*
 194 getService(void)
 195 {
 196     UBool needInit;
 197     UMTX_CHECK(NULL, (UBool)(gService == NULL), needInit);
 198     if(needInit) {
 199         ICULocaleService *newservice = new ICUCollatorService();
 200         if(newservice) {
 201             umtx_lock(NULL);
 202             if(gService == NULL) {
 203                 gService = newservice;
 204                 newservice = NULL;
 205             }
 206             umtx_unlock(NULL);
 207         }
 208         if(newservice) {
 209             delete newservice;
 210         }
 211         else {
 212             ucln_i18n_registerCleanup(UCLN_I18N_COLLATOR, collator_cleanup);
 213         }
 214     }
 215     return gService;
 216 }
 217
 218 // -------------------------------------
 219
 220 static inline UBool
 221 hasService(void)
 222 {
 223     UBool retVal;
 224     UMTX_CHECK(NULL, gService != NULL, retVal);
 225     return retVal;
 226 }
 227
 228 // -------------------------------------
 229
 230 UCollator*
 231 Collator::createUCollator(const char *loc,
 232                           UErrorCode *status)
 233 {
 234     UCollator *result = 0;
 235     if (status && U_SUCCESS(*status) && hasService()) {
 236         Locale desiredLocale(loc);
 237         Collator *col = (Collator*)gService->get(desiredLocale, *status);
 238         RuleBasedCollator *rbc;
 239         if (col && (rbc = dynamic_cast<RuleBasedCollator *>(col))) {
 240             if (!rbc->dataIsOwned) {
 241                 result = ucol_safeClone(rbc->ucollator, NULL, NULL, status);
 242             } else {
 243                 result = rbc->ucollator;
 244                 rbc->ucollator = NULL; // to prevent free on delete
 245             }
 246         }
 247         delete col;
 248     }
 249     return result;
 250 }
 251 #endif /* UCONFIG_NO_SERVICE */
 252
 253 static UBool isAvailableLocaleListInitialized(UErrorCode &status) {
 254     // for now, there is a hardcoded list, so just walk through that list and set it up.
 255     UBool needInit;
 256     UMTX_CHECK(NULL, availableLocaleList == NULL, needInit);
 257
 258     if (needInit) {
 259         UResourceBundle *index = NULL;
 260         UResourceBundle installed;
 261         Locale * temp;
 262         int32_t i = 0;
 263         int32_t localeCount;
 264
 265         ures_initStackObject(&installed);
 266         index = ures_openDirect(U_ICUDATA_COLL, "res_index", &status);
 267         ures_getByKey(index, "InstalledLocales", &installed, &status);
 268
 269         if(U_SUCCESS(status)) {
 270             localeCount = ures_getSize(&installed);
 271             temp = new Locale[localeCount];
 272
 273             if (temp != NULL) {
 274                 ures_resetIterator(&installed);
 275                 while(ures_hasNext(&installed)) {
 276                     const char *tempKey = NULL;
 277                     ures_getNextString(&installed, NULL, &tempKey, &status);
 278                     temp[i++] = Locale(tempKey);
 279                 }
 280
 281                 umtx_lock(NULL);
 282                 if (availableLocaleList == NULL)
 283                 {
 284                     availableLocaleListCount = localeCount;
 285                     availableLocaleList = temp;
 286                     temp = NULL;
 287                     ucln_i18n_registerCleanup(UCLN_I18N_COLLATOR, collator_cleanup);
 288                 }
 289                 umtx_unlock(NULL);
 290
 291                 needInit = FALSE;
 292                 if (temp) {
 293                     delete []temp;
 294                 }
 295             }
 296
 297             ures_close(&installed);
 298         }
 299         ures_close(index);
 300     }
 301     return !needInit;
 302 }
 303
 304 // Collator public methods -----------------------------------------------
 305
 306 Collator* U_EXPORT2 Collator::createInstance(UErrorCode& success)
 307 {
 308     return createInstance(Locale::getDefault(), success);
 309 }
 310
 311 Collator* U_EXPORT2 Collator::createInstance(const Locale& desiredLocale,
 312                                    UErrorCode& status)
 313 {
 314     if (U_FAILURE(status))
 315         return 0;
 316
 317 #if !UCONFIG_NO_SERVICE
 318     if (hasService()) {
 319         Locale actualLoc;
 320         Collator *result =
 321             (Collator*)gService->get(desiredLocale, &actualLoc, status);
 322         // Ugly Hack Alert! If the returned locale is empty (not root,
 323         // but empty -- getName() == "") then that means the service
 324         // returned a default object, not a "real" service object.  In
 325         // that case, the locale metadata (valid & actual) is setup
 326         // correctly already, and we don't want to overwrite it. (TODO
 327         // remove in 3.0) [aliu]
 328         if (*actualLoc.getName() != 0) {
 329             result->setLocales(desiredLocale, actualLoc, actualLoc);
 330         }
 331         return result;
 332     }
 333 #endif
 334     return makeInstance(desiredLocale, status);
 335 }
 336
 337
 338 Collator* Collator::makeInstance(const Locale&  desiredLocale,
 339                                          UErrorCode& status)
 340 {
 341     // A bit of explanation is required here. Although in the current
 342     // implementation
 343     // Collator::createInstance() is just turning around and calling
 344     // RuleBasedCollator(Locale&), this will not necessarily always be the
 345     // case. For example, suppose we modify this code to handle a
 346     // non-table-based Collator, such as that for Thai. In this case,
 347     // createInstance() will have to be modified to somehow determine this fact
 348     // (perhaps a field in the resource bundle). Then it can construct the
 349     // non-table-based Collator in some other way, when it sees that it needs
 350     // to.
 351     // The specific caution is this: RuleBasedCollator(Locale&) will ALWAYS
 352     // return a valid collation object, if the system is functioning properly.
 353     // The reason is that it will fall back, use the default locale, and even
 354     // use the built-in default collation rules. THEREFORE, createInstance()
 355     // should in general ONLY CALL RuleBasedCollator(Locale&) IF IT KNOWS IN
 356     // ADVANCE that the given locale's collation is properly implemented as a
 357     // RuleBasedCollator.
 358     // Currently, we don't do this...we always return a RuleBasedCollator,
 359     // whether it is strictly correct to do so or not, without checking, because
 360     // we currently have no way of checking.
 361
 362     RuleBasedCollator* collation = new RuleBasedCollator(desiredLocale,
 363         status);
 364     /* test for NULL */
 365     if (collation == 0) {
 366         status = U_MEMORY_ALLOCATION_ERROR;
 367         return 0;
 368     }
 369     if (U_FAILURE(status))
 370     {
 371         delete collation;
 372         collation = 0;
 373     }
 374     return collation;
 375 }
 376
 377 #ifdef U_USE_COLLATION_OBSOLETE_2_6
 378 // !!! dlf the following is obsolete, ignore registration for this
 379
 380 Collator *
 381 Collator::createInstance(const Locale &loc,
 382                          UVersionInfo version,
 383                          UErrorCode &status)
 384 {
 385     Collator *collator;
 386     UVersionInfo info;
 387
 388     collator=new RuleBasedCollator(loc, status);
 389     /* test for NULL */
 390     if (collator == 0) {
 391         status = U_MEMORY_ALLOCATION_ERROR;
 392         return 0;
 393     }
 394
 395     if(U_SUCCESS(status)) {
 396         collator->getVersion(info);
 397         if(0!=uprv_memcmp(version, info, sizeof(UVersionInfo))) {
 398             delete collator;
 399             status=U_MISSING_RESOURCE_ERROR;
 400             return 0;
 401         }
 402     }
 403     return collator;
 404 }
 405 #endif
 406
 407 // implement deprecated, previously abstract method
 408 Collator::EComparisonResult Collator::compare(const UnicodeString& source,
 409                                     const UnicodeString& target) const
 410 {
 411     UErrorCode ec = U_ZERO_ERROR;
 412     return (Collator::EComparisonResult)compare(source, target, ec);
 413 }
 414
 415 // implement deprecated, previously abstract method
 416 Collator::EComparisonResult Collator::compare(const UnicodeString& source,
 417                                     const UnicodeString& target,
 418                                     int32_t length) const
 419 {
 420     UErrorCode ec = U_ZERO_ERROR;
 421     return (Collator::EComparisonResult)compare(source, target, length, ec);
 422 }
 423
 424 // implement deprecated, previously abstract method
 425 Collator::EComparisonResult Collator::compare(const UChar* source, int32_t sourceLength,
 426                                     const UChar* target, int32_t targetLength)
 427                                     const
 428 {
 429     UErrorCode ec = U_ZERO_ERROR;
 430     return (Collator::EComparisonResult)compare(source, sourceLength, target, targetLength, ec);
 431 }
 432
 433 UCollationResult Collator::compare(UCharIterator &/*sIter*/,
 434                                    UCharIterator &/*tIter*/,
 435                                    UErrorCode &status) const {
 436     if(U_SUCCESS(status)) {
 437         // Not implemented in the base class.
 438         status = U_UNSUPPORTED_ERROR;
 439     }
 440     return UCOL_EQUAL;
 441 }
 442
 443 UCollationResult Collator::compareUTF8(const StringPiece &source,
 444                                        const StringPiece &target,
 445                                        UErrorCode &status) const {
 446     if(U_FAILURE(status)) {
 447         return UCOL_EQUAL;
 448     }
 449     UCharIterator sIter, tIter;
 450     uiter_setUTF8(&sIter, source.data(), source.length());
 451     uiter_setUTF8(&tIter, target.data(), target.length());
 452     return compare(sIter, tIter, status);
 453 }
 454
 455 UBool Collator::equals(const UnicodeString& source,
 456                        const UnicodeString& target) const
 457 {
 458     UErrorCode ec = U_ZERO_ERROR;
 459     return (compare(source, target, ec) == UCOL_EQUAL);
 460 }
 461
 462 UBool Collator::greaterOrEqual(const UnicodeString& source,
 463                                const UnicodeString& target) const
 464 {
 465     UErrorCode ec = U_ZERO_ERROR;
 466     return (compare(source, target, ec) != UCOL_LESS);
 467 }
 468
 469 UBool Collator::greater(const UnicodeString& source,
 470                         const UnicodeString& target) const
 471 {
 472     UErrorCode ec = U_ZERO_ERROR;
 473     return (compare(source, target, ec) == UCOL_GREATER);
 474 }
 475
 476 // this API  ignores registered collators, since it returns an
 477 // array of indefinite lifetime
 478 const Locale* U_EXPORT2 Collator::getAvailableLocales(int32_t& count)
 479 {
 480     UErrorCode status = U_ZERO_ERROR;
 481     Locale *result = NULL;
 482     count = 0;
 483     if (isAvailableLocaleListInitialized(status))
 484     {
 485         result = availableLocaleList;
 486         count = availableLocaleListCount;
 487     }
 488     return result;
 489 }
 490
 491 UnicodeString& U_EXPORT2 Collator::getDisplayName(const Locale& objectLocale,
 492                                         const Locale& displayLocale,
 493                                         UnicodeString& name)
 494 {
 495 #if !UCONFIG_NO_SERVICE
 496     if (hasService()) {
 497         UnicodeString locNameStr;
 498         LocaleUtility::initNameFromLocale(objectLocale, locNameStr);
 499         return gService->getDisplayName(locNameStr, name, displayLocale);
 500     }
 501 #endif
 502     return objectLocale.getDisplayName(displayLocale, name);
 503 }
 504
 505 UnicodeString& U_EXPORT2 Collator::getDisplayName(const Locale& objectLocale,
 506                                         UnicodeString& name)
 507 {
 508     return getDisplayName(objectLocale, Locale::getDefault(), name);
 509 }
 510
 511 /* This is useless information */
 512 /*void Collator::getVersion(UVersionInfo versionInfo) const
 513 {
 514   if (versionInfo!=NULL)
 515     uprv_memcpy(versionInfo, fVersion, U_MAX_VERSION_LENGTH);
 516 }
 517 */
 518
 519 // UCollator protected constructor destructor ----------------------------
 520
 521 /**
 522 * Default constructor.
 523 * Constructor is different from the old default Collator constructor.
 524 * The task for determing the default collation strength and normalization mode
 525 * is left to the child class.
 526 */
 527 Collator::Collator()
 528 : UObject()
 529 {
 530 }
 531
 532 /**
 533 * Constructor.
 534 * Empty constructor, does not handle the arguments.
 535 * This constructor is done for backward compatibility with 1.7 and 1.8.
 536 * The task for handling the argument collation strength and normalization
 537 * mode is left to the child class.
 538 * @param collationStrength collation strength
 539 * @param decompositionMode
 540 * @deprecated 2.4 use the default constructor instead
 541 */
 542 Collator::Collator(UCollationStrength, UNormalizationMode )
 543 : UObject()
 544 {
 545 }
 546
 547 Collator::~Collator()
 548 {
 549 }
 550
 551 Collator::Collator(const Collator &other)
 552     : UObject(other)
 553 {
 554 }
 555
 556 UBool Collator::operator==(const Collator& other) const
 557 {
 558     return (UBool)(this == &other);
 559 }
 560
 561 UBool Collator::operator!=(const Collator& other) const
 562 {
 563     return (UBool)!(*this == other);
 564 }
 565
 566 int32_t U_EXPORT2 Collator::getBound(const uint8_t       *source,
 567                            int32_t             sourceLength,
 568                            UColBoundMode       boundType,
 569                            uint32_t            noOfLevels,
 570                            uint8_t             *result,
 571                            int32_t             resultLength,
 572                            UErrorCode          &status)
 573 {
 574     return ucol_getBound(source, sourceLength, boundType, noOfLevels, result, resultLength, &status);
 575 }
 576
 577 void
 578 Collator::setLocales(const Locale& /* requestedLocale */, const Locale& /* validLocale */, const Locale& /*actualLocale*/) {
 579 }
 580
 581 UnicodeSet *Collator::getTailoredSet(UErrorCode &status) const
 582 {
 583     if(U_FAILURE(status)) {
 584         return NULL;
 585     }
 586     // everything can be changed
 587     return new UnicodeSet(0, 0x10FFFF);
 588 }
 589
 590 // -------------------------------------
 591
 592 #if !UCONFIG_NO_SERVICE
 593 URegistryKey U_EXPORT2
 594 Collator::registerInstance(Collator* toAdopt, const Locale& locale, UErrorCode& status)
 595 {
 596     if (U_SUCCESS(status)) {
 597         return getService()->registerInstance(toAdopt, locale, status);
 598     }
 599     return NULL;
 600 }
 601
 602 // -------------------------------------
 603
 604 class CFactory : public LocaleKeyFactory {
 605 private:
 606     CollatorFactory* _delegate;
 607     Hashtable* _ids;
 608
 609 public:
 610     CFactory(CollatorFactory* delegate, UErrorCode& status)
 611         : LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
 612         , _delegate(delegate)
 613         , _ids(NULL)
 614     {
 615         if (U_SUCCESS(status)) {
 616             int32_t count = 0;
 617             _ids = new Hashtable(status);
 618             if (_ids) {
 619                 const UnicodeString * idlist = _delegate->getSupportedIDs(count, status);
 620                 for (int i = 0; i < count; ++i) {
 621                     _ids->put(idlist[i], (void*)this, status);
 622                     if (U_FAILURE(status)) {
 623                         delete _ids;
 624                         _ids = NULL;
 625                         return;
 626                     }
 627                 }
 628             } else {
 629                 status = U_MEMORY_ALLOCATION_ERROR;
 630             }
 631         }
 632     }
 633
 634     virtual ~CFactory()
 635     {
 636         delete _delegate;
 637         delete _ids;
 638     }
 639
 640     virtual UObject* create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const;
 641
 642 protected:
 643     virtual const Hashtable* getSupportedIDs(UErrorCode& status) const
 644     {
 645         if (U_SUCCESS(status)) {
 646             return _ids;
 647         }
 648         return NULL;
 649     }
 650
 651     virtual UnicodeString&
 652         getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const;
 653 };
 654
 655 UObject*
 656 CFactory::create(const ICUServiceKey& key, const ICUService* /* service */, UErrorCode& status) const
 657 {
 658     if (handlesKey(key, status)) {
 659         const LocaleKey& lkey = (const LocaleKey&)key;
 660         Locale validLoc;
 661         lkey.currentLocale(validLoc);
 662         return _delegate->createCollator(validLoc);
 663     }
 664     return NULL;
 665 }
 666
 667 UnicodeString&
 668 CFactory::getDisplayName(const UnicodeString& id, const Locale& locale, UnicodeString& result) const
 669 {
 670     if ((_coverage & 0x1) == 0) {
 671         UErrorCode status = U_ZERO_ERROR;
 672         const Hashtable* ids = getSupportedIDs(status);
 673         if (ids && (ids->get(id) != NULL)) {
 674             Locale loc;
 675             LocaleUtility::initLocaleFromName(id, loc);
 676             return _delegate->getDisplayName(loc, locale, result);
 677         }
 678     }
 679     result.setToBogus();
 680     return result;
 681 }
 682
 683 URegistryKey U_EXPORT2
 684 Collator::registerFactory(CollatorFactory* toAdopt, UErrorCode& status)
 685 {
 686     if (U_SUCCESS(status)) {
 687         CFactory* f = new CFactory(toAdopt, status);
 688         if (f) {
 689             return getService()->registerFactory(f, status);
 690         }
 691         status = U_MEMORY_ALLOCATION_ERROR;
 692     }
 693     return NULL;
 694 }
 695
 696 // -------------------------------------
 697
 698 UBool U_EXPORT2
 699 Collator::unregister(URegistryKey key, UErrorCode& status)
 700 {
 701     if (U_SUCCESS(status)) {
 702         if (hasService()) {
 703             return gService->unregister(key, status);
 704         }
 705         status = U_ILLEGAL_ARGUMENT_ERROR;
 706     }
 707     return FALSE;
 708 }
 709 #endif /* UCONFIG_NO_SERVICE */
 710
 711 class CollationLocaleListEnumeration : public StringEnumeration {
 712 private:
 713     int32_t index;
 714 public:
 715     static UClassID U_EXPORT2 getStaticClassID(void);
 716     virtual UClassID getDynamicClassID(void) const;
 717 public:
 718     CollationLocaleListEnumeration()
 719         : index(0)
 720     {
 721         // The global variables should already be initialized.
 722         //isAvailableLocaleListInitialized(status);
 723     }
 724
 725     virtual ~CollationLocaleListEnumeration() {
 726     }
 727
 728     virtual StringEnumeration * clone() const
 729     {
 730         CollationLocaleListEnumeration *result = new CollationLocaleListEnumeration();
 731         if (result) {
 732             result->index = index;
 733         }
 734         return result;
 735     }
 736
 737     virtual int32_t count(UErrorCode &/*status*/) const {
 738         return availableLocaleListCount;
 739     }
 740
 741     virtual const char* next(int32_t* resultLength, UErrorCode& /*status*/) {
 742         const char* result;
 743         if(index < availableLocaleListCount) {
 744             result = availableLocaleList[index++].getName();
 745             if(resultLength != NULL) {
 746                 *resultLength = (int32_t)uprv_strlen(result);
 747             }
 748         } else {
 749             if(resultLength != NULL) {
 750                 *resultLength = 0;
 751             }
 752             result = NULL;
 753         }
 754         return result;
 755     }
 756
 757     virtual const UnicodeString* snext(UErrorCode& status) {
 758         int32_t resultLength = 0;
 759         const char *s = next(&resultLength, status);
 760         return setChars(s, resultLength, status);
 761     }
 762
 763     virtual void reset(UErrorCode& /*status*/) {
 764         index = 0;
 765     }
 766 };
 767
 768 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationLocaleListEnumeration)
 769
 770
 771 // -------------------------------------
 772
 773 StringEnumeration* U_EXPORT2
 774 Collator::getAvailableLocales(void)
 775 {
 776 #if !UCONFIG_NO_SERVICE
 777     if (hasService()) {
 778         return getService()->getAvailableLocales();
 779     }
 780 #endif /* UCONFIG_NO_SERVICE */
 781     UErrorCode status = U_ZERO_ERROR;
 782     if (isAvailableLocaleListInitialized(status)) {
 783         return new CollationLocaleListEnumeration();
 784     }
 785     return NULL;
 786 }
 787
 788 StringEnumeration* U_EXPORT2
 789 Collator::getKeywords(UErrorCode& status) {
 790     // This is a wrapper over ucol_getKeywords
 791     UEnumeration* uenum = ucol_getKeywords(&status);
 792     if (U_FAILURE(status)) {
 793         uenum_close(uenum);
 794         return NULL;
 795     }
 796     return new UStringEnumeration(uenum);
 797 }
 798
 799 StringEnumeration* U_EXPORT2
 800 Collator::getKeywordValues(const char *keyword, UErrorCode& status) {
 801     // This is a wrapper over ucol_getKeywordValues
 802     UEnumeration* uenum = ucol_getKeywordValues(keyword, &status);
 803     if (U_FAILURE(status)) {
 804         uenum_close(uenum);
 805         return NULL;
 806     }
 807     return new UStringEnumeration(uenum);
 808 }
 809
 810 StringEnumeration* U_EXPORT2
 811 Collator::getKeywordValuesForLocale(const char* key, const Locale& locale,
 812                                     UBool commonlyUsed, UErrorCode& status) {
 813     // This is a wrapper over ucol_getKeywordValuesForLocale
 814     UEnumeration *uenum = ucol_getKeywordValuesForLocale(key, locale.getName(),
 815                                                         commonlyUsed, &status);
 816     if (U_FAILURE(status)) {
 817         uenum_close(uenum);
 818         return NULL;
 819     }
 820     return new UStringEnumeration(uenum);
 821 }
 822
 823 Locale U_EXPORT2
 824 Collator::getFunctionalEquivalent(const char* keyword, const Locale& locale,
 825                                   UBool& isAvailable, UErrorCode& status) {
 826     // This is a wrapper over ucol_getFunctionalEquivalent
 827     char loc[ULOC_FULLNAME_CAPACITY];
 828     /*int32_t len =*/ ucol_getFunctionalEquivalent(loc, sizeof(loc),
 829                     keyword, locale.getName(), &isAvailable, &status);
 830     if (U_FAILURE(status)) {
 831         *loc = 0; // root
 832     }
 833     return Locale::createFromName(loc);
 834 }
 835
 836 int32_t Collator::getReorderCodes(int32_t *dest,
 837                                  int32_t destCapacity,
 838                                  UErrorCode& status) const
 839 {
 840     if (U_SUCCESS(status)) {
 841         status = U_UNSUPPORTED_ERROR;
 842     }
 843     return 0;
 844 }
 845
 846 void Collator::setReorderCodes(const int32_t *reorderCodes,
 847                               int32_t reorderCodesLength,
 848                               UErrorCode& status)
 849 {
 850     if (U_SUCCESS(status)) {
 851         status = U_UNSUPPORTED_ERROR;
 852     }
 853 }
 854
 855 // UCollator private data members ----------------------------------------
 856
 857 /* This is useless information */
 858 /*const UVersionInfo Collator::fVersion = {1, 1, 0, 0};*/
 859
 860 // -------------------------------------
 861
 862 U_NAMESPACE_END
 863
 864 #endif /* #if !UCONFIG_NO_COLLATION */
 865
 866 /* eof */