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 */ 867
