| /* | |
| ******************************************************************************* | |
| * Copyright (C) 1996-2014, International Business Machines Corporation and | |
| * others. All Rights Reserved. | |
| ******************************************************************************* | |
| */ | |
| /* | |
| * File coleitr.cpp | |
| * | |
| * Created by: Helena Shih | |
| * | |
| * Modification History: | |
| * | |
| * Date Name Description | |
| * | |
| * 6/23/97 helena Adding comments to make code more readable. | |
| * 08/03/98 erm Synched with 1.2 version of CollationElementIterator.java | |
| * 12/10/99 aliu Ported Thai collation support from Java. | |
| * 01/25/01 swquek Modified to a C++ wrapper calling C APIs (ucoliter.h) | |
| * 02/19/01 swquek Removed CollationElementIterator() since it is | |
| * private constructor and no calls are made to it | |
| * 2012-2014 markus Rewritten in C++ again. | |
| */ | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_COLLATION | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/coleitr.h" | |
| #include "unicode/tblcoll.h" | |
| #include "unicode/ustring.h" | |
| #include "cmemory.h" | |
| #include "collation.h" | |
| #include "collationdata.h" | |
| #include "collationiterator.h" | |
| #include "collationsets.h" | |
| #include "collationtailoring.h" | |
| #include "uassert.h" | |
| #include "uhash.h" | |
| #include "utf16collationiterator.h" | |
| #include "uvectr32.h" | |
| /* Constants --------------------------------------------------------------- */ | |
| U_NAMESPACE_BEGIN | |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CollationElementIterator) | |
| /* CollationElementIterator public constructor/destructor ------------------ */ | |
| CollationElementIterator::CollationElementIterator( | |
| const CollationElementIterator& other) | |
| : UObject(other), iter_(NULL), rbc_(NULL), otherHalf_(0), dir_(0), offsets_(NULL) { | |
| *this = other; | |
| } | |
| CollationElementIterator::~CollationElementIterator() | |
| { | |
| delete iter_; | |
| delete offsets_; | |
| } | |
| /* CollationElementIterator public methods --------------------------------- */ | |
| namespace { | |
| uint32_t getFirstHalf(uint32_t p, uint32_t lower32) { | |
| return (p & 0xffff0000) | ((lower32 >> 16) & 0xff00) | ((lower32 >> 8) & 0xff); | |
| } | |
| uint32_t getSecondHalf(uint32_t p, uint32_t lower32) { | |
| return (p << 16) | ((lower32 >> 8) & 0xff00) | (lower32 & 0x3f); | |
| } | |
| UBool ceNeedsTwoParts(int64_t ce) { | |
| return (ce & INT64_C(0xffff00ff003f)) != 0; | |
| } | |
| } // namespace | |
| int32_t CollationElementIterator::getOffset() const | |
| { | |
| if (dir_ < 0 && offsets_ != NULL && !offsets_->isEmpty()) { | |
| // CollationIterator::previousCE() decrements the CEs length | |
| // while it pops CEs from its internal buffer. | |
| int32_t i = iter_->getCEsLength(); | |
| if (otherHalf_ != 0) { | |
| // Return the trailing CE offset while we are in the middle of a 64-bit CE. | |
| ++i; | |
| } | |
| U_ASSERT(i < offsets_->size()); | |
| return offsets_->elementAti(i); | |
| } | |
| return iter_->getOffset(); | |
| } | |
| /** | |
| * Get the ordering priority of the next character in the string. | |
| * @return the next character's ordering. Returns NULLORDER if an error has | |
| * occured or if the end of string has been reached | |
| */ | |
| int32_t CollationElementIterator::next(UErrorCode& status) | |
| { | |
| if (U_FAILURE(status)) { return NULLORDER; } | |
| if (dir_ > 1) { | |
| // Continue forward iteration. Test this first. | |
| if (otherHalf_ != 0) { | |
| uint32_t oh = otherHalf_; | |
| otherHalf_ = 0; | |
| return oh; | |
| } | |
| } else if (dir_ == 1) { | |
| // next() after setOffset() | |
| dir_ = 2; | |
| } else if (dir_ == 0) { | |
| // The iter_ is already reset to the start of the text. | |
| dir_ = 2; | |
| } else /* dir_ < 0 */ { | |
| // illegal change of direction | |
| status = U_INVALID_STATE_ERROR; | |
| return NULLORDER; | |
| } | |
| // No need to keep all CEs in the buffer when we iterate. | |
| iter_->clearCEsIfNoneRemaining(); | |
| int64_t ce = iter_->nextCE(status); | |
| if (ce == Collation::NO_CE) { return NULLORDER; } | |
| // Turn the 64-bit CE into two old-style 32-bit CEs, without quaternary bits. | |
| uint32_t p = (uint32_t)(ce >> 32); | |
| uint32_t lower32 = (uint32_t)ce; | |
| uint32_t firstHalf = getFirstHalf(p, lower32); | |
| uint32_t secondHalf = getSecondHalf(p, lower32); | |
| if (secondHalf != 0) { | |
| otherHalf_ = secondHalf | 0xc0; // continuation CE | |
| } | |
| return firstHalf; | |
| } | |
| UBool CollationElementIterator::operator!=( | |
| const CollationElementIterator& other) const | |
| { | |
| return !(*this == other); | |
| } | |
| UBool CollationElementIterator::operator==( | |
| const CollationElementIterator& that) const | |
| { | |
| if (this == &that) { | |
| return TRUE; | |
| } | |
| return | |
| (rbc_ == that.rbc_ || *rbc_ == *that.rbc_) && | |
| otherHalf_ == that.otherHalf_ && | |
| normalizeDir() == that.normalizeDir() && | |
| string_ == that.string_ && | |
| *iter_ == *that.iter_; | |
| } | |
| /** | |
| * Get the ordering priority of the previous collation element in the string. | |
| * @param status the error code status. | |
| * @return the previous element's ordering. Returns NULLORDER if an error has | |
| * occured or if the start of string has been reached. | |
| */ | |
| int32_t CollationElementIterator::previous(UErrorCode& status) | |
| { | |
| if (U_FAILURE(status)) { return NULLORDER; } | |
| if (dir_ < 0) { | |
| // Continue backwards iteration. Test this first. | |
| if (otherHalf_ != 0) { | |
| uint32_t oh = otherHalf_; | |
| otherHalf_ = 0; | |
| return oh; | |
| } | |
| } else if (dir_ == 0) { | |
| iter_->resetToOffset(string_.length()); | |
| dir_ = -1; | |
| } else if (dir_ == 1) { | |
| // previous() after setOffset() | |
| dir_ = -1; | |
| } else /* dir_ > 1 */ { | |
| // illegal change of direction | |
| status = U_INVALID_STATE_ERROR; | |
| return NULLORDER; | |
| } | |
| if (offsets_ == NULL) { | |
| offsets_ = new UVector32(status); | |
| if (offsets_ == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return NULLORDER; | |
| } | |
| } | |
| // If we already have expansion CEs, then we also have offsets. | |
| // Otherwise remember the trailing offset in case we need to | |
| // write offsets for an artificial expansion. | |
| int32_t limitOffset = iter_->getCEsLength() == 0 ? iter_->getOffset() : 0; | |
| int64_t ce = iter_->previousCE(*offsets_, status); | |
| if (ce == Collation::NO_CE) { return NULLORDER; } | |
| // Turn the 64-bit CE into two old-style 32-bit CEs, without quaternary bits. | |
| uint32_t p = (uint32_t)(ce >> 32); | |
| uint32_t lower32 = (uint32_t)ce; | |
| uint32_t firstHalf = getFirstHalf(p, lower32); | |
| uint32_t secondHalf = getSecondHalf(p, lower32); | |
| if (secondHalf != 0) { | |
| if (offsets_->isEmpty()) { | |
| // When we convert a single 64-bit CE into two 32-bit CEs, | |
| // we need to make this artificial expansion behave like a normal expansion. | |
| // See CollationIterator::previousCE(). | |
| offsets_->addElement(iter_->getOffset(), status); | |
| offsets_->addElement(limitOffset, status); | |
| } | |
| otherHalf_ = firstHalf; | |
| return secondHalf | 0xc0; // continuation CE | |
| } | |
| return firstHalf; | |
| } | |
| /** | |
| * Resets the cursor to the beginning of the string. | |
| */ | |
| void CollationElementIterator::reset() | |
| { | |
| iter_ ->resetToOffset(0); | |
| otherHalf_ = 0; | |
| dir_ = 0; | |
| } | |
| void CollationElementIterator::setOffset(int32_t newOffset, | |
| UErrorCode& status) | |
| { | |
| if (U_FAILURE(status)) { return; } | |
| if (0 < newOffset && newOffset < string_.length()) { | |
| int32_t offset = newOffset; | |
| do { | |
| UChar c = string_.charAt(offset); | |
| if (!rbc_->isUnsafe(c) || | |
| (U16_IS_LEAD(c) && !rbc_->isUnsafe(string_.char32At(offset)))) { | |
| break; | |
| } | |
| // Back up to before this unsafe character. | |
| --offset; | |
| } while (offset > 0); | |
| if (offset < newOffset) { | |
| // We might have backed up more than necessary. | |
| // For example, contractions "ch" and "cu" make both 'h' and 'u' unsafe, | |
| // but for text "chu" setOffset(2) should remain at 2 | |
| // although we initially back up to offset 0. | |
| // Find the last safe offset no greater than newOffset by iterating forward. | |
| int32_t lastSafeOffset = offset; | |
| do { | |
| iter_->resetToOffset(lastSafeOffset); | |
| do { | |
| iter_->nextCE(status); | |
| if (U_FAILURE(status)) { return; } | |
| } while ((offset = iter_->getOffset()) == lastSafeOffset); | |
| if (offset <= newOffset) { | |
| lastSafeOffset = offset; | |
| } | |
| } while (offset < newOffset); | |
| newOffset = lastSafeOffset; | |
| } | |
| } | |
| iter_->resetToOffset(newOffset); | |
| otherHalf_ = 0; | |
| dir_ = 1; | |
| } | |
| /** | |
| * Sets the source to the new source string. | |
| */ | |
| void CollationElementIterator::setText(const UnicodeString& source, | |
| UErrorCode& status) | |
| { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| string_ = source; | |
| const UChar *s = string_.getBuffer(); | |
| CollationIterator *newIter; | |
| UBool numeric = rbc_->settings->isNumeric(); | |
| if (rbc_->settings->dontCheckFCD()) { | |
| newIter = new UTF16CollationIterator(rbc_->data, numeric, s, s, s + string_.length()); | |
| } else { | |
| newIter = new FCDUTF16CollationIterator(rbc_->data, numeric, s, s, s + string_.length()); | |
| } | |
| if (newIter == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| delete iter_; | |
| iter_ = newIter; | |
| otherHalf_ = 0; | |
| dir_ = 0; | |
| } | |
| // Sets the source to the new character iterator. | |
| void CollationElementIterator::setText(CharacterIterator& source, | |
| UErrorCode& status) | |
| { | |
| if (U_FAILURE(status)) | |
| return; | |
| source.getText(string_); | |
| setText(string_, status); | |
| } | |
| int32_t CollationElementIterator::strengthOrder(int32_t order) const | |
| { | |
| UColAttributeValue s = (UColAttributeValue)rbc_->settings->getStrength(); | |
| // Mask off the unwanted differences. | |
| if (s == UCOL_PRIMARY) { | |
| order &= 0xffff0000; | |
| } | |
| else if (s == UCOL_SECONDARY) { | |
| order &= 0xffffff00; | |
| } | |
| return order; | |
| } | |
| /* CollationElementIterator private constructors/destructors --------------- */ | |
| /** | |
| * This is the "real" constructor for this class; it constructs an iterator | |
| * over the source text using the specified collator | |
| */ | |
| CollationElementIterator::CollationElementIterator( | |
| const UnicodeString &source, | |
| const RuleBasedCollator *coll, | |
| UErrorCode &status) | |
| : iter_(NULL), rbc_(coll), otherHalf_(0), dir_(0), offsets_(NULL) { | |
| setText(source, status); | |
| } | |
| /** | |
| * This is the "real" constructor for this class; it constructs an iterator over | |
| * the source text using the specified collator | |
| */ | |
| CollationElementIterator::CollationElementIterator( | |
| const CharacterIterator &source, | |
| const RuleBasedCollator *coll, | |
| UErrorCode &status) | |
| : iter_(NULL), rbc_(coll), otherHalf_(0), dir_(0), offsets_(NULL) { | |
| // We only call source.getText() which should be const anyway. | |
| setText(const_cast<CharacterIterator &>(source), status); | |
| } | |
| /* CollationElementIterator private methods -------------------------------- */ | |
| const CollationElementIterator& CollationElementIterator::operator=( | |
| const CollationElementIterator& other) | |
| { | |
| if (this == &other) { | |
| return *this; | |
| } | |
| CollationIterator *newIter; | |
| const FCDUTF16CollationIterator *otherFCDIter = | |
| dynamic_cast<const FCDUTF16CollationIterator *>(other.iter_); | |
| if(otherFCDIter != NULL) { | |
| newIter = new FCDUTF16CollationIterator(*otherFCDIter, string_.getBuffer()); | |
| } else { | |
| const UTF16CollationIterator *otherIter = | |
| dynamic_cast<const UTF16CollationIterator *>(other.iter_); | |
| if(otherIter != NULL) { | |
| newIter = new UTF16CollationIterator(*otherIter, string_.getBuffer()); | |
| } else { | |
| newIter = NULL; | |
| } | |
| } | |
| if(newIter != NULL) { | |
| delete iter_; | |
| iter_ = newIter; | |
| rbc_ = other.rbc_; | |
| otherHalf_ = other.otherHalf_; | |
| dir_ = other.dir_; | |
| string_ = other.string_; | |
| } | |
| if(other.dir_ < 0 && other.offsets_ != NULL && !other.offsets_->isEmpty()) { | |
| UErrorCode errorCode = U_ZERO_ERROR; | |
| if(offsets_ == NULL) { | |
| offsets_ = new UVector32(other.offsets_->size(), errorCode); | |
| } | |
| if(offsets_ != NULL) { | |
| offsets_->assign(*other.offsets_, errorCode); | |
| } | |
| } | |
| return *this; | |
| } | |
| namespace { | |
| class MaxExpSink : public ContractionsAndExpansions::CESink { | |
| public: | |
| MaxExpSink(UHashtable *h, UErrorCode &ec) : maxExpansions(h), errorCode(ec) {} | |
| virtual ~MaxExpSink(); | |
| virtual void handleCE(int64_t /*ce*/) {} | |
| virtual void handleExpansion(const int64_t ces[], int32_t length) { | |
| if (length <= 1) { | |
| // We do not need to add single CEs into the map. | |
| return; | |
| } | |
| int32_t count = 0; // number of CE "halves" | |
| for (int32_t i = 0; i < length; ++i) { | |
| count += ceNeedsTwoParts(ces[i]) ? 2 : 1; | |
| } | |
| // last "half" of the last CE | |
| int64_t ce = ces[length - 1]; | |
| uint32_t p = (uint32_t)(ce >> 32); | |
| uint32_t lower32 = (uint32_t)ce; | |
| uint32_t lastHalf = getSecondHalf(p, lower32); | |
| if (lastHalf == 0) { | |
| lastHalf = getFirstHalf(p, lower32); | |
| U_ASSERT(lastHalf != 0); | |
| } else { | |
| lastHalf |= 0xc0; // old-style continuation CE | |
| } | |
| if (count > uhash_igeti(maxExpansions, (int32_t)lastHalf)) { | |
| uhash_iputi(maxExpansions, (int32_t)lastHalf, count, &errorCode); | |
| } | |
| } | |
| private: | |
| UHashtable *maxExpansions; | |
| UErrorCode &errorCode; | |
| }; | |
| MaxExpSink::~MaxExpSink() {} | |
| } // namespace | |
| UHashtable * | |
| CollationElementIterator::computeMaxExpansions(const CollationData *data, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode)) { return NULL; } | |
| UHashtable *maxExpansions = uhash_open(uhash_hashLong, uhash_compareLong, | |
| uhash_compareLong, &errorCode); | |
| if (U_FAILURE(errorCode)) { return NULL; } | |
| MaxExpSink sink(maxExpansions, errorCode); | |
| ContractionsAndExpansions(NULL, NULL, &sink, TRUE).forData(data, errorCode); | |
| if (U_FAILURE(errorCode)) { | |
| uhash_close(maxExpansions); | |
| return NULL; | |
| } | |
| return maxExpansions; | |
| } | |
| int32_t | |
| CollationElementIterator::getMaxExpansion(int32_t order) const { | |
| return getMaxExpansion(rbc_->tailoring->maxExpansions, order); | |
| } | |
| int32_t | |
| CollationElementIterator::getMaxExpansion(const UHashtable *maxExpansions, int32_t order) { | |
| if (order == 0) { return 1; } | |
| int32_t max; | |
| if(maxExpansions != NULL && (max = uhash_igeti(maxExpansions, order)) != 0) { | |
| return max; | |
| } | |
| if ((order & 0xc0) == 0xc0) { | |
| // old-style continuation CE | |
| return 2; | |
| } else { | |
| return 1; | |
| } | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_COLLATION */ |