icuSources/i18n/search.cpp

   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-2008,2010 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/brkiter.h"
  17 #include "unicode/schriter.h"
  18 #include "unicode/search.h"
  19 #include "usrchimp.h"
  20 #include "cmemory.h"
  21
  22 // public constructors and destructors -----------------------------------
  23 U_NAMESPACE_BEGIN
  24
  25 SearchIterator::SearchIterator(const SearchIterator &other)
  26     : UObject(other)
  27 {
  28     m_breakiterator_            = other.m_breakiterator_;
  29     m_text_                     = other.m_text_;
  30     m_search_                   = (USearch *)uprv_malloc(sizeof(USearch));
  31     m_search_->breakIter        = other.m_search_->breakIter;
  32     m_search_->isCanonicalMatch = other.m_search_->isCanonicalMatch;
  33     m_search_->isOverlap        = other.m_search_->isOverlap;
  34     m_search_->elementComparisonType = other.m_search_->elementComparisonType;
  35     m_search_->matchedIndex     = other.m_search_->matchedIndex;
  36     m_search_->matchedLength    = other.m_search_->matchedLength;
  37     m_search_->text             = other.m_search_->text;
  38     m_search_->textLength       = other.m_search_->textLength;
  39 }
  40
  41 SearchIterator::~SearchIterator()
  42 {
  43     if (m_search_ != NULL) {
  44         uprv_free(m_search_);
  45     }
  46 }
  47
  48 // public get and set methods ----------------------------------------
  49
  50 void SearchIterator::setAttribute(USearchAttribute       attribute,
  51                                   USearchAttributeValue  value,
  52                                   UErrorCode            &status)
  53 {
  54     if (U_SUCCESS(status)) {
  55         switch (attribute)
  56         {
  57         case USEARCH_OVERLAP :
  58             m_search_->isOverlap = (value == USEARCH_ON ? TRUE : FALSE);
  59             break;
  60         case USEARCH_CANONICAL_MATCH :
  61             m_search_->isCanonicalMatch = (value == USEARCH_ON ? TRUE : FALSE);
  62             break;
  63         case USEARCH_ELEMENT_COMPARISON :
  64             if (value == USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD || value == USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD) {
  65                 m_search_->elementComparisonType = (int16_t)value;
  66             } else {
  67                 m_search_->elementComparisonType = 0;
  68             }
  69             break;
  70         default:
  71             status = U_ILLEGAL_ARGUMENT_ERROR;
  72         }
  73     }
  74     if (value == USEARCH_ATTRIBUTE_VALUE_COUNT) {
  75         status = U_ILLEGAL_ARGUMENT_ERROR;
  76     }
  77 }
  78
  79 USearchAttributeValue SearchIterator::getAttribute(
  80                                           USearchAttribute  attribute) const
  81 {
  82     switch (attribute) {
  83     case USEARCH_OVERLAP :
  84         return (m_search_->isOverlap == TRUE ? USEARCH_ON : USEARCH_OFF);
  85     case USEARCH_CANONICAL_MATCH :
  86         return (m_search_->isCanonicalMatch == TRUE ? USEARCH_ON :
  87                                                                 USEARCH_OFF);
  88     case USEARCH_ELEMENT_COMPARISON :
  89         {
  90             int16_t value = m_search_->elementComparisonType;
  91             if (value == USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD || value == USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD) {
  92                 return (USearchAttributeValue)value;
  93             } else {
  94                 return USEARCH_STANDARD_ELEMENT_COMPARISON;
  95             }
  96         }
  97     default :
  98         return USEARCH_DEFAULT;
  99     }
 100 }
 101
 102 int32_t SearchIterator::getMatchedStart() const
 103 {
 104     return m_search_->matchedIndex;
 105 }
 106
 107 int32_t SearchIterator::getMatchedLength() const
 108 {
 109     return m_search_->matchedLength;
 110 }
 111
 112 void SearchIterator::getMatchedText(UnicodeString &result) const
 113 {
 114     int32_t matchedindex  = m_search_->matchedIndex;
 115     int32_t     matchedlength = m_search_->matchedLength;
 116     if (matchedindex != USEARCH_DONE && matchedlength != 0) {
 117         result.setTo(m_search_->text + matchedindex, matchedlength);
 118     }
 119     else {
 120         result.remove();
 121     }
 122 }
 123
 124 void SearchIterator::setBreakIterator(BreakIterator *breakiter,
 125                                       UErrorCode &status)
 126 {
 127     if (U_SUCCESS(status)) {
 128 #if 0
 129         m_search_->breakIter = NULL;
 130         // the c++ breakiterator may not make use of ubreakiterator.
 131         // so we'll have to keep track of it ourselves.
 132 #else
 133         // Well, gee... the Constructors that take a BreakIterator
 134         // all cast the BreakIterator to a UBreakIterator and
 135         // pass it to the corresponding usearch_openFromXXX
 136         // routine, so there's no reason not to do this.
 137         //
 138         // Besides, a UBreakIterator is a BreakIterator, so
 139         // any subclass of BreakIterator should work fine here...
 140         m_search_->breakIter = (UBreakIterator *) breakiter;
 141 #endif
 142
 143         m_breakiterator_ = breakiter;
 144     }
 145 }
 146
 147 const BreakIterator * SearchIterator::getBreakIterator(void) const
 148 {
 149     return m_breakiterator_;
 150 }
 151
 152 void SearchIterator::setText(const UnicodeString &text, UErrorCode &status)
 153 {
 154     if (U_SUCCESS(status)) {
 155         if (text.length() == 0) {
 156             status = U_ILLEGAL_ARGUMENT_ERROR;
 157         }
 158         else {
 159             m_text_        = text;
 160             m_search_->text = m_text_.getBuffer();
 161             m_search_->textLength = m_text_.length();
 162         }
 163     }
 164 }
 165
 166 void SearchIterator::setText(CharacterIterator &text, UErrorCode &status)
 167 {
 168     if (U_SUCCESS(status)) {
 169         text.getText(m_text_);
 170         setText(m_text_, status);
 171     }
 172 }
 173
 174 const UnicodeString & SearchIterator::getText(void) const
 175 {
 176     return m_text_;
 177 }
 178
 179 // operator overloading ----------------------------------------------
 180
 181 UBool SearchIterator::operator==(const SearchIterator &that) const
 182 {
 183     if (this == &that) {
 184         return TRUE;
 185     }
 186     return (m_breakiterator_            == that.m_breakiterator_ &&
 187             m_search_->isCanonicalMatch == that.m_search_->isCanonicalMatch &&
 188             m_search_->isOverlap        == that.m_search_->isOverlap &&
 189             m_search_->elementComparisonType == that.m_search_->elementComparisonType &&
 190             m_search_->matchedIndex     == that.m_search_->matchedIndex &&
 191             m_search_->matchedLength    == that.m_search_->matchedLength &&
 192             m_search_->textLength       == that.m_search_->textLength &&
 193             getOffset() == that.getOffset() &&
 194             (uprv_memcmp(m_search_->text, that.m_search_->text,
 195                               m_search_->textLength * sizeof(UChar)) == 0));
 196 }
 197
 198 // public methods ----------------------------------------------------
 199
 200 int32_t SearchIterator::first(UErrorCode &status)
 201 {
 202     if (U_FAILURE(status)) {
 203         return USEARCH_DONE;
 204     }
 205     setOffset(0, status);
 206     return handleNext(0, status);
 207 }
 208
 209 int32_t SearchIterator::following(int32_t position,
 210                                       UErrorCode &status)
 211 {
 212     if (U_FAILURE(status)) {
 213         return USEARCH_DONE;
 214     }
 215     setOffset(position, status);
 216     return handleNext(position, status);
 217 }
 218
 219 int32_t SearchIterator::last(UErrorCode &status)
 220 {
 221     if (U_FAILURE(status)) {
 222         return USEARCH_DONE;
 223     }
 224     setOffset(m_search_->textLength, status);
 225     return handlePrev(m_search_->textLength, status);
 226 }
 227
 228 int32_t SearchIterator::preceding(int32_t position,
 229                                       UErrorCode &status)
 230 {
 231     if (U_FAILURE(status)) {
 232         return USEARCH_DONE;
 233     }
 234     setOffset(position, status);
 235     return handlePrev(position, status);
 236 }
 237
 238 int32_t SearchIterator::next(UErrorCode &status)
 239 {
 240     if (U_SUCCESS(status)) {
 241         int32_t offset = getOffset();
 242         int32_t matchindex  = m_search_->matchedIndex;
 243         int32_t     matchlength = m_search_->matchedLength;
 244         m_search_->reset = FALSE;
 245         if (m_search_->isForwardSearching == TRUE) {
 246             int32_t textlength = m_search_->textLength;
 247             if (offset == textlength || matchindex == textlength ||
 248                 (matchindex != USEARCH_DONE &&
 249                 matchindex + matchlength >= textlength)) {
 250                 // not enough characters to match
 251                 setMatchNotFound();
 252                 return USEARCH_DONE;
 253             }
 254         }
 255         else {
 256             // switching direction.
 257             // if matchedIndex == USEARCH_DONE, it means that either a
 258             // setOffset has been called or that previous ran off the text
 259             // string. the iterator would have been set to offset 0 if a
 260             // match is not found.
 261             m_search_->isForwardSearching = TRUE;
 262             if (m_search_->matchedIndex != USEARCH_DONE) {
 263                 // there's no need to set the collation element iterator
 264                 // the next call to next will set the offset.
 265                 return matchindex;
 266             }
 267         }
 268
 269         if (matchlength > 0) {
 270             // if matchlength is 0 we are at the start of the iteration
 271             if (m_search_->isOverlap) {
 272                 offset ++;
 273             }
 274             else {
 275                 offset += matchlength;
 276             }
 277         }
 278         return handleNext(offset, status);
 279     }
 280     return USEARCH_DONE;
 281 }
 282
 283 int32_t SearchIterator::previous(UErrorCode &status)
 284 {
 285     if (U_SUCCESS(status)) {
 286         int32_t offset;
 287         if (m_search_->reset) {
 288             offset                       = m_search_->textLength;
 289             m_search_->isForwardSearching = FALSE;
 290             m_search_->reset              = FALSE;
 291             setOffset(offset, status);
 292         }
 293         else {
 294             offset = getOffset();
 295         }
 296
 297         int32_t matchindex = m_search_->matchedIndex;
 298         if (m_search_->isForwardSearching == TRUE) {
 299             // switching direction.
 300             // if matchedIndex == USEARCH_DONE, it means that either a
 301             // setOffset has been called or that next ran off the text
 302             // string. the iterator would have been set to offset textLength if
 303             // a match is not found.
 304             m_search_->isForwardSearching = FALSE;
 305             if (matchindex != USEARCH_DONE) {
 306                 return matchindex;
 307             }
 308         }
 309         else {
 310             if (offset == 0 || matchindex == 0) {
 311                 // not enough characters to match
 312                 setMatchNotFound();
 313                 return USEARCH_DONE;
 314             }
 315         }
 316
 317         if (matchindex != USEARCH_DONE) {
 318             if (m_search_->isOverlap) {
 319                 matchindex += m_search_->matchedLength - 2;
 320             }
 321
 322             return handlePrev(matchindex, status);
 323         }
 324
 325         return handlePrev(offset, status);
 326     }
 327
 328     return USEARCH_DONE;
 329 }
 330
 331 void SearchIterator::reset()
 332 {
 333     UErrorCode status = U_ZERO_ERROR;
 334     setMatchNotFound();
 335     setOffset(0, status);
 336     m_search_->isOverlap          = FALSE;
 337     m_search_->isCanonicalMatch   = FALSE;
 338     m_search_->elementComparisonType = 0;
 339     m_search_->isForwardSearching = TRUE;
 340     m_search_->reset              = TRUE;
 341 }
 342
 343 // protected constructors and destructors -----------------------------
 344
 345 SearchIterator::SearchIterator()
 346 {
 347     m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));
 348     m_search_->breakIter          = NULL;
 349     m_search_->isOverlap          = FALSE;
 350     m_search_->isCanonicalMatch   = FALSE;
 351     m_search_->elementComparisonType = 0;
 352     m_search_->isForwardSearching = TRUE;
 353     m_search_->reset              = TRUE;
 354     m_search_->matchedIndex       = USEARCH_DONE;
 355     m_search_->matchedLength      = 0;
 356     m_search_->text               = NULL;
 357     m_search_->textLength         = 0;
 358     m_breakiterator_              = NULL;
 359 }
 360
 361 SearchIterator::SearchIterator(const UnicodeString &text,
 362                                      BreakIterator *breakiter) :
 363                                      m_breakiterator_(breakiter),
 364                                      m_text_(text)
 365 {
 366     m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));
 367     m_search_->breakIter          = NULL;
 368     m_search_->isOverlap          = FALSE;
 369     m_search_->isCanonicalMatch   = FALSE;
 370     m_search_->elementComparisonType = 0;
 371     m_search_->isForwardSearching = TRUE;
 372     m_search_->reset              = TRUE;
 373     m_search_->matchedIndex       = USEARCH_DONE;
 374     m_search_->matchedLength      = 0;
 375     m_search_->text               = m_text_.getBuffer();
 376     m_search_->textLength         = text.length();
 377 }
 378
 379 SearchIterator::SearchIterator(CharacterIterator &text,
 380                                BreakIterator     *breakiter) :
 381                                m_breakiterator_(breakiter)
 382 {
 383     m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));
 384     m_search_->breakIter          = NULL;
 385     m_search_->isOverlap          = FALSE;
 386     m_search_->isCanonicalMatch   = FALSE;
 387     m_search_->elementComparisonType = 0;
 388     m_search_->isForwardSearching = TRUE;
 389     m_search_->reset              = TRUE;
 390     m_search_->matchedIndex       = USEARCH_DONE;
 391     m_search_->matchedLength      = 0;
 392     text.getText(m_text_);
 393     m_search_->text               = m_text_.getBuffer();
 394     m_search_->textLength         = m_text_.length();
 395     m_breakiterator_             = breakiter;
 396 }
 397
 398 // protected methods ------------------------------------------------------
 399
 400 SearchIterator & SearchIterator::operator=(const SearchIterator &that)
 401 {
 402     if (this != &that) {
 403         m_breakiterator_            = that.m_breakiterator_;
 404         m_text_                     = that.m_text_;
 405         m_search_->breakIter        = that.m_search_->breakIter;
 406         m_search_->isCanonicalMatch = that.m_search_->isCanonicalMatch;
 407         m_search_->isOverlap        = that.m_search_->isOverlap;
 408         m_search_->elementComparisonType = that.m_search_->elementComparisonType;
 409         m_search_->matchedIndex     = that.m_search_->matchedIndex;
 410         m_search_->matchedLength    = that.m_search_->matchedLength;
 411         m_search_->text             = that.m_search_->text;
 412         m_search_->textLength       = that.m_search_->textLength;
 413     }
 414     return *this;
 415 }
 416
 417 void SearchIterator::setMatchLength(int32_t length)
 418 {
 419     m_search_->matchedLength = length;
 420 }
 421
 422 void SearchIterator::setMatchStart(int32_t position)
 423 {
 424     m_search_->matchedIndex = position;
 425 }
 426
 427 void SearchIterator::setMatchNotFound()
 428 {
 429     setMatchStart(USEARCH_DONE);
 430     setMatchLength(0);
 431     UErrorCode status = U_ZERO_ERROR;
 432     // by default no errors should be returned here since offsets are within
 433     // range.
 434     if (m_search_->isForwardSearching) {
 435         setOffset(m_search_->textLength, status);
 436     }
 437     else {
 438         setOffset(0, status);
 439     }
 440 }
 441
 442
 443 U_NAMESPACE_END
 444
 445 #endif /* #if !UCONFIG_NO_COLLATION */