int32_t StringSearch::handleNext(int32_t position, UErrorCode &status) { // values passed here are already in the pre-shift position if (U_SUCCESS(status)) { if (m_strsrch_->pattern.CELength == 0) { m_search_->matchedIndex = m_search_->matchedIndex == USEARCH_DONE ? getOffset() : m_search_->matchedIndex + 1; m_search_->matchedLength = 0; ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status); if (m_search_->matchedIndex == m_search_->textLength) { m_search_->matchedIndex = USEARCH_DONE; } } else { // looking at usearch.cpp, this part is shifted out to // StringSearch instead of SearchIterator because m_strsrch_ is // not accessible in SearchIterator if (position + m_strsrch_->pattern.defaultShiftSize > m_search_->textLength) { setMatchNotFound(); return USEARCH_DONE; } ucol_setOffset(m_strsrch_->textIter, position, &status); while (TRUE) { if (m_search_->isCanonicalMatch) { // can't use exact here since extra accents are allowed. usearch_handleNextCanonical(m_strsrch_, &status); } else { usearch_handleNextExact(m_strsrch_, &status); } if (U_FAILURE(status)) { return USEARCH_DONE; } if (m_breakiterator_ == NULL #if !UCONFIG_NO_BREAK_ITERATION || m_search_->matchedIndex == USEARCH_DONE || (m_breakiterator_->isBoundary(m_search_->matchedIndex) && m_breakiterator_->isBoundary(m_search_->matchedIndex + m_search_->matchedLength)) #endif ) { if (m_search_->matchedIndex == USEARCH_DONE) { ucol_setOffset(m_strsrch_->textIter, m_search_->textLength, &status); } else { ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status); } return m_search_->matchedIndex; } } } } return USEARCH_DONE; }
//static void NativeCollation_setOffset(JNIEnv* env, jclass, jint address, jint offset) { JNIEXPORT void JNICALL Java_com_ibm_icu4jni_text_NativeCollation_setOffset(JNIEnv* env, jclass, jint address, jint offset) { UErrorCode status = U_ZERO_ERROR; ucol_setOffset(toCollationElements(address), offset, &status); icu4jni_error(env, status); }
void Target::setOffset(int32_t offset) { UErrorCode status = U_ZERO_ERROR; bufferMin = 0; bufferMax = 0; ucol_setOffset(elements, offset, &status); }
void Target::setLast(int32_t last) { UErrorCode status = U_ZERO_ERROR; bufferMin = 0; bufferMax = 1; ceb[0].order = UCOL_NULLORDER; ceb[0].lowOffset = last; ceb[0].highOffset = last; ucol_setOffset(elements, last, &status); }
OrderList::OrderList(UCollator *coll, const UnicodeString &string, int32_t stringOffset) : list(NULL), listMax(16), listSize(0) { UErrorCode status = U_ZERO_ERROR; UCollationElements *elems = ucol_openElements(coll, string.getBuffer(), string.length(), &status); uint32_t strengthMask = 0; int32_t order, low, high; switch (ucol_getStrength(coll)) { default: strengthMask |= UCOL_TERTIARYORDERMASK; /* fall through */ case UCOL_SECONDARY: strengthMask |= UCOL_SECONDARYORDERMASK; /* fall through */ case UCOL_PRIMARY: strengthMask |= UCOL_PRIMARYORDERMASK; } list = new Order[listMax]; ucol_setOffset(elems, stringOffset, &status); do { low = ucol_getOffset(elems); order = ucol_next(elems, &status); high = ucol_getOffset(elems); if (order != UCOL_NULLORDER) { order &= strengthMask; } if (order != UCOL_IGNORABLE) { add(order, low, high); } } while (order != UCOL_NULLORDER); ucol_closeElements(elems); }
void CollationElementIterator::setOffset(int32_t newOffset, UErrorCode& status) { ucol_setOffset(m_data_, newOffset, &status); }
static void NativeCollation_setOffset(JNIEnv* env, jclass, jlong address, jint offset) { UErrorCode status = U_ZERO_ERROR; ucol_setOffset(toCollationElements(address), offset, &status); maybeThrowIcuException(env, "ucol_setOffset", status); }
int32_t StringSearch::handlePrev(int32_t position, UErrorCode &status) { // values passed here are already in the pre-shift position if (U_SUCCESS(status)) { if (m_strsrch_->pattern.cesLength == 0) { m_search_->matchedIndex = (m_search_->matchedIndex == USEARCH_DONE ? getOffset() : m_search_->matchedIndex); if (m_search_->matchedIndex == 0) { setMatchNotFound(); } else { m_search_->matchedIndex --; ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status); m_search_->matchedLength = 0; } } else { // looking at usearch.cpp, this part is shifted out to // StringSearch instead of SearchIterator because m_strsrch_ is // not accessible in SearchIterator #if 0 if (!m_search_->isOverlap && position - m_strsrch_->pattern.defaultShiftSize < 0) { setMatchNotFound(); return USEARCH_DONE; } for (;;) { if (m_search_->isCanonicalMatch) { // can't use exact here since extra accents are allowed. usearch_handlePreviousCanonical(m_strsrch_, &status); } else { usearch_handlePreviousExact(m_strsrch_, &status); } if (U_FAILURE(status)) { return USEARCH_DONE; } if (m_breakiterator_ == NULL #if !UCONFIG_NO_BREAK_ITERATION || m_search_->matchedIndex == USEARCH_DONE || (m_breakiterator_->isBoundary(m_search_->matchedIndex) && m_breakiterator_->isBoundary(m_search_->matchedIndex + m_search_->matchedLength)) #endif ) { return m_search_->matchedIndex; } } #else ucol_setOffset(m_strsrch_->textIter, position, &status); if (m_search_->isCanonicalMatch) { // *could* use exact match here since extra accents *not* allowed! usearch_handlePreviousCanonical(m_strsrch_, &status); } else { usearch_handlePreviousExact(m_strsrch_, &status); } if (U_FAILURE(status)) { return USEARCH_DONE; } return m_search_->matchedIndex; #endif } return m_search_->matchedIndex; } return USEARCH_DONE; }
int32_t StringSearch::handleNext(int32_t position, UErrorCode &status) { // values passed here are already in the pre-shift position if (U_SUCCESS(status)) { if (m_strsrch_->pattern.cesLength == 0) { m_search_->matchedIndex = m_search_->matchedIndex == USEARCH_DONE ? getOffset() : m_search_->matchedIndex + 1; m_search_->matchedLength = 0; ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status); if (m_search_->matchedIndex == m_search_->textLength) { m_search_->matchedIndex = USEARCH_DONE; } } else { // looking at usearch.cpp, this part is shifted out to // StringSearch instead of SearchIterator because m_strsrch_ is // not accessible in SearchIterator #if 0 if (position + m_strsrch_->pattern.defaultShiftSize > m_search_->textLength) { setMatchNotFound(); return USEARCH_DONE; } #endif if (m_search_->matchedLength <= 0) { // the flipping direction issue has already been handled // in next() // for boundary check purposes. this will ensure that the // next match will not preceed the current offset // note search->matchedIndex will always be set to something // in the code m_search_->matchedIndex = position - 1; } ucol_setOffset(m_strsrch_->textIter, position, &status); #if 0 for (;;) { if (m_search_->isCanonicalMatch) { // can't use exact here since extra accents are allowed. usearch_handleNextCanonical(m_strsrch_, &status); } else { usearch_handleNextExact(m_strsrch_, &status); } if (U_FAILURE(status)) { return USEARCH_DONE; } if (m_breakiterator_ == NULL #if !UCONFIG_NO_BREAK_ITERATION || m_search_->matchedIndex == USEARCH_DONE || (m_breakiterator_->isBoundary(m_search_->matchedIndex) && m_breakiterator_->isBoundary(m_search_->matchedIndex + m_search_->matchedLength)) #endif ) { if (m_search_->matchedIndex == USEARCH_DONE) { ucol_setOffset(m_strsrch_->textIter, m_search_->textLength, &status); } else { ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status); } return m_search_->matchedIndex; } } #else // if m_strsrch_->breakIter is always the same as m_breakiterator_ // then we don't need to check the match boundaries here because // usearch_handleNextXXX will already have done it. if (m_search_->isCanonicalMatch) { // *could* actually use exact here 'cause no extra accents allowed... usearch_handleNextCanonical(m_strsrch_, &status); } else { usearch_handleNextExact(m_strsrch_, &status); } if (U_FAILURE(status)) { return USEARCH_DONE; } if (m_search_->matchedIndex == USEARCH_DONE) { ucol_setOffset(m_strsrch_->textIter, m_search_->textLength, &status); } else { ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status); } return m_search_->matchedIndex; #endif } } return USEARCH_DONE; }
static void NativeCollation_setOffset(JNIEnv* env, jclass, jint address, jint offset) { UErrorCode status = U_ZERO_ERROR; ucol_setOffset(toCollationElements(address), offset, &status); icu4jni_error(env, status); }
static void TestBug672() { UErrorCode status = U_ZERO_ERROR; UChar pattern[20]; UChar text[50]; int i; int result[3][3]; u_uastrcpy(pattern, "resume"); u_uastrcpy(text, "Time to resume updating my resume."); for (i = 0; i < 3; ++ i) { UCollator *coll = ucol_open(LOCALES[i], &status); UCollationElements *pitr = ucol_openElements(coll, pattern, -1, &status); UCollationElements *titer = ucol_openElements(coll, text, -1, &status); if (U_FAILURE(status)) { log_err_status(status, "ERROR: in creation of either the collator or the collation iterator :%s\n", myErrorName(status)); return; } log_verbose("locale tested %s\n", LOCALES[i]); while (ucol_next(pitr, &status) != UCOL_NULLORDER && U_SUCCESS(status)) { } if (U_FAILURE(status)) { log_err("ERROR: reversing collation iterator :%s\n", myErrorName(status)); return; } ucol_reset(pitr); ucol_setOffset(titer, u_strlen(pattern), &status); if (U_FAILURE(status)) { log_err("ERROR: setting offset in collator :%s\n", myErrorName(status)); return; } result[i][0] = ucol_getOffset(titer); log_verbose("Text iterator set to offset %d\n", result[i][0]); /* Use previous() */ ucol_previous(titer, &status); result[i][1] = ucol_getOffset(titer); log_verbose("Current offset %d after previous\n", result[i][1]); /* Add one to index */ log_verbose("Adding one to current offset...\n"); ucol_setOffset(titer, ucol_getOffset(titer) + 1, &status); if (U_FAILURE(status)) { log_err("ERROR: setting offset in collator :%s\n", myErrorName(status)); return; } result[i][2] = ucol_getOffset(titer); log_verbose("Current offset in text = %d\n", result[i][2]); ucol_closeElements(pitr); ucol_closeElements(titer); ucol_close(coll); } if (uprv_memcmp(result[0], result[1], 3) != 0 || uprv_memcmp(result[1], result[2], 3) != 0) { log_err("ERROR: Different locales have different offsets at the same character\n"); } }
/** * Test for getOffset() and setOffset() */ static void TestOffset() { UErrorCode status= U_ZERO_ERROR; UCollator *en_us=NULL; UCollationElements *iter, *pristine; int32_t offset; OrderAndOffset *orders; int32_t orderLength=0; int count = 0; UChar test1[50]; UChar test2[50]; u_uastrcpy(test1, "What subset of all possible test cases?"); u_uastrcpy(test2, "has the highest probability of detecting"); en_us = ucol_open("en_US", &status); log_verbose("Testing getOffset and setOffset for collations\n"); iter = ucol_openElements(en_us, test1, u_strlen(test1), &status); if(U_FAILURE(status)){ log_err_status(status, "ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(en_us); return; } /* testing boundaries */ ucol_setOffset(iter, 0, &status); if (U_FAILURE(status) || ucol_previous(iter, &status) != UCOL_NULLORDER) { log_err("Error: After setting offset to 0, we should be at the end " "of the backwards iteration"); } ucol_setOffset(iter, u_strlen(test1), &status); if (U_FAILURE(status) || ucol_next(iter, &status) != UCOL_NULLORDER) { log_err("Error: After setting offset to end of the string, we should " "be at the end of the backwards iteration"); } /* Run all the way through the iterator, then get the offset */ orders = getOrders(iter, &orderLength); offset = ucol_getOffset(iter); if (offset != u_strlen(test1)) { log_err("offset at end != length %d vs %d\n", offset, u_strlen(test1) ); } /* Now set the offset back to the beginning and see if it works */ pristine=ucol_openElements(en_us, test1, u_strlen(test1), &status); if(U_FAILURE(status)){ log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(en_us); return; } status = U_ZERO_ERROR; ucol_setOffset(iter, 0, &status); if (U_FAILURE(status)) { log_err("setOffset failed. %s\n", myErrorName(status)); } else { assertEqual(iter, pristine); } ucol_closeElements(pristine); ucol_closeElements(iter); free(orders); /* testing offsets in normalization buffer */ test1[0] = 0x61; test1[1] = 0x300; test1[2] = 0x316; test1[3] = 0x62; test1[4] = 0; ucol_setAttribute(en_us, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); iter = ucol_openElements(en_us, test1, 4, &status); if(U_FAILURE(status)){ log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n", myErrorName(status)); ucol_close(en_us); return; } count = 0; while (ucol_next(iter, &status) != UCOL_NULLORDER && U_SUCCESS(status)) { switch (count) { case 0: if (ucol_getOffset(iter) != 1) { log_err("ERROR: Offset of iteration should be 1\n"); } break; case 3: if (ucol_getOffset(iter) != 4) { log_err("ERROR: Offset of iteration should be 4\n"); } break; default: if (ucol_getOffset(iter) != 3) { log_err("ERROR: Offset of iteration should be 3\n"); } } count ++; } ucol_reset(iter); count = 0; while (ucol_previous(iter, &status) != UCOL_NULLORDER && U_SUCCESS(status)) { switch (count) { case 0: case 1: if (ucol_getOffset(iter) != 3) { log_err("ERROR: Offset of iteration should be 3\n"); } break; case 2: if (ucol_getOffset(iter) != 1) { log_err("ERROR: Offset of iteration should be 1\n"); } break; default: if (ucol_getOffset(iter) != 0) { log_err("ERROR: Offset of iteration should be 0\n"); } } count ++; } if(U_FAILURE(status)){ log_err("ERROR: in iterating collation elements %s\n", myErrorName(status)); } ucol_closeElements(iter); ucol_close(en_us); }
static void TestSearchCollatorElements(void) { const TSCEItem * tsceItemPtr; for (tsceItemPtr = tsceItems; tsceItemPtr->locale != NULL; tsceItemPtr++) { UErrorCode status = U_ZERO_ERROR; UCollator* ucol = ucol_open(tsceItemPtr->locale, &status); if ( U_SUCCESS(status) ) { UCollationElements * uce = ucol_openElements(ucol, tsceText, kLen_tsceText, &status); if ( U_SUCCESS(status) ) { int32_t offset, element; const int32_t * nextOffsetPtr; const int32_t * limitOffsetPtr; nextOffsetPtr = tsceItemPtr->offsets; limitOffsetPtr = tsceItemPtr->offsets + tsceItemPtr->offsetsLen; do { offset = ucol_getOffset(uce); element = ucol_next(uce, &status); log_verbose("(%s) offset=%2d ce=%08x\n", tsceItemPtr->locale, offset, element); if ( element == 0 ) { log_err("error, locale %s, ucol_next returned element 0\n", tsceItemPtr->locale ); } if ( nextOffsetPtr < limitOffsetPtr ) { if (offset != *nextOffsetPtr) { log_err("error, locale %s, expected ucol_next -> ucol_getOffset %d, got %d\n", tsceItemPtr->locale, *nextOffsetPtr, offset ); nextOffsetPtr = limitOffsetPtr; break; } nextOffsetPtr++; } else { log_err("error, locale %s, ucol_next returned more elements than expected\n", tsceItemPtr->locale ); } } while ( U_SUCCESS(status) && element != UCOL_NULLORDER ); if ( nextOffsetPtr < limitOffsetPtr ) { log_err("error, locale %s, ucol_next returned fewer elements than expected\n", tsceItemPtr->locale ); } ucol_setOffset(uce, kLen_tsceText, &status); status = U_ZERO_ERROR; nextOffsetPtr = tsceItemPtr->offsets + tsceItemPtr->offsetsLen; limitOffsetPtr = tsceItemPtr->offsets; do { offset = ucol_getOffset(uce); element = ucol_previous(uce, &status); if ( element == 0 ) { log_err("error, locale %s, ucol_previous returned element 0\n", tsceItemPtr->locale ); } if ( nextOffsetPtr > limitOffsetPtr ) { nextOffsetPtr--; if (offset != *nextOffsetPtr) { log_err("error, locale %s, expected ucol_previous -> ucol_getOffset %d, got %d\n", tsceItemPtr->locale, *nextOffsetPtr, offset ); nextOffsetPtr = limitOffsetPtr; break; } } else { log_err("error, locale %s, ucol_previous returned more elements than expected\n", tsceItemPtr->locale ); } } while ( U_SUCCESS(status) && element != UCOL_NULLORDER ); if ( nextOffsetPtr > limitOffsetPtr ) { log_err("error, locale %s, ucol_previous returned fewer elements than expected\n", tsceItemPtr->locale ); } ucol_closeElements(uce); } else { log_err("error, locale %s, ucol_openElements failed: %s\n", tsceItemPtr->locale, u_errorName(status) ); } ucol_close(ucol); } else { log_data_err("error, locale %s, ucol_open failed: %s\n", tsceItemPtr->locale, u_errorName(status) ); } } }