The Tor Browser: intl/icu/source/i18n/search.cpp@b8a032363ba2 (annotated)

intl/icu/source/i18n/search.cpp@b8a032363ba2 (annotated)

intl/icu/source/i18n/search.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*
 **********************************************************************
 *   Copyright (C) 2001-2008,2010 IBM and others. All rights reserved.
 **********************************************************************
 *   Date        Name        Description
 *  03/22/2000   helena      Creation.
 **********************************************************************
 */
 #include "unicode/utypes.h"
 #if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION
 #include "unicode/brkiter.h"
 #include "unicode/schriter.h"
 #include "unicode/search.h"
 #include "usrchimp.h"
 #include "cmemory.h"
 // public constructors and destructors -----------------------------------
 U_NAMESPACE_BEGIN
 SearchIterator::SearchIterator(const SearchIterator &other)
     : UObject(other)
 {
     m_breakiterator_            = other.m_breakiterator_;
     m_text_                     = other.m_text_;
     m_search_                   = (USearch *)uprv_malloc(sizeof(USearch));
     m_search_->breakIter        = other.m_search_->breakIter;
     m_search_->isCanonicalMatch = other.m_search_->isCanonicalMatch;
     m_search_->isOverlap        = other.m_search_->isOverlap;
     m_search_->elementComparisonType = other.m_search_->elementComparisonType;
     m_search_->matchedIndex     = other.m_search_->matchedIndex;
     m_search_->matchedLength    = other.m_search_->matchedLength;
     m_search_->text             = other.m_search_->text;
     m_search_->textLength       = other.m_search_->textLength;
 }
 SearchIterator::~SearchIterator()
 {
     if (m_search_ != NULL) {
         uprv_free(m_search_);
     }
 }
 // public get and set methods ----------------------------------------
 void SearchIterator::setAttribute(USearchAttribute       attribute,
                                   USearchAttributeValue  value,
                                   UErrorCode            &status)
 {
     if (U_SUCCESS(status)) {
         switch (attribute)
         {
         case USEARCH_OVERLAP :
             m_search_->isOverlap = (value == USEARCH_ON ? TRUE : FALSE);
             break;
         case USEARCH_CANONICAL_MATCH :
             m_search_->isCanonicalMatch = (value == USEARCH_ON ? TRUE : FALSE);
             break;
         case USEARCH_ELEMENT_COMPARISON :
             if (value == USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD || value == USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD) {
                 m_search_->elementComparisonType = (int16_t)value;
             } else {
                 m_search_->elementComparisonType = 0;
             }
             break;
         default:
             status = U_ILLEGAL_ARGUMENT_ERROR;
         }
     }
     if (value == USEARCH_ATTRIBUTE_VALUE_COUNT) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
     }
 }
 USearchAttributeValue SearchIterator::getAttribute(
                                           USearchAttribute  attribute) const
 {
     switch (attribute) {
     case USEARCH_OVERLAP :
         return (m_search_->isOverlap == TRUE ? USEARCH_ON : USEARCH_OFF);
     case USEARCH_CANONICAL_MATCH :
         return (m_search_->isCanonicalMatch == TRUE ? USEARCH_ON :
                                                                 USEARCH_OFF);
     case USEARCH_ELEMENT_COMPARISON :
         {
             int16_t value = m_search_->elementComparisonType;
             if (value == USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD || value == USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD) {
                 return (USearchAttributeValue)value;
             } else {
                 return USEARCH_STANDARD_ELEMENT_COMPARISON;
             }
         }
     default :
         return USEARCH_DEFAULT;
     }
 }
 int32_t SearchIterator::getMatchedStart() const
 {
     return m_search_->matchedIndex;
 }
 int32_t SearchIterator::getMatchedLength() const
 {
     return m_search_->matchedLength;
 }
 void SearchIterator::getMatchedText(UnicodeString &result) const
 {
     int32_t matchedindex  = m_search_->matchedIndex;
     int32_t     matchedlength = m_search_->matchedLength;
     if (matchedindex != USEARCH_DONE && matchedlength != 0) {
         result.setTo(m_search_->text + matchedindex, matchedlength);
     }
     else {
         result.remove();
     }
 }
 void SearchIterator::setBreakIterator(BreakIterator *breakiter,
                                       UErrorCode &status)
 {
     if (U_SUCCESS(status)) {
 #if 0
         m_search_->breakIter = NULL;
         // the c++ breakiterator may not make use of ubreakiterator.
         // so we'll have to keep track of it ourselves.
 #else
         // Well, gee... the Constructors that take a BreakIterator
         // all cast the BreakIterator to a UBreakIterator and
         // pass it to the corresponding usearch_openFromXXX
         // routine, so there's no reason not to do this.
         //
         // Besides, a UBreakIterator is a BreakIterator, so
         // any subclass of BreakIterator should work fine here...
         m_search_->breakIter = (UBreakIterator *) breakiter;
 #endif
         m_breakiterator_ = breakiter;
     }
 }
 const BreakIterator * SearchIterator::getBreakIterator(void) const
 {
     return m_breakiterator_;
 }
 void SearchIterator::setText(const UnicodeString &text, UErrorCode &status)
 {
     if (U_SUCCESS(status)) {
         if (text.length() == 0) {
             status = U_ILLEGAL_ARGUMENT_ERROR;
         }
         else {
             m_text_        = text;
             m_search_->text = m_text_.getBuffer();
             m_search_->textLength = m_text_.length();
         }
     }
 }
 void SearchIterator::setText(CharacterIterator &text, UErrorCode &status)
 {
     if (U_SUCCESS(status)) {
         text.getText(m_text_);
         setText(m_text_, status);
     }
 }
 const UnicodeString & SearchIterator::getText(void) const
 {
     return m_text_;
 }
 // operator overloading ----------------------------------------------
 UBool SearchIterator::operator==(const SearchIterator &that) const
 {
     if (this == &that) {
         return TRUE;
     }
     return (m_breakiterator_            == that.m_breakiterator_ &&
             m_search_->isCanonicalMatch == that.m_search_->isCanonicalMatch &&
             m_search_->isOverlap        == that.m_search_->isOverlap &&
             m_search_->elementComparisonType == that.m_search_->elementComparisonType &&
             m_search_->matchedIndex     == that.m_search_->matchedIndex &&
             m_search_->matchedLength    == that.m_search_->matchedLength &&
             m_search_->textLength       == that.m_search_->textLength &&
             getOffset() == that.getOffset() &&
             (uprv_memcmp(m_search_->text, that.m_search_->text,
                               m_search_->textLength * sizeof(UChar)) == 0));
 }
 // public methods ----------------------------------------------------
 int32_t SearchIterator::first(UErrorCode &status)
 {
     if (U_FAILURE(status)) {
         return USEARCH_DONE;
     }
     setOffset(0, status);
     return handleNext(0, status);
 }
 int32_t SearchIterator::following(int32_t position,
                                       UErrorCode &status)
 {
     if (U_FAILURE(status)) {
         return USEARCH_DONE;
     }
     setOffset(position, status);
     return handleNext(position, status);
 }
 int32_t SearchIterator::last(UErrorCode &status)
 {
     if (U_FAILURE(status)) {
         return USEARCH_DONE;
     }
     setOffset(m_search_->textLength, status);
     return handlePrev(m_search_->textLength, status);
 }
 int32_t SearchIterator::preceding(int32_t position,
                                       UErrorCode &status)
 {
     if (U_FAILURE(status)) {
         return USEARCH_DONE;
     }
     setOffset(position, status);
     return handlePrev(position, status);
 }
 int32_t SearchIterator::next(UErrorCode &status)
 {
     if (U_SUCCESS(status)) {
         int32_t offset = getOffset();
         int32_t matchindex  = m_search_->matchedIndex;
         int32_t     matchlength = m_search_->matchedLength;
         m_search_->reset = FALSE;
         if (m_search_->isForwardSearching == TRUE) {
             int32_t textlength = m_search_->textLength;
             if (offset == textlength || matchindex == textlength ||
                 (matchindex != USEARCH_DONE &&
                 matchindex + matchlength >= textlength)) {
                 // not enough characters to match
                 setMatchNotFound();
                 return USEARCH_DONE;
             }
         }
         else {
             // switching direction.
             // if matchedIndex == USEARCH_DONE, it means that either a
             // setOffset has been called or that previous ran off the text
             // string. the iterator would have been set to offset 0 if a
             // match is not found.
             m_search_->isForwardSearching = TRUE;
             if (m_search_->matchedIndex != USEARCH_DONE) {
                 // there's no need to set the collation element iterator
                 // the next call to next will set the offset.
                 return matchindex;
             }
         }
         if (matchlength > 0) {
             // if matchlength is 0 we are at the start of the iteration
             if (m_search_->isOverlap) {
                 offset ++;
             }
             else {
                 offset += matchlength;
             }
         }
         return handleNext(offset, status);
     }
     return USEARCH_DONE;
 }
 int32_t SearchIterator::previous(UErrorCode &status)
 {
     if (U_SUCCESS(status)) {
         int32_t offset;
         if (m_search_->reset) {
             offset                       = m_search_->textLength;
             m_search_->isForwardSearching = FALSE;
             m_search_->reset              = FALSE;
             setOffset(offset, status);
         }
         else {
             offset = getOffset();
         }
         int32_t matchindex = m_search_->matchedIndex;
         if (m_search_->isForwardSearching == TRUE) {
             // switching direction.
             // if matchedIndex == USEARCH_DONE, it means that either a
             // setOffset has been called or that next ran off the text
             // string. the iterator would have been set to offset textLength if
             // a match is not found.
             m_search_->isForwardSearching = FALSE;
             if (matchindex != USEARCH_DONE) {
                 return matchindex;
             }
         }
         else {
             if (offset == 0 || matchindex == 0) {
                 // not enough characters to match
                 setMatchNotFound();
                 return USEARCH_DONE;
             }
         }
         if (matchindex != USEARCH_DONE) {
             if (m_search_->isOverlap) {
                 matchindex += m_search_->matchedLength - 2;
             }
             return handlePrev(matchindex, status);
         }
         return handlePrev(offset, status);
     }
     return USEARCH_DONE;
 }
 void SearchIterator::reset()
 {
     UErrorCode status = U_ZERO_ERROR;
     setMatchNotFound();
     setOffset(0, status);
     m_search_->isOverlap          = FALSE;
     m_search_->isCanonicalMatch   = FALSE;
     m_search_->elementComparisonType = 0;
     m_search_->isForwardSearching = TRUE;
     m_search_->reset              = TRUE;
 }
 // protected constructors and destructors -----------------------------
 SearchIterator::SearchIterator()
 {
     m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));
     m_search_->breakIter          = NULL;
     m_search_->isOverlap          = FALSE;
     m_search_->isCanonicalMatch   = FALSE;
     m_search_->elementComparisonType = 0;
     m_search_->isForwardSearching = TRUE;
     m_search_->reset              = TRUE;
     m_search_->matchedIndex       = USEARCH_DONE;
     m_search_->matchedLength      = 0;
     m_search_->text               = NULL;
     m_search_->textLength         = 0;
     m_breakiterator_              = NULL;
 }
 SearchIterator::SearchIterator(const UnicodeString &text,
                                      BreakIterator *breakiter) :
                                      m_breakiterator_(breakiter),
                                      m_text_(text)
 {
     m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));
     m_search_->breakIter          = NULL;
     m_search_->isOverlap          = FALSE;
     m_search_->isCanonicalMatch   = FALSE;
     m_search_->elementComparisonType = 0;
     m_search_->isForwardSearching = TRUE;
     m_search_->reset              = TRUE;
     m_search_->matchedIndex       = USEARCH_DONE;
     m_search_->matchedLength      = 0;
     m_search_->text               = m_text_.getBuffer();
     m_search_->textLength         = text.length();
 }
 SearchIterator::SearchIterator(CharacterIterator &text,
                                BreakIterator     *breakiter) :
                                m_breakiterator_(breakiter)
 {
     m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));
     m_search_->breakIter          = NULL;
     m_search_->isOverlap          = FALSE;
     m_search_->isCanonicalMatch   = FALSE;
     m_search_->elementComparisonType = 0;
     m_search_->isForwardSearching = TRUE;
     m_search_->reset              = TRUE;
     m_search_->matchedIndex       = USEARCH_DONE;
     m_search_->matchedLength      = 0;
     text.getText(m_text_);
     m_search_->text               = m_text_.getBuffer();
     m_search_->textLength         = m_text_.length();
     m_breakiterator_             = breakiter;
 }
 // protected methods ------------------------------------------------------
 SearchIterator & SearchIterator::operator=(const SearchIterator &that)
 {
     if (this != &that) {
         m_breakiterator_            = that.m_breakiterator_;
         m_text_                     = that.m_text_;
         m_search_->breakIter        = that.m_search_->breakIter;
         m_search_->isCanonicalMatch = that.m_search_->isCanonicalMatch;
         m_search_->isOverlap        = that.m_search_->isOverlap;
         m_search_->elementComparisonType = that.m_search_->elementComparisonType;
         m_search_->matchedIndex     = that.m_search_->matchedIndex;
         m_search_->matchedLength    = that.m_search_->matchedLength;
         m_search_->text             = that.m_search_->text;
         m_search_->textLength       = that.m_search_->textLength;
     }
     return *this;
 }
 void SearchIterator::setMatchLength(int32_t length)
 {
     m_search_->matchedLength = length;
 }
 void SearchIterator::setMatchStart(int32_t position)
 {
     m_search_->matchedIndex = position;
 }
 void SearchIterator::setMatchNotFound()
 {
     setMatchStart(USEARCH_DONE);
     setMatchLength(0);
     UErrorCode status = U_ZERO_ERROR;
     // by default no errors should be returned here since offsets are within
     // range.
     if (m_search_->isForwardSearching) {
         setOffset(m_search_->textLength, status);
     }
     else {
         setOffset(0, status);
     }
 }
 U_NAMESPACE_END
 #endif /* #if !UCONFIG_NO_COLLATION */

The Tor Browser / annotate

intl/icu/source/i18n/search.cpp@b8a032363ba2 (annotated)

intl/icu/source/i18n/search.cpp