| /* | |
| ********************************************************************** | |
| * 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 "starboard/client_porting/poem/string_poem.h" | |
| #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 */ |