icuSources/i18n/stsearch.cpp

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