icuSources/i18n/tblcoll.cpp

   1 /*
   2  ******************************************************************************
   3  * Copyright (C) 1996-2010, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ******************************************************************************
   6  */
   7
   8 /**
   9  * File tblcoll.cpp
  10  *
  11  * Created by: Helena Shih
  12  *
  13  * Modification History:
  14  *
  15  *  Date        Name        Description
  16  *  2/5/97      aliu        Added streamIn and streamOut methods.  Added
  17  *                          constructor which reads RuleBasedCollator object from
  18  *                          a binary file.  Added writeToFile method which streams
  19  *                          RuleBasedCollator out to a binary file.  The streamIn
  20  *                          and streamOut methods use istream and ostream objects
  21  *                          in binary mode.
  22  *  2/11/97     aliu        Moved declarations out of for loop initializer.
  23  *                          Added Mac compatibility #ifdef for ios::nocreate.
  24  *  2/12/97     aliu        Modified to use TableCollationData sub-object to
  25  *                          hold invariant data.
  26  *  2/13/97     aliu        Moved several methods into this class from Collation.
  27  *                          Added a private RuleBasedCollator(Locale&) constructor,
  28  *                          to be used by Collator::getInstance().  General
  29  *                          clean up.  Made use of UErrorCode variables consistent.
  30  *  2/20/97     helena      Added clone, operator==, operator!=, operator=, and copy
  31  *                          constructor and getDynamicClassID.
  32  *  3/5/97      aliu        Changed compaction cycle to improve performance.  We
  33  *                          use the maximum allowable value which is kBlockCount.
  34  *                          Modified getRules() to load rules dynamically.  Changed
  35  *                          constructFromFile() call to accomodate this (added
  36  *                          parameter to specify whether binary loading is to
  37  *                          take place).
  38  * 05/06/97     helena      Added memory allocation error check.
  39  *  6/20/97     helena      Java class name change.
  40  *  6/23/97     helena      Adding comments to make code more readable.
  41  * 09/03/97     helena      Added createCollationKeyValues().
  42  * 06/26/98     erm         Changes for CollationKeys using byte arrays.
  43  * 08/10/98     erm         Synched with 1.2 version of RuleBasedCollator.java
  44  * 04/23/99     stephen     Removed EDecompositionMode, merged with
  45  *                          Normalizer::EMode
  46  * 06/14/99     stephen     Removed kResourceBundleSuffix
  47  * 06/22/99     stephen     Fixed logic in constructFromFile() since .ctx
  48  *                          files are no longer used.
  49  * 11/02/99     helena      Collator performance enhancements.  Special case
  50  *                          for NO_OP situations.
  51  * 11/17/99     srl         More performance enhancements. Inlined some internal functions.
  52  * 12/15/99     aliu        Update to support Thai collation.  Move NormalizerIterator
  53  *                          to implementation file.
  54  * 01/29/01     synwee      Modified into a C++ wrapper calling C APIs (ucol.h)
  55  */
  56
  57 #include <typeinfo>  // for 'typeid' to work
  58
  59 #include "unicode/utypes.h"
  60
  61 #if !UCONFIG_NO_COLLATION
  62
  63 #include "unicode/tblcoll.h"
  64 #include "unicode/coleitr.h"
  65 #include "unicode/ures.h"
  66 #include "unicode/uset.h"
  67 #include "ucol_imp.h"
  68 #include "uresimp.h"
  69 #include "uhash.h"
  70 #include "cmemory.h"
  71 #include "cstring.h"
  72 #include "putilimp.h"
  73
  74 /* public RuleBasedCollator constructor ---------------------------------- */
  75
  76 U_NAMESPACE_BEGIN
  77
  78 /**
  79 * Copy constructor, aliasing, not write-through
  80 */
  81 RuleBasedCollator::RuleBasedCollator(const RuleBasedCollator& that)
  82 : Collator(that)
  83 , dataIsOwned(FALSE)
  84 , isWriteThroughAlias(FALSE)
  85 , ucollator(NULL)
  86 {
  87     RuleBasedCollator::operator=(that);
  88 }
  89
  90 RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
  91                                      UErrorCode& status) :
  92 dataIsOwned(FALSE)
  93 {
  94     construct(rules,
  95         UCOL_DEFAULT_STRENGTH,
  96         UCOL_DEFAULT,
  97         status);
  98 }
  99
 100 RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
 101                                      ECollationStrength collationStrength,
 102                                      UErrorCode& status) : dataIsOwned(FALSE)
 103 {
 104     construct(rules,
 105         getUCollationStrength(collationStrength),
 106         UCOL_DEFAULT,
 107         status);
 108 }
 109
 110 RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
 111                                      UColAttributeValue decompositionMode,
 112                                      UErrorCode& status) :
 113 dataIsOwned(FALSE)
 114 {
 115     construct(rules,
 116         UCOL_DEFAULT_STRENGTH,
 117         decompositionMode,
 118         status);
 119 }
 120
 121 RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
 122                                      ECollationStrength collationStrength,
 123                                      UColAttributeValue decompositionMode,
 124                                      UErrorCode& status) : dataIsOwned(FALSE)
 125 {
 126     construct(rules,
 127         getUCollationStrength(collationStrength),
 128         decompositionMode,
 129         status);
 130 }
 131 RuleBasedCollator::RuleBasedCollator(const uint8_t *bin, int32_t length,
 132                     const RuleBasedCollator *base,
 133                     UErrorCode &status) :
 134 dataIsOwned(TRUE),
 135 isWriteThroughAlias(FALSE)
 136 {
 137   ucollator = ucol_openBinary(bin, length, base->ucollator, &status);
 138 }
 139
 140 void
 141 RuleBasedCollator::setRuleStringFromCollator()
 142 {
 143     int32_t length;
 144     const UChar *r = ucol_getRules(ucollator, &length);
 145
 146     if (r && length > 0) {
 147         // alias the rules string
 148         urulestring.setTo(TRUE, r, length);
 149     }
 150     else {
 151         urulestring.truncate(0); // Clear string.
 152     }
 153 }
 154
 155 // not aliasing, not write-through
 156 void
 157 RuleBasedCollator::construct(const UnicodeString& rules,
 158                              UColAttributeValue collationStrength,
 159                              UColAttributeValue decompositionMode,
 160                              UErrorCode& status)
 161 {
 162     ucollator = ucol_openRules(rules.getBuffer(), rules.length(),
 163         decompositionMode, collationStrength,
 164         NULL, &status);
 165
 166     dataIsOwned = TRUE; // since we own a collator now, we need to get rid of it
 167     isWriteThroughAlias = FALSE;
 168
 169     if(ucollator == NULL) {
 170         if(U_SUCCESS(status)) {
 171             status = U_MEMORY_ALLOCATION_ERROR;
 172         }
 173         return; // Failure
 174     }
 175
 176     setRuleStringFromCollator();
 177 }
 178
 179 /* RuleBasedCollator public destructor ----------------------------------- */
 180
 181 RuleBasedCollator::~RuleBasedCollator()
 182 {
 183     if (dataIsOwned)
 184     {
 185         ucol_close(ucollator);
 186     }
 187     ucollator = 0;
 188 }
 189
 190 /* RuleBaseCollator public methods --------------------------------------- */
 191
 192 UBool RuleBasedCollator::operator==(const Collator& that) const
 193 {
 194   /* only checks for address equals here */
 195   if (Collator::operator==(that))
 196     return TRUE;
 197
 198   if (typeid(*this) != typeid(that))
 199     return FALSE;  /* not the same class */
 200
 201   RuleBasedCollator& thatAlias = (RuleBasedCollator&)that;
 202
 203   // weiv: use C function, commented code below is wrong
 204   return ucol_equals(this->ucollator, thatAlias.ucollator);
 205   /*
 206   synwee : orginal code does not check for data compatibility
 207   */
 208   /*
 209   if (ucollator != thatAlias.ucollator)
 210     return FALSE;
 211
 212   return TRUE;
 213   */
 214 }
 215
 216 UBool RuleBasedCollator::operator!=(const Collator& other) const
 217 {
 218     return !(*this == other);
 219 }
 220
 221 // aliasing, not write-through
 222 RuleBasedCollator& RuleBasedCollator::operator=(const RuleBasedCollator& that)
 223 {
 224     if (this != &that)
 225     {
 226         if (dataIsOwned)
 227         {
 228             ucol_close(ucollator);
 229         }
 230
 231         urulestring.truncate(0); // empty the rule string
 232         dataIsOwned = TRUE;
 233         isWriteThroughAlias = FALSE;
 234
 235         UErrorCode intStatus = U_ZERO_ERROR;
 236         int32_t buffersize = U_COL_SAFECLONE_BUFFERSIZE;
 237         ucollator = ucol_safeClone(that.ucollator, NULL, &buffersize,
 238                                         &intStatus);
 239         if (U_SUCCESS(intStatus)) {
 240             setRuleStringFromCollator();
 241         }
 242     }
 243     return *this;
 244 }
 245
 246 // aliasing, not write-through
 247 Collator* RuleBasedCollator::clone() const
 248 {
 249     return new RuleBasedCollator(*this);
 250 }
 251
 252 CollationElementIterator* RuleBasedCollator::createCollationElementIterator
 253                                            (const UnicodeString& source) const
 254 {
 255     UErrorCode status = U_ZERO_ERROR;
 256     CollationElementIterator *result = new CollationElementIterator(source, this,
 257                                                                     status);
 258     if (U_FAILURE(status)) {
 259         delete result;
 260         return NULL;
 261     }
 262
 263     return result;
 264 }
 265
 266 /**
 267 * Create a CollationElementIterator object that will iterate over the
 268 * elements in a string, using the collation rules defined in this
 269 * RuleBasedCollator
 270 */
 271 CollationElementIterator* RuleBasedCollator::createCollationElementIterator
 272                                        (const CharacterIterator& source) const
 273 {
 274     UErrorCode status = U_ZERO_ERROR;
 275     CollationElementIterator *result = new CollationElementIterator(source, this,
 276                                                                     status);
 277
 278     if (U_FAILURE(status)) {
 279         delete result;
 280         return NULL;
 281     }
 282
 283     return result;
 284 }
 285
 286 /**
 287 * Return a string representation of this collator's rules. The string can
 288 * later be passed to the constructor that takes a UnicodeString argument,
 289 * which will construct a collator that's functionally identical to this one.
 290 * You can also allow users to edit the string in order to change the collation
 291 * data, or you can print it out for inspection, or whatever.
 292 */
 293 const UnicodeString& RuleBasedCollator::getRules() const
 294 {
 295     return urulestring;
 296 }
 297
 298 void RuleBasedCollator::getRules(UColRuleOption delta, UnicodeString &buffer)
 299 {
 300     int32_t rulesize = ucol_getRulesEx(ucollator, delta, NULL, -1);
 301
 302     if (rulesize > 0) {
 303         UChar *rules = (UChar*) uprv_malloc( sizeof(UChar) * (rulesize) );
 304         if(rules != NULL) {
 305             ucol_getRulesEx(ucollator, delta, rules, rulesize);
 306             buffer.setTo(rules, rulesize);
 307             uprv_free(rules);
 308         } else { // couldn't allocate
 309             buffer.remove();
 310         }
 311     }
 312     else {
 313         buffer.remove();
 314     }
 315 }
 316
 317 UnicodeSet *
 318 RuleBasedCollator::getTailoredSet(UErrorCode &status) const
 319 {
 320     if(U_FAILURE(status)) {
 321         return NULL;
 322     }
 323     return (UnicodeSet *)ucol_getTailoredSet(this->ucollator, &status);
 324 }
 325
 326
 327 void RuleBasedCollator::getVersion(UVersionInfo versionInfo) const
 328 {
 329     if (versionInfo!=NULL){
 330         ucol_getVersion(ucollator, versionInfo);
 331     }
 332 }
 333
 334 Collator::EComparisonResult RuleBasedCollator::compare(
 335                                                const UnicodeString& source,
 336                                                const UnicodeString& target,
 337                                                int32_t length) const
 338 {
 339     UErrorCode status = U_ZERO_ERROR;
 340     return getEComparisonResult(compare(source.getBuffer(), uprv_min(length,source.length()), target.getBuffer(), uprv_min(length,target.length()), status));
 341 }
 342
 343 UCollationResult RuleBasedCollator::compare(
 344                                                const UnicodeString& source,
 345                                                const UnicodeString& target,
 346                                                int32_t length,
 347                                                UErrorCode &status) const
 348 {
 349     return compare(source.getBuffer(), uprv_min(length,source.length()), target.getBuffer(), uprv_min(length,target.length()), status);
 350 }
 351
 352 Collator::EComparisonResult RuleBasedCollator::compare(const UChar* source,
 353                                                        int32_t sourceLength,
 354                                                        const UChar* target,
 355                                                        int32_t targetLength)
 356                                                        const
 357 {
 358     return  getEComparisonResult(ucol_strcoll(ucollator, source, sourceLength,
 359                                                          target, targetLength));
 360 }
 361
 362 UCollationResult RuleBasedCollator::compare(const UChar* source,
 363                                                        int32_t sourceLength,
 364                                                        const UChar* target,
 365                                                        int32_t targetLength,
 366                                                        UErrorCode &status) const
 367 {
 368     if(U_SUCCESS(status)) {
 369         return  ucol_strcoll(ucollator, source, sourceLength, target, targetLength);
 370     } else {
 371         return UCOL_EQUAL;
 372     }
 373 }
 374
 375 /**
 376 * Compare two strings using this collator
 377 */
 378 Collator::EComparisonResult RuleBasedCollator::compare(
 379                                              const UnicodeString& source,
 380                                              const UnicodeString& target) const
 381 {
 382     return getEComparisonResult(ucol_strcoll(ucollator, source.getBuffer(), source.length(),
 383                                                         target.getBuffer(), target.length()));
 384 }
 385
 386 UCollationResult RuleBasedCollator::compare(
 387                                              const UnicodeString& source,
 388                                              const UnicodeString& target,
 389                                              UErrorCode &status) const
 390 {
 391     if(U_SUCCESS(status)) {
 392         return ucol_strcoll(ucollator, source.getBuffer(), source.length(),
 393                                        target.getBuffer(), target.length());
 394     } else {
 395         return UCOL_EQUAL;
 396     }
 397 }
 398
 399 UCollationResult RuleBasedCollator::compare(UCharIterator &sIter,
 400                                             UCharIterator &tIter,
 401                                             UErrorCode &status) const {
 402     if(U_SUCCESS(status)) {
 403         return ucol_strcollIter(ucollator, &sIter, &tIter, &status);
 404     } else {
 405         return UCOL_EQUAL;
 406     }
 407 }
 408
 409 /**
 410 * Retrieve a collation key for the specified string. The key can be compared
 411 * with other collation keys using a bitwise comparison (e.g. memcmp) to find
 412 * the ordering of their respective source strings. This is handy when doing a
 413 * sort, where each sort key must be compared many times.
 414 *
 415 * The basic algorithm here is to find all of the collation elements for each
 416 * character in the source string, convert them to an ASCII representation, and
 417 * put them into the collation key.  But it's trickier than that. Each
 418 * collation element in a string has three components: primary ('A' vs 'B'),
 419 * secondary ('u' vs '\u00FC'), and tertiary ('A' vs 'a'), and a primary difference
 420 * at the end of a string takes precedence over a secondary or tertiary
 421 * difference earlier in the string.
 422 *
 423 * To account for this, we put all of the primary orders at the beginning of
 424 * the string, followed by the secondary and tertiary orders. Each set of
 425 * orders is terminated by nulls so that a key for a string which is a initial
 426 * substring of another key will compare less without any special case.
 427 *
 428 * Here's a hypothetical example, with the collation element represented as a
 429 * three-digit number, one digit for primary, one for secondary, etc.
 430 *
 431 * String:              A     a     B    \u00C9
 432 * Collation Elements: 101   100   201  511
 433 * Collation Key:      1125<null>0001<null>1011<null>
 434 *
 435 * To make things even trickier, secondary differences (accent marks) are
 436 * compared starting at the *end* of the string in languages with French
 437 * secondary ordering. But when comparing the accent marks on a single base
 438 * character, they are compared from the beginning. To handle this, we reverse
 439 * all of the accents that belong to each base character, then we reverse the
 440 * entire string of secondary orderings at the end.
 441 */
 442 CollationKey& RuleBasedCollator::getCollationKey(
 443                                                   const UnicodeString& source,
 444                                                   CollationKey& sortkey,
 445                                                   UErrorCode& status) const
 446 {
 447     return getCollationKey(source.getBuffer(), source.length(), sortkey, status);
 448 }
 449
 450 CollationKey& RuleBasedCollator::getCollationKey(const UChar* source,
 451                                                     int32_t sourceLen,
 452                                                     CollationKey& sortkey,
 453                                                     UErrorCode& status) const
 454 {
 455     if (U_FAILURE(status))
 456     {
 457         return sortkey.setToBogus();
 458     }
 459
 460     if ((!source) || (sourceLen == 0)) {
 461         return sortkey.reset();
 462     }
 463
 464     uint8_t *result;
 465     int32_t resultLen = ucol_getSortKeyWithAllocation(ucollator,
 466                                                       source, sourceLen,
 467                                                       &result,
 468                                                       &status);
 469     sortkey.adopt(result, resultLen);
 470     return sortkey;
 471 }
 472
 473 /**
 474  * Return the maximum length of any expansion sequences that end with the
 475  * specified comparison order.
 476  * @param order a collation order returned by previous or next.
 477  * @return the maximum length of any expansion seuences ending with the
 478  *         specified order or 1 if collation order does not occur at the end of any
 479  *         expansion sequence.
 480  * @see CollationElementIterator#getMaxExpansion
 481  */
 482 int32_t RuleBasedCollator::getMaxExpansion(int32_t order) const
 483 {
 484     uint8_t result;
 485     UCOL_GETMAXEXPANSION(ucollator, (uint32_t)order, result);
 486     return result;
 487 }
 488
 489 uint8_t* RuleBasedCollator::cloneRuleData(int32_t &length,
 490                                               UErrorCode &status)
 491 {
 492     return ucol_cloneRuleData(ucollator, &length, &status);
 493 }
 494
 495
 496 int32_t RuleBasedCollator::cloneBinary(uint8_t *buffer, int32_t capacity, UErrorCode &status)
 497 {
 498   return ucol_cloneBinary(ucollator, buffer, capacity, &status);
 499 }
 500
 501 void RuleBasedCollator::setAttribute(UColAttribute attr,
 502                                      UColAttributeValue value,
 503                                      UErrorCode &status)
 504 {
 505     if (U_FAILURE(status))
 506         return;
 507     checkOwned();
 508     ucol_setAttribute(ucollator, attr, value, &status);
 509 }
 510
 511 UColAttributeValue RuleBasedCollator::getAttribute(UColAttribute attr,
 512                                                       UErrorCode &status)
 513 {
 514     if (U_FAILURE(status))
 515         return UCOL_DEFAULT;
 516     return ucol_getAttribute(ucollator, attr, &status);
 517 }
 518
 519 uint32_t RuleBasedCollator::setVariableTop(const UChar *varTop, int32_t len, UErrorCode &status) {
 520     checkOwned();
 521     return ucol_setVariableTop(ucollator, varTop, len, &status);
 522 }
 523
 524 uint32_t RuleBasedCollator::setVariableTop(const UnicodeString varTop, UErrorCode &status) {
 525     checkOwned();
 526     return ucol_setVariableTop(ucollator, varTop.getBuffer(), varTop.length(), &status);
 527 }
 528
 529 void RuleBasedCollator::setVariableTop(const uint32_t varTop, UErrorCode &status) {
 530     checkOwned();
 531     ucol_restoreVariableTop(ucollator, varTop, &status);
 532 }
 533
 534 uint32_t RuleBasedCollator::getVariableTop(UErrorCode &status) const {
 535   return ucol_getVariableTop(ucollator, &status);
 536 }
 537
 538 Collator* RuleBasedCollator::safeClone(void)
 539 {
 540     UErrorCode intStatus = U_ZERO_ERROR;
 541     int32_t buffersize = U_COL_SAFECLONE_BUFFERSIZE;
 542     UCollator *ucol = ucol_safeClone(ucollator, NULL, &buffersize,
 543                                     &intStatus);
 544     if (U_FAILURE(intStatus)) {
 545         return NULL;
 546     }
 547
 548     RuleBasedCollator *result = new RuleBasedCollator();
 549     // Null pointer check
 550     if (result != NULL) {
 551             result->ucollator = ucol;
 552             result->dataIsOwned = TRUE;
 553             result->isWriteThroughAlias = FALSE;
 554             setRuleStringFromCollator();
 555     }
 556
 557     return result;
 558 }
 559
 560
 561 int32_t RuleBasedCollator::getSortKey(const UnicodeString& source,
 562                                          uint8_t *result, int32_t resultLength)
 563                                          const
 564 {
 565     return ucol_getSortKey(ucollator, source.getBuffer(), source.length(), result, resultLength);
 566 }
 567
 568 int32_t RuleBasedCollator::getSortKey(const UChar *source,
 569                                          int32_t sourceLength, uint8_t *result,
 570                                          int32_t resultLength) const
 571 {
 572     return ucol_getSortKey(ucollator, source, sourceLength, result, resultLength);
 573 }
 574
 575 Collator::ECollationStrength RuleBasedCollator::getStrength(void) const
 576 {
 577     UErrorCode intStatus = U_ZERO_ERROR;
 578     return getECollationStrength(ucol_getAttribute(ucollator, UCOL_STRENGTH,
 579                                 &intStatus));
 580 }
 581
 582 void RuleBasedCollator::setStrength(ECollationStrength newStrength)
 583 {
 584     checkOwned();
 585     UErrorCode intStatus = U_ZERO_ERROR;
 586     UCollationStrength strength = getUCollationStrength(newStrength);
 587     ucol_setAttribute(ucollator, UCOL_STRENGTH, strength, &intStatus);
 588 }
 589
 590 int32_t RuleBasedCollator::getReorderCodes(int32_t *dest,
 591                                           int32_t destCapacity,
 592                                           UErrorCode& status) const
 593 {
 594     return ucol_getReorderCodes(ucollator, dest, destCapacity, &status);
 595 }
 596
 597 void RuleBasedCollator::setReorderCodes(const int32_t *reorderCodes,
 598                                        int32_t reorderCodesLength,
 599                                        UErrorCode& status)
 600 {
 601     ucol_setReorderCodes(ucollator, reorderCodes, reorderCodesLength, &status);
 602 }
 603
 604
 605 /**
 606 * Create a hash code for this collation. Just hash the main rule table -- that
 607 * should be good enough for almost any use.
 608 */
 609 int32_t RuleBasedCollator::hashCode() const
 610 {
 611     int32_t length;
 612     const UChar *rules = ucol_getRules(ucollator, &length);
 613     return uhash_hashUCharsN(rules, length);
 614 }
 615
 616 /**
 617 * return the locale of this collator
 618 */
 619 const Locale RuleBasedCollator::getLocale(ULocDataLocaleType type, UErrorCode &status) const {
 620     const char *result = ucol_getLocaleByType(ucollator, type, &status);
 621     if(result == NULL) {
 622         Locale res("");
 623         res.setToBogus();
 624         return res;
 625     } else {
 626         return Locale(result);
 627     }
 628 }
 629
 630 void
 631 RuleBasedCollator::setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale) {
 632     checkOwned();
 633     char* rloc  = uprv_strdup(requestedLocale.getName());
 634     if (rloc) {
 635         char* vloc = uprv_strdup(validLocale.getName());
 636         if (vloc) {
 637             char* aloc = uprv_strdup(actualLocale.getName());
 638             if (aloc) {
 639                 ucol_setReqValidLocales(ucollator, rloc, vloc, aloc);
 640                 return;
 641             }
 642             uprv_free(vloc);
 643         }
 644         uprv_free(rloc);
 645     }
 646 }
 647
 648 // RuleBaseCollatorNew private constructor ----------------------------------
 649
 650 RuleBasedCollator::RuleBasedCollator()
 651   : dataIsOwned(FALSE), isWriteThroughAlias(FALSE), ucollator(NULL)
 652 {
 653 }
 654
 655 RuleBasedCollator::RuleBasedCollator(const Locale& desiredLocale,
 656                                            UErrorCode& status)
 657  : dataIsOwned(FALSE), isWriteThroughAlias(FALSE), ucollator(NULL)
 658 {
 659     if (U_FAILURE(status))
 660         return;
 661
 662     /*
 663     Try to load, in order:
 664      1. The desired locale's collation.
 665      2. A fallback of the desired locale.
 666      3. The default locale's collation.
 667      4. A fallback of the default locale.
 668      5. The default collation rules, which contains en_US collation rules.
 669
 670      To reiterate, we try:
 671      Specific:
 672       language+country+variant
 673       language+country
 674       language
 675      Default:
 676       language+country+variant
 677       language+country
 678       language
 679      Root: (aka DEFAULTRULES)
 680      steps 1-5 are handled by resource bundle fallback mechanism.
 681      however, in a very unprobable situation that no resource bundle
 682      data exists, step 5 is repeated with hardcoded default rules.
 683     */
 684
 685     setUCollator(desiredLocale, status);
 686
 687     if (U_FAILURE(status))
 688     {
 689         status = U_ZERO_ERROR;
 690
 691         setUCollator(kRootLocaleName, status);
 692         if (status == U_ZERO_ERROR) {
 693             status = U_USING_DEFAULT_WARNING;
 694         }
 695     }
 696
 697     if (U_SUCCESS(status))
 698     {
 699         setRuleStringFromCollator();
 700     }
 701 }
 702
 703 void
 704 RuleBasedCollator::setUCollator(const char *locale,
 705                                 UErrorCode &status)
 706 {
 707     if (U_FAILURE(status))
 708         return;
 709     if (ucollator && dataIsOwned)
 710         ucol_close(ucollator);
 711     ucollator = ucol_open_internal(locale, &status);
 712     dataIsOwned = TRUE;
 713     isWriteThroughAlias = FALSE;
 714 }
 715
 716
 717 void
 718 RuleBasedCollator::checkOwned() {
 719     if (!(dataIsOwned || isWriteThroughAlias)) {
 720         UErrorCode status = U_ZERO_ERROR;
 721         ucollator = ucol_safeClone(ucollator, NULL, NULL, &status);
 722         setRuleStringFromCollator();
 723         dataIsOwned = TRUE;
 724         isWriteThroughAlias = FALSE;
 725     }
 726 }
 727
 728 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedCollator)
 729
 730 U_NAMESPACE_END
 731
 732 #endif /* #if !UCONFIG_NO_COLLATION */