| /* |
| ********************************************************************** |
| * Copyright (C) 1999-2000 IBM and others. All rights reserved. |
| ********************************************************************** |
| * Date Name Description |
| * 03/22/2000 helena Creation. |
| ********************************************************************** |
| */ |
| |
| #include <memory.h> |
| #include "unicode/coleitr.h" |
| #include "unicode/schriter.h" |
| #include "strsrch.h" |
| /** |
| * <code>StringSearch</code> is a <code>SearchIterator</code> that provides |
| * language-sensitive text searching based on the comparison rules defined |
| * in a {@link RuleBasedCollator} object. |
| * Instances of <code>StringSearch</code> function as iterators |
| * maintain a current position and scan over text returning the index of |
| * characters where the pattern occurs and the length of each match. |
| * <p> |
| * <code>StringSearch</code> uses a version of the fast Boyer-Moore search |
| * algorithm that has been adapted to work with the large character set of |
| * Unicode. See "Efficient Text Searching in Java", to be published in |
| * <i>Java Report</i> in February, 1999, for further information on the algorithm. |
| * <p> |
| * Consult the <code>SearchIterator</code> documentation for information on |
| * and examples of how to use instances of this class to implement text |
| * searching. <code>SearchIterator</code> provides all of the necessary |
| * API; this class only provides constructors and internal implementation |
| * methods. |
| * |
| * @see SearchIterator |
| * @see RuleBasedCollator |
| * |
| * @author Laura Werner |
| * @version 1.0 |
| */ |
| |
| char StringSearch::fgClassID = 0; // Value is irrelevant // class id |
| /* to be removed */ |
| void StringSearch::dumpTables() { |
| int i; |
| for (i = 0; i < 256; i++) { |
| if (shiftTable[i] != minLen) { |
| // debug("shift[" + Integer.toString(i,16) + "] = " + shiftTable[i]); |
| } |
| } |
| for (i = 0; i < 256; i++) { |
| if (backShiftTable[i] != minLen) { |
| // debug("backShift[" + Integer.toString(i,16) + "] = " + backShiftTable[i]); |
| } |
| } |
| } |
| |
| StringSearch::StringSearch(const UnicodeString& pat, |
| CharacterIterator* target, |
| RuleBasedCollator* coll, |
| BreakIterator* breaker, |
| UErrorCode& status) : |
| SearchIterator(target, breaker), |
| strength(coll->getStrength()), |
| valueList(NULL), |
| valueListLen(0), |
| pattern(pat), |
| normLen(0), // num. of collation elements in pattern. |
| minLen(0), // Min of composed, decomposed versions |
| maxLen(0), // Max |
| it(NULL) |
| |
| { |
| if (U_FAILURE(status)) return; |
| collator = (RuleBasedCollator*)(coll->clone()); |
| iter = collator->createCollationElementIterator(*target); |
| it = collator->createCollationElementIterator(pat); |
| |
| initialize(status); // Initialize the Boyer-Moore tables |
| } |
| |
| /** |
| * Construct a <code>StringSearch</code> object using a specific collator. |
| * <p> |
| * @param pattern The text for which this object will search. |
| * |
| * @param target The text in which to search for the pattern. |
| * |
| * @param collator A <code>RuleBasedCollator</code> object which defines the |
| * language-sensitive comparison rules used to determine |
| * whether text in the pattern and target matches. |
| */ |
| StringSearch::StringSearch(const UnicodeString& pat, |
| CharacterIterator* target, |
| RuleBasedCollator* collator, |
| UErrorCode& status) : |
| SearchIterator(), |
| strength(collator->getStrength()), |
| valueList(NULL), |
| valueListLen(0), |
| pattern(pat), |
| normLen(0), // num. of collation elements in pattern. |
| minLen(0), // Min of composed, decomposed versions |
| maxLen(0), // Max |
| it(NULL) |
| { |
| if (U_FAILURE(status)) return; |
| this->adoptTarget(target); |
| this->collator = (RuleBasedCollator*)(collator->clone()); |
| this->iter = collator->createCollationElementIterator(*target); |
| this->it = collator->createCollationElementIterator(pat); |
| initialize(status); |
| } |
| |
| /** |
| * Construct a <code>StringSearch</code> object using the collator and |
| * character boundary detection rules for a given locale |
| * <p> |
| * @param pattern The text for which this object will search. |
| * |
| * @param target The text in which to search for the pattern. |
| * |
| * @param loc The locale whose collation and break-detection rules |
| * should be used. |
| * |
| * @exception ClassCastException thrown if the collator for the specified |
| * locale is not a RuleBasedCollator. |
| */ |
| StringSearch::StringSearch(const StringSearch& that) : |
| SearchIterator(that), |
| iter(NULL), |
| collator(that.collator), |
| strength(that.strength), |
| valueList(NULL), |
| valueListLen(that.valueListLen), |
| normLen(that.normLen), // num. of collation elements in pattern. |
| minLen(that.minLen), // Min of composed, decomposed versions |
| maxLen(that.maxLen), |
| it(NULL) |
| { |
| valueList = new int32_t[valueListLen]; |
| memcpy(valueList, that.valueList, valueListLen*sizeof(int32_t)); |
| iter = that.collator->createCollationElementIterator(that.getTarget()); |
| it = that.collator->createCollationElementIterator(that.pattern); |
| } |
| |
| StringSearch::StringSearch(const UnicodeString& pat, |
| CharacterIterator* target, |
| const Locale& loc, |
| UErrorCode& status) : |
| SearchIterator(), |
| valueList(NULL), |
| valueListLen(0), |
| pattern(pat), |
| normLen(0), // num. of collation elements in pattern. |
| minLen(0), // Min of composed, decomposed versions |
| maxLen(0) // Max |
| { |
| if (U_FAILURE(status)) return; |
| this->adoptTarget(target); |
| collator = (RuleBasedCollator*)Collator::createInstance(loc, status); |
| iter = collator->createCollationElementIterator(*target); |
| it = collator->createCollationElementIterator(pat); |
| |
| strength = collator->getStrength(); |
| |
| initialize(status); |
| } |
| |
| UBool |
| StringSearch::operator==(const SearchIterator& that) const |
| { |
| if (that.getDynamicClassID() != getDynamicClassID()) |
| return FALSE; |
| if (!SearchIterator::operator==(that)) |
| return FALSE; |
| const StringSearch& that2 = (const StringSearch&)that; |
| if (*that2.iter != *iter) return FALSE; |
| else if (*that2.collator != *collator) return FALSE; |
| else if (that2.strength != strength) return FALSE; |
| else if (that2.valueListLen != valueListLen) return FALSE; |
| else if (memcmp(that2.valueList, valueList, valueListLen*sizeof(int32_t)) != 0) return FALSE; |
| else if (that2.pattern != pattern) return FALSE; |
| else if (that2.normLen != normLen) return FALSE; |
| else if (that2.minLen != minLen) return FALSE; |
| else if (that2.maxLen != maxLen) return FALSE; |
| else return TRUE; |
| } |
| |
| SearchIterator* |
| StringSearch::clone(void) const |
| { |
| return new StringSearch(*this); |
| } |
| |
| /** |
| * Construct a <code>StringSearch</code> object using the collator for the default |
| * locale |
| * <p> |
| * @param pattern The text for which this object will search. |
| * |
| * @param target The text in which to search for the pattern. |
| * |
| * @param collator A <code>RuleBasedCollator</code> object which defines the |
| * language-sensitive comparison rules used to determine |
| * whether text in the pattern and target matches. |
| */ |
| StringSearch::StringSearch(const UnicodeString& pat, |
| const UnicodeString& newText, |
| UErrorCode& status) : |
| SearchIterator(), |
| valueList(NULL), |
| valueListLen(0), |
| pattern(pat), |
| normLen(0), // num. of collation elements in pattern. |
| minLen(0), // Min of composed, decomposed versions |
| maxLen(0) // Max |
| { |
| StringCharacterIterator *s = new StringCharacterIterator(newText); |
| collator = (RuleBasedCollator*)Collator::createInstance(Locale::getDefault(), status); |
| strength = collator->getStrength(); |
| iter = collator->createCollationElementIterator(newText); |
| it = collator->createCollationElementIterator(pat); |
| this->adoptTarget(s); |
| initialize(status); |
| } |
| |
| StringSearch::~StringSearch(void) |
| { |
| if (valueList != NULL) { |
| delete [] valueList; |
| valueList = 0; |
| } |
| if (iter != NULL) { |
| delete iter; |
| iter = 0; |
| } |
| if (collator != NULL) { |
| delete collator; |
| collator = 0; |
| } |
| if (it != NULL) { |
| delete it; |
| it = 0; |
| } |
| } |
| //------------------------------------------------------------------- |
| // Getters and Setters |
| //------------------------------------------------------------------- |
| |
| /** |
| * Sets this object's strength property. The strength determines the |
| * minimum level of difference considered significant during a |
| * search. Generally, {@link Collator#TERTIARY} and |
| * {@link Collator#IDENTICAL} indicate that all differences are |
| * considered significant, {@link Collator#SECONDARY} indicates |
| * that upper/lower case distinctions should be ignored, and |
| * {@link Collator#PRIMARY} indicates that both case and accents |
| * should be ignored. However, the exact meanings of these constants |
| * are determined by individual Collator objects. |
| * <p> |
| * @see Collator#PRIMARY |
| * @see Collator#SECONDARY |
| * @see Collator#TERTIARY |
| * @see Collator#IDENTICAL |
| */ |
| void StringSearch::setStrength(Collator::ECollationStrength newStrength, UErrorCode& status) { |
| if (U_FAILURE(status)) |
| { |
| return; |
| } |
| strength = newStrength; |
| |
| // Due to a bug (?) in CollationElementIterator, we must set the |
| // collator's strength as well, since the iterator is going to |
| // mask out the portions of the collation element that are not |
| // relevant for the collator's current strength setting |
| // Note that this makes it impossible to share a Collator among |
| // multiple StringSearch objects if you adjust Strength settings. |
| collator->setStrength(strength); |
| initialize(status); |
| } |
| |
| |
| /** |
| * Returns this object's strength property, which indicates what level |
| * of differences are considered significant during a search. |
| * <p> |
| * @see #setStrength |
| */ |
| Collator::ECollationStrength StringSearch::getStrength() const |
| { |
| return strength; |
| } |
| |
| /** |
| * Set the collator to be used for this string search. Also changes |
| * the search strength to match that of the new collator. |
| * <p> |
| * This method causes internal data such as Boyer-Moore shift tables |
| * to be recalculated, but the iterator's position is unchanged. |
| * <p> |
| * @see #getCollator |
| */ |
| void StringSearch::setCollator(const RuleBasedCollator *coll, UErrorCode& status) |
| { |
| delete iter; |
| delete collator; |
| collator = (RuleBasedCollator*)coll->clone(); |
| strength = collator->getStrength(); |
| // Also need to recompute the pattern and get a new target iterator |
| iter = collator->createCollationElementIterator(getTarget()); |
| initialize(status); |
| } |
| |
| /** |
| * Return the RuleBasedCollator being used for this string search. |
| */ |
| const RuleBasedCollator& StringSearch::getCollator(void) const |
| { |
| return *collator; |
| } |
| |
| /** |
| * Set the pattern for which to search. |
| * This method causes internal data such as Boyer-Moore shift tables |
| * to be recalculated, but the iterator's position is unchanged. |
| */ |
| void StringSearch::setPattern(const UnicodeString& pat, UErrorCode& status) |
| { |
| pattern = pat; |
| initialize(status); |
| } |
| |
| /** |
| * Returns the pattern for which this object is searching. |
| */ |
| const UnicodeString& StringSearch::getPattern() const |
| { |
| return pattern; |
| } |
| |
| /** |
| * Set the target text which should be searched and resets the |
| * iterator's position to point before the start of the new text. |
| * This method is useful if you want to re-use an iterator to |
| * search for the same pattern within a different body of text. |
| */ |
| void StringSearch::adoptTarget(CharacterIterator* target) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| SearchIterator::adoptTarget(target); |
| |
| // fix me: Skipped the error code |
| // Since we're caching a CollationElementIterator, recreate it |
| iter->setText(*target, status); |
| } |
| void StringSearch::setTarget(const UnicodeString& newText) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| SearchIterator::setTarget(newText); |
| // Since we're caching a CollationElementIterator, recreate it |
| iter->setText(newText, status); |
| } |
| |
| void StringSearch::reset(void) |
| { |
| SearchIterator::reset(); |
| iter->reset(); |
| }//------------------------------------------------------------------- |
| // Privates |
| //------------------------------------------------------------------- |
| |
| /** |
| * Search forward for matching text, starting at a given location. |
| * Clients should not call this method directly; instead they should call |
| * {@link SearchIterator#next}. |
| * <p> |
| * If a match is found, this method returns the index at which the match |
| * starts and calls {@link SearchIterator#setMatchLength} |
| * with the number of characters in the target |
| * text that make up the match. If no match is found, the method returns |
| * <code>DONE</code> and does not call <tt>setMatchLength</tt>. |
| * <p> |
| * @param start The index in the target text at which the search starts. |
| * |
| * @return The index at which the matched text in the target starts, or DONE |
| * if no match was found. |
| * <p> |
| * @see SearchIterator#next |
| * @see SearchIterator#DONE |
| */ |
| int32_t StringSearch::handleNext(int32_t start, UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| { |
| return SearchIterator::DONE; |
| } |
| const CharacterIterator& target = getTarget(); |
| |
| int mask = getMask(strength); |
| |
| #if 0 |
| int done = CollationElementIterator::NULLORDER & mask; |
| if (DEBUG) { |
| debug("-------------------------handleNext-----------------------------------"); |
| debug(""); |
| debug("strength=" + strength + ", mask=" + Integer.toString(mask,16) |
| + ", done=" + Integer.toString(done,16)); |
| debug("decomp=" + collator.getDecomposition()); |
| |
| debug("target.begin=" + getTarget().getBeginIndex()); |
| debug("target.end=" + getTarget().getEndIndex()); |
| debug("start = " + start); |
| } |
| #endif |
| int32_t index = start + minLen; |
| int32_t matchEnd = 0; |
| |
| while (index <= target.endIndex()) |
| { |
| int32_t patIndex = normLen; |
| int32_t tval = 0, pval = 0; |
| UBool getP = TRUE; |
| |
| iter->setOffset(index, status); |
| matchEnd = index; |
| |
| //if (DEBUG) debug(" outer loop: patIndex=" + patIndex + ", index=" + index); |
| |
| while ((patIndex > 0 || getP == false) && iter->getOffset() > start) |
| { |
| #if 0 |
| if (DEBUG) { |
| debug(" inner loop: patIndex=" + patIndex + " iter=" + iter.getOffset()); |
| debug(" getP=" + getP); |
| } |
| #endif |
| |
| // Get the previous character in both the pattern and the target |
| tval = iter->previous(status) & mask; |
| if (U_FAILURE(status)) |
| { |
| return SearchIterator::DONE; |
| } |
| |
| if (getP) pval = valueList[--patIndex]; |
| getP = TRUE; |
| |
| // (DEBUG) debug(" pval=" + Integer.toString(pval,16) + ", tval=" + Integer.toString(tval,16)); |
| |
| if (tval == 0) { // skip tval, use same pval |
| // (DEBUG) debug(" tval is ignorable"); |
| getP = FALSE; |
| } |
| else if (pval != tval) { // Mismatch, skip ahead |
| // (DEBUG) debug(" mismatch: skippping " + getShift(tval, patIndex)); |
| |
| index += getShift(tval, patIndex); |
| break; |
| } |
| else if (patIndex == 0) { |
| // The values matched, and we're at the beginning of the pattern, |
| // which means we matched the whole thing. |
| start = iter->getOffset(); |
| setMatchLength(matchEnd - start); |
| // if (DEBUG) debug("Found match at index "+ start ); |
| return start; |
| } |
| } |
| #if 0 |
| if (DEBUG) debug(" end of inner loop: patIndex=" + patIndex + " iter=" + iter.getOffset()); |
| if (DEBUG) debug(" getP=" + getP); |
| #endif |
| if (iter->getOffset() <= start) { |
| // We hit the beginning of the text being searched, which is |
| // possible if it contains lots of ignorable characters. |
| // Advance one character and try again. |
| // if (DEBUG) debug("hit beginning of target; advance by one"); |
| index++; |
| } |
| } |
| // if (DEBUG) debug("Fell off end of outer loop; returning DONE"); |
| return SearchIterator::DONE; |
| } |
| |
| /** |
| * Search backward for matching text ,starting at a given location. |
| * Clients should not call this method directly; instead they should call |
| * <code>SearchIterator.previous()</code>, which this method overrides. |
| * <p> |
| * If a match is found, this method returns the index at which the match |
| * starts and calls {@link SearchIterator#setMatchLength} |
| * with the number of characters in the target |
| * text that make up the match. If no match is found, the method returns |
| * <code>DONE</code> and does not call <tt>setMatchLength</tt>. |
| * <p> |
| * @param start The index in the target text at which the search starts. |
| * |
| * @return The index at which the matched text in the target starts, or DONE |
| * if no match was found. |
| * <p> |
| * @see SearchIterator#previous |
| * @see SearchIterator#DONE |
| */ |
| int32_t StringSearch::handlePrev(int32_t start, UErrorCode& status) |
| { |
| if (U_FAILURE(status)) |
| { |
| return SearchIterator::DONE; |
| } |
| int patLen = normLen; |
| int index = start - minLen; |
| |
| int mask = getMask(strength); |
| int done = CollationElementIterator::NULLORDER & mask; |
| #if 0 |
| if (DEBUG) { |
| debug("-------------------------handlePrev-----------------------------------"); |
| debug(""); |
| debug("strength=" + strength + ", mask=" + Integer.toString(mask,16) |
| + ", done=" + Integer.toString(done,16)); |
| debug("decomp=" + collator.getDecomposition()); |
| |
| debug("target.begin=" + getTarget().getBeginIndex()); |
| debug("target.end=" + getTarget().getEndIndex()); |
| } |
| #endif |
| |
| while (index >= 0) { |
| int patIndex = 0; |
| int tval = 0, pval = 0; |
| UBool getP = TRUE; |
| |
| iter->setOffset(index, status); |
| if (U_FAILURE(status)) |
| { |
| return SearchIterator::DONE; |
| } |
| |
| |
| // if (DEBUG) debug(" outer loop: patIndex=" + patIndex + ", index=" + index); |
| |
| while ((patIndex < patLen || !getP) && iter->getOffset() < start) |
| { |
| /* if (DEBUG) { |
| debug(" inner loop: patIndex=" + patIndex + " iter=" + iter.getOffset()); |
| } |
| */ |
| tval = iter->next(status) & mask; |
| if (U_FAILURE(status)) |
| { |
| return SearchIterator::DONE; |
| } |
| if (getP) pval = valueList[patIndex++]; |
| getP = TRUE; |
| |
| //if (DEBUG) debug(" pval=" + Integer.toString(pval,16) + ", tval=" + Integer.toString(tval,16)); |
| |
| if (tval == done) { |
| // if (DEBUG) debug(" end of target; no match"); |
| return DONE; |
| } |
| else if (tval == 0) { |
| // if (DEBUG) debug(" tval is ignorable"); |
| getP = false; |
| } |
| else if (pval != tval) { |
| // We didn't match this pattern. Skip ahead |
| // if (DEBUG) debug(" mismatch: skippping " + getBackShift(tval, patIndex)); |
| |
| int shift = getBackShift(tval, patIndex); |
| index -= shift; |
| break; |
| } |
| else if (patIndex == patLen) { |
| // The elements matched and we're at the end of the pattern, |
| // which means we matched the whole thing. |
| setMatchLength(iter->getOffset() - index); |
| return index; |
| } |
| } |
| if (iter->getOffset() >= start) { |
| // We hit the end of the text being searched, which is |
| // possible if it contains lots of ignorable characters. |
| // Back up one character and try again. |
| // if (DEBUG) debug("hit end of target; back by one"); |
| index--; |
| } |
| } |
| return SearchIterator::DONE; |
| } |
| |
| /** |
| * Return a bitmask that will select only the portions of a collation |
| * element that are significant at the given strength level. |
| */ |
| int32_t StringSearch::getMask(Collator::ECollationStrength strength) |
| { |
| switch (strength) { |
| case Collator::PRIMARY: |
| return 0xFFFF0000; |
| case Collator::SECONDARY: |
| return 0xFFFFFF00; |
| default: |
| return 0xFFFFFFFF; |
| } |
| } |
| |
| |
| void StringSearch::initialize(UErrorCode& status) { |
| /* |
| if (DEBUG) { |
| debug("-------------------------initialize-----------------------------------"); |
| debug("pattern=" + pattern); |
| } |
| */ |
| it->setText(pattern, status); |
| if (U_FAILURE(status)) { |
| delete it; |
| return; |
| } |
| |
| int mask = getMask(strength); |
| |
| // See how many non-ignorable collation keys are in the text |
| normLen = 0; |
| int32_t elem; |
| while ((elem = it->next(status)) != CollationElementIterator::NULLORDER) |
| { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if ((elem & mask) != 0) { |
| normLen++; |
| } |
| } |
| |
| if (valueList != NULL) { |
| delete [] valueList; |
| } |
| |
| // Save them all |
| valueList = new int32_t[normLen]; |
| int expandLen = 0; |
| it->reset(); |
| |
| int32_t i; |
| for (i = 0; i < normLen; i++) |
| { |
| elem = it->next(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| if ((elem & mask) != 0) { |
| valueList[i] = elem & mask; |
| |
| } |
| // Keep track of whether there are any expanding-character |
| // sequences that can result in one of the characters that's in |
| // the pattern. If there are, we have to reduce the shift |
| // distances calculated below to account for it. |
| expandLen += it->getMaxExpansion(elem) - 1; |
| } |
| |
| // |
| // We need to remember the size of the composed and decomposed |
| // versions of the string. Standard Boyer-Moore shift calculations |
| // can be wrong by an amount up to that difference, since a small |
| // small number of characters in the pattern can map to a larger |
| // number in the text being searched, or vice-versa. |
| // |
| int uniLen = pattern.length(); |
| maxLen = uprv_max(normLen, uniLen); |
| minLen = uprv_min(normLen, uniLen) - expandLen; |
| |
| |
| /* |
| if (DEBUG) debug("normLen=" + normLen + ", expandLen=" + expandLen |
| + ", maxLen=" + maxLen + ", minLen=" + minLen); |
| */ |
| // Now initialize the shift tables |
| // |
| // NOTE: This is the most conservative way to build them. If we had a way |
| // of knowing that there were no expanding/contracting chars in the rules, |
| // we could get rid of the "- 1" in the shiftTable calculations. |
| // But all of the default collators have at least one expansion or |
| // contraction, so it probably doesn't matter anyway. |
| // |
| for (i = 0; i < 256; i++) { |
| shiftTable[i] = backShiftTable[i] = minLen; |
| } |
| |
| for (i = 0; i < normLen-1; i++) { |
| shiftTable[hash(valueList[i])] = uprv_max(minLen - i - 1, 1); |
| } |
| shiftTable[hash(valueList[normLen-1])] = 1; |
| |
| for (i = normLen - 1; i > 0; i--) { |
| backShiftTable[hash(valueList[i])] = i; |
| } |
| backShiftTable[hash(valueList[0])] = 1; |
| |
| /* dumpTables(); */ |
| } |
| |
| /** |
| * Method used by StringSearch to determine how far to the right to |
| * shift the pattern during a Boyer-Moore search. |
| * |
| * @param curValue The current value in the target text |
| * @param curIndex The index in the pattern at which we failed to match |
| * curValue in the target text. |
| */ |
| int32_t StringSearch::getShift( int32_t curValue, int32_t curIndex ) const |
| { |
| int32_t shiftAmt = shiftTable[hash(curValue)]; |
| |
| if (minLen != maxLen) { |
| int adjust = normLen - curIndex; |
| if (shiftAmt > adjust + 1) { |
| // if (DEBUG) debug("getShift: adjusting by " + adjust); |
| shiftAmt -= adjust; |
| } |
| } |
| return shiftAmt; |
| } |
| |
| /** |
| * Method used by StringSearch to determine how far to the left to |
| * shift the pattern during a reverse Boyer-Moore search. |
| * |
| * @param curValue The current value in the target text |
| * @param curIndex The index in the pattern at which we failed to match |
| * curValue in the target text. |
| */ |
| int32_t StringSearch::getBackShift( int32_t curValue, int32_t curIndex ) const |
| { |
| int shiftAmt = backShiftTable[hash(curValue)]; |
| |
| if (minLen != maxLen) { |
| int adjust = normLen - (minLen - curIndex); |
| if (shiftAmt > adjust + 1) { |
| // if (DEBUG) debug("getBackShift: adjusting by " + adjust); |
| shiftAmt -= adjust; |
| } |
| } |
| return shiftAmt; |
| } |
| |
| /** |
| * Hash a collation element from its full size (32 bits) down into a |
| * value that can be used as an index into the shift tables. Right |
| * now we do a modulus by the size of the hash table. |
| * |
| * TODO: At some point I should experiment to see whether a slightly |
| * more complicated hash function gives us a better distribution |
| * on multilingual text. I doubt it will have much effect on |
| * performance, though. |
| */ |
| int32_t StringSearch::hash(int32_t order) |
| { |
| return CollationElementIterator::primaryOrder(order) % 256; |
| } |
| |
| |
| |
| |
