1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ********************************************************************** 5 * Copyright (C) 2001-2014 IBM and others. All rights reserved. 6 ********************************************************************** 7 * Date Name Description 8 * 03/22/2000 helena Creation. 9 ********************************************************************** 10 */ 11 12 #include "unicode/utypes.h" 13 14 #if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION 15 16 #include "unicode/stsearch.h" 17 #include "usrchimp.h" 18 #include "cmemory.h" 19 20 U_NAMESPACE_BEGIN 21 22 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringSearch) 23 24 // public constructors and destructors ----------------------------------- 25 26 StringSearch::StringSearch(const UnicodeString &pattern, 27 const UnicodeString &text, 28 const Locale &locale, 29 BreakIterator *breakiter, 30 UErrorCode &status) : 31 SearchIterator(text, breakiter), 32 m_pattern_(pattern) 33 { 34 if (U_FAILURE(status)) { 35 m_strsrch_ = NULL; 36 return; 37 } 38 39 m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(), 40 m_text_.getBuffer(), m_text_.length(), 41 locale.getName(), (UBreakIterator *)breakiter, 42 &status); 43 uprv_free(m_search_); 44 m_search_ = NULL; 45 46 if (U_SUCCESS(status)) { 47 // m_search_ has been created by the base SearchIterator class 48 m_search_ = m_strsrch_->search; 49 } 50 } 51 52 StringSearch::StringSearch(const UnicodeString &pattern, 53 const UnicodeString &text, 54 RuleBasedCollator *coll, 55 BreakIterator *breakiter, 56 UErrorCode &status) : 57 SearchIterator(text, breakiter), 58 m_pattern_(pattern) 59 { 60 if (U_FAILURE(status)) { 61 m_strsrch_ = NULL; 62 return; 63 } 64 if (coll == NULL) { 65 status = U_ILLEGAL_ARGUMENT_ERROR; 66 m_strsrch_ = NULL; 67 return; 68 } 69 m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(), 70 m_pattern_.length(), 71 m_text_.getBuffer(), 72 m_text_.length(), coll->toUCollator(), 73 (UBreakIterator *)breakiter, 74 &status); 75 uprv_free(m_search_); 76 m_search_ = NULL; 77 78 if (U_SUCCESS(status)) { 79 // m_search_ has been created by the base SearchIterator class 80 m_search_ = m_strsrch_->search; 81 } 82 } 83 84 StringSearch::StringSearch(const UnicodeString &pattern, 85 CharacterIterator &text, 86 const Locale &locale, 87 BreakIterator *breakiter, 88 UErrorCode &status) : 89 SearchIterator(text, breakiter), 90 m_pattern_(pattern) 91 { 92 if (U_FAILURE(status)) { 93 m_strsrch_ = NULL; 94 return; 95 } 96 m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(), 97 m_text_.getBuffer(), m_text_.length(), 98 locale.getName(), (UBreakIterator *)breakiter, 99 &status); 100 uprv_free(m_search_); 101 m_search_ = NULL; 102 103 if (U_SUCCESS(status)) { 104 // m_search_ has been created by the base SearchIterator class 105 m_search_ = m_strsrch_->search; 106 } 107 } 108 109 StringSearch::StringSearch(const UnicodeString &pattern, 110 CharacterIterator &text, 111 RuleBasedCollator *coll, 112 BreakIterator *breakiter, 113 UErrorCode &status) : 114 SearchIterator(text, breakiter), 115 m_pattern_(pattern) 116 { 117 if (U_FAILURE(status)) { 118 m_strsrch_ = NULL; 119 return; 120 } 121 if (coll == NULL) { 122 status = U_ILLEGAL_ARGUMENT_ERROR; 123 m_strsrch_ = NULL; 124 return; 125 } 126 m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(), 127 m_pattern_.length(), 128 m_text_.getBuffer(), 129 m_text_.length(), coll->toUCollator(), 130 (UBreakIterator *)breakiter, 131 &status); 132 uprv_free(m_search_); 133 m_search_ = NULL; 134 135 if (U_SUCCESS(status)) { 136 // m_search_ has been created by the base SearchIterator class 137 m_search_ = m_strsrch_->search; 138 } 139 } 140 141 StringSearch::StringSearch(const StringSearch &that) : 142 SearchIterator(that.m_text_, that.m_breakiterator_), 143 m_pattern_(that.m_pattern_) 144 { 145 UErrorCode status = U_ZERO_ERROR; 146 147 // Free m_search_ from the superclass 148 uprv_free(m_search_); 149 m_search_ = NULL; 150 151 if (that.m_strsrch_ == NULL) { 152 // This was not a good copy 153 m_strsrch_ = NULL; 154 } 155 else { 156 // Make a deep copy 157 m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(), 158 m_pattern_.length(), 159 m_text_.getBuffer(), 160 m_text_.length(), 161 that.m_strsrch_->collator, 162 (UBreakIterator *)that.m_breakiterator_, 163 &status); 164 if (U_SUCCESS(status)) { 165 // m_search_ has been created by the base SearchIterator class 166 m_search_ = m_strsrch_->search; 167 } 168 } 169 } 170 171 StringSearch::~StringSearch() 172 { 173 if (m_strsrch_ != NULL) { 174 usearch_close(m_strsrch_); 175 m_search_ = NULL; 176 } 177 } 178 179 StringSearch * 180 StringSearch::clone() const { 181 return new StringSearch(*this); 182 } 183 184 // operator overloading --------------------------------------------- 185 StringSearch & StringSearch::operator=(const StringSearch &that) 186 { 187 if ((*this) != that) { 188 UErrorCode status = U_ZERO_ERROR; 189 m_text_ = that.m_text_; 190 m_breakiterator_ = that.m_breakiterator_; 191 m_pattern_ = that.m_pattern_; 192 // all m_search_ in the parent class is linked up with m_strsrch_ 193 usearch_close(m_strsrch_); 194 m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(), 195 m_pattern_.length(), 196 m_text_.getBuffer(), 197 m_text_.length(), 198 that.m_strsrch_->collator, 199 NULL, &status); 200 // Check null pointer 201 if (m_strsrch_ != NULL) { 202 m_search_ = m_strsrch_->search; 203 } 204 } 205 return *this; 206 } 207 208 UBool StringSearch::operator==(const SearchIterator &that) const 209 { 210 if (this == &that) { 211 return TRUE; 212 } 213 if (SearchIterator::operator ==(that)) { 214 StringSearch &thatsrch = (StringSearch &)that; 215 return (this->m_pattern_ == thatsrch.m_pattern_ && 216 this->m_strsrch_->collator == thatsrch.m_strsrch_->collator); 217 } 218 return FALSE; 219 } 220 221 // public get and set methods ---------------------------------------- 222 223 void StringSearch::setOffset(int32_t position, UErrorCode &status) 224 { 225 // status checked in usearch_setOffset 226 usearch_setOffset(m_strsrch_, position, &status); 227 } 228 229 int32_t StringSearch::getOffset(void) const 230 { 231 return usearch_getOffset(m_strsrch_); 232 } 233 234 void StringSearch::setText(const UnicodeString &text, UErrorCode &status) 235 { 236 if (U_SUCCESS(status)) { 237 m_text_ = text; 238 usearch_setText(m_strsrch_, text.getBuffer(), text.length(), &status); 239 } 240 } 241 242 void StringSearch::setText(CharacterIterator &text, UErrorCode &status) 243 { 244 if (U_SUCCESS(status)) { 245 text.getText(m_text_); 246 usearch_setText(m_strsrch_, m_text_.getBuffer(), m_text_.length(), &status); 247 } 248 } 249 250 RuleBasedCollator * StringSearch::getCollator() const 251 { 252 // Note the const_cast. It would be cleaner if this const method returned a const collator. 253 return RuleBasedCollator::rbcFromUCollator(const_cast<UCollator *>(m_strsrch_->collator)); 254 } 255 256 void StringSearch::setCollator(RuleBasedCollator *coll, UErrorCode &status) 257 { 258 if (U_SUCCESS(status)) { 259 usearch_setCollator(m_strsrch_, coll->toUCollator(), &status); 260 } 261 } 262 263 void StringSearch::setPattern(const UnicodeString &pattern, 264 UErrorCode &status) 265 { 266 if (U_SUCCESS(status)) { 267 m_pattern_ = pattern; 268 usearch_setPattern(m_strsrch_, m_pattern_.getBuffer(), m_pattern_.length(), 269 &status); 270 } 271 } 272 273 const UnicodeString & StringSearch::getPattern() const 274 { 275 return m_pattern_; 276 } 277 278 // public methods ---------------------------------------------------- 279 280 void StringSearch::reset() 281 { 282 usearch_reset(m_strsrch_); 283 } 284 285 SearchIterator * StringSearch::safeClone(void) const 286 { 287 UErrorCode status = U_ZERO_ERROR; 288 StringSearch *result = new StringSearch(m_pattern_, m_text_, 289 getCollator(), 290 m_breakiterator_, 291 status); 292 /* test for NULL */ 293 if (result == 0) { 294 status = U_MEMORY_ALLOCATION_ERROR; 295 return 0; 296 } 297 result->setOffset(getOffset(), status); 298 result->setMatchStart(m_strsrch_->search->matchedIndex); 299 result->setMatchLength(m_strsrch_->search->matchedLength); 300 if (U_FAILURE(status)) { 301 return NULL; 302 } 303 return result; 304 } 305 306 // protected method ------------------------------------------------- 307 308 int32_t StringSearch::handleNext(int32_t position, UErrorCode &status) 309 { 310 // values passed here are already in the pre-shift position 311 if (U_SUCCESS(status)) { 312 if (m_strsrch_->pattern.cesLength == 0) { 313 m_search_->matchedIndex = 314 m_search_->matchedIndex == USEARCH_DONE ? 315 getOffset() : m_search_->matchedIndex + 1; 316 m_search_->matchedLength = 0; 317 ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, 318 &status); 319 if (m_search_->matchedIndex == m_search_->textLength) { 320 m_search_->matchedIndex = USEARCH_DONE; 321 } 322 } 323 else { 324 // looking at usearch.cpp, this part is shifted out to 325 // StringSearch instead of SearchIterator because m_strsrch_ is 326 // not accessible in SearchIterator 327 #if 0 328 if (position + m_strsrch_->pattern.defaultShiftSize 329 > m_search_->textLength) { 330 setMatchNotFound(); 331 return USEARCH_DONE; 332 } 333 #endif 334 if (m_search_->matchedLength <= 0) { 335 // the flipping direction issue has already been handled 336 // in next() 337 // for boundary check purposes. this will ensure that the 338 // next match will not preceed the current offset 339 // note search->matchedIndex will always be set to something 340 // in the code 341 m_search_->matchedIndex = position - 1; 342 } 343 344 ucol_setOffset(m_strsrch_->textIter, position, &status); 345 346 #if 0 347 for (;;) { 348 if (m_search_->isCanonicalMatch) { 349 // can't use exact here since extra accents are allowed. 350 usearch_handleNextCanonical(m_strsrch_, &status); 351 } 352 else { 353 usearch_handleNextExact(m_strsrch_, &status); 354 } 355 if (U_FAILURE(status)) { 356 return USEARCH_DONE; 357 } 358 if (m_breakiterator_ == NULL 359 #if !UCONFIG_NO_BREAK_ITERATION 360 || 361 m_search_->matchedIndex == USEARCH_DONE || 362 (m_breakiterator_->isBoundary(m_search_->matchedIndex) && 363 m_breakiterator_->isBoundary(m_search_->matchedIndex + 364 m_search_->matchedLength)) 365 #endif 366 ) { 367 if (m_search_->matchedIndex == USEARCH_DONE) { 368 ucol_setOffset(m_strsrch_->textIter, 369 m_search_->textLength, &status); 370 } 371 else { 372 ucol_setOffset(m_strsrch_->textIter, 373 m_search_->matchedIndex, &status); 374 } 375 return m_search_->matchedIndex; 376 } 377 } 378 #else 379 // if m_strsrch_->breakIter is always the same as m_breakiterator_ 380 // then we don't need to check the match boundaries here because 381 // usearch_handleNextXXX will already have done it. 382 if (m_search_->isCanonicalMatch) { 383 // *could* actually use exact here 'cause no extra accents allowed... 384 usearch_handleNextCanonical(m_strsrch_, &status); 385 } else { 386 usearch_handleNextExact(m_strsrch_, &status); 387 } 388 389 if (U_FAILURE(status)) { 390 return USEARCH_DONE; 391 } 392 393 if (m_search_->matchedIndex == USEARCH_DONE) { 394 ucol_setOffset(m_strsrch_->textIter, m_search_->textLength, &status); 395 } else { 396 ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status); 397 } 398 399 return m_search_->matchedIndex; 400 #endif 401 } 402 } 403 return USEARCH_DONE; 404 } 405 406 int32_t StringSearch::handlePrev(int32_t position, UErrorCode &status) 407 { 408 // values passed here are already in the pre-shift position 409 if (U_SUCCESS(status)) { 410 if (m_strsrch_->pattern.cesLength == 0) { 411 m_search_->matchedIndex = 412 (m_search_->matchedIndex == USEARCH_DONE ? getOffset() : 413 m_search_->matchedIndex); 414 if (m_search_->matchedIndex == 0) { 415 setMatchNotFound(); 416 } 417 else { 418 m_search_->matchedIndex --; 419 ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, 420 &status); 421 m_search_->matchedLength = 0; 422 } 423 } 424 else { 425 // looking at usearch.cpp, this part is shifted out to 426 // StringSearch instead of SearchIterator because m_strsrch_ is 427 // not accessible in SearchIterator 428 #if 0 429 if (!m_search_->isOverlap && 430 position - m_strsrch_->pattern.defaultShiftSize < 0) { 431 setMatchNotFound(); 432 return USEARCH_DONE; 433 } 434 435 for (;;) { 436 if (m_search_->isCanonicalMatch) { 437 // can't use exact here since extra accents are allowed. 438 usearch_handlePreviousCanonical(m_strsrch_, &status); 439 } 440 else { 441 usearch_handlePreviousExact(m_strsrch_, &status); 442 } 443 if (U_FAILURE(status)) { 444 return USEARCH_DONE; 445 } 446 if (m_breakiterator_ == NULL 447 #if !UCONFIG_NO_BREAK_ITERATION 448 || 449 m_search_->matchedIndex == USEARCH_DONE || 450 (m_breakiterator_->isBoundary(m_search_->matchedIndex) && 451 m_breakiterator_->isBoundary(m_search_->matchedIndex + 452 m_search_->matchedLength)) 453 #endif 454 ) { 455 return m_search_->matchedIndex; 456 } 457 } 458 #else 459 ucol_setOffset(m_strsrch_->textIter, position, &status); 460 461 if (m_search_->isCanonicalMatch) { 462 // *could* use exact match here since extra accents *not* allowed! 463 usearch_handlePreviousCanonical(m_strsrch_, &status); 464 } else { 465 usearch_handlePreviousExact(m_strsrch_, &status); 466 } 467 468 if (U_FAILURE(status)) { 469 return USEARCH_DONE; 470 } 471 472 return m_search_->matchedIndex; 473 #endif 474 } 475 476 return m_search_->matchedIndex; 477 } 478 return USEARCH_DONE; 479 } 480 481 U_NAMESPACE_END 482 483 #endif /* #if !UCONFIG_NO_COLLATION */ 484
