[apple/icu.git] / icuSources / i18n / stsearch.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
*   Copyright (C) 2001-2014 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/stsearch.h"
#include "usrchimp.h"
#include "cmemory.h"

U_NAMESPACE_BEGIN

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringSearch)

// public constructors and destructors -----------------------------------

StringSearch::StringSearch(const UnicodeString &pattern,
                           const UnicodeString &text,
                           const Locale        &locale,
                                 BreakIterator *breakiter,
                                 UErrorCode    &status) :
                           SearchIterator(text, breakiter),
                           m_pattern_(pattern)
{
    if (U_FAILURE(status)) {
        m_strsrch_ = NULL;
        return;
    }

    m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(),
                              m_text_.getBuffer(), m_text_.length(),
                              locale.getName(), (UBreakIterator *)breakiter,
                              &status);
    uprv_free(m_search_);
    m_search_ = NULL;

    if (U_SUCCESS(status)) {
        // m_search_ has been created by the base SearchIterator class
        m_search_        = m_strsrch_->search;
    }
}

StringSearch::StringSearch(const UnicodeString     &pattern,
                           const UnicodeString     &text,
                                 RuleBasedCollator *coll,
                                 BreakIterator     *breakiter,
                                 UErrorCode        &status) :
                           SearchIterator(text, breakiter),
                           m_pattern_(pattern)
{
    if (U_FAILURE(status)) {
        m_strsrch_ = NULL;
        return;
    }
    if (coll == NULL) {
        status     = U_ILLEGAL_ARGUMENT_ERROR;
        m_strsrch_ = NULL;
        return;
    }
    m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                          m_pattern_.length(),
                                          m_text_.getBuffer(),
                                          m_text_.length(), coll->toUCollator(),
                                          (UBreakIterator *)breakiter,
                                          &status);
    uprv_free(m_search_);
    m_search_ = NULL;

    if (U_SUCCESS(status)) {
        // m_search_ has been created by the base SearchIterator class
        m_search_ = m_strsrch_->search;
    }
}

StringSearch::StringSearch(const UnicodeString     &pattern,
                                 CharacterIterator &text,
                           const Locale            &locale,
                                 BreakIterator     *breakiter,
                                 UErrorCode        &status) :
                           SearchIterator(text, breakiter),
                           m_pattern_(pattern)
{
    if (U_FAILURE(status)) {
        m_strsrch_ = NULL;
        return;
    }
    m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(),
                              m_text_.getBuffer(), m_text_.length(),
                              locale.getName(), (UBreakIterator *)breakiter,
                              &status);
    uprv_free(m_search_);
    m_search_ = NULL;

    if (U_SUCCESS(status)) {
        // m_search_ has been created by the base SearchIterator class
        m_search_ = m_strsrch_->search;
    }
}

StringSearch::StringSearch(const UnicodeString     &pattern,
                                 CharacterIterator &text,
                                 RuleBasedCollator *coll,
                                 BreakIterator     *breakiter,
                                 UErrorCode        &status) :
                           SearchIterator(text, breakiter),
                           m_pattern_(pattern)
{
    if (U_FAILURE(status)) {
        m_strsrch_ = NULL;
        return;
    }
    if (coll == NULL) {
        status     = U_ILLEGAL_ARGUMENT_ERROR;
        m_strsrch_ = NULL;
        return;
    }
    m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                          m_pattern_.length(),
                                          m_text_.getBuffer(),
                                          m_text_.length(), coll->toUCollator(),
                                          (UBreakIterator *)breakiter,
                                          &status);
    uprv_free(m_search_);
    m_search_ = NULL;

    if (U_SUCCESS(status)) {
        // m_search_ has been created by the base SearchIterator class
        m_search_ = m_strsrch_->search;
    }
}

StringSearch::StringSearch(const StringSearch &that) :
                       SearchIterator(that.m_text_, that.m_breakiterator_),
                       m_pattern_(that.m_pattern_)
{
    UErrorCode status = U_ZERO_ERROR;

    // Free m_search_ from the superclass
    uprv_free(m_search_);
    m_search_ = NULL;

    if (that.m_strsrch_ == NULL) {
        // This was not a good copy
        m_strsrch_ = NULL;
    }
    else {
        // Make a deep copy
        m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                              m_pattern_.length(),
                                              m_text_.getBuffer(),
                                              m_text_.length(),
                                              that.m_strsrch_->collator,
                                             (UBreakIterator *)that.m_breakiterator_,
                                              &status);
        if (U_SUCCESS(status)) {
            // m_search_ has been created by the base SearchIterator class
            m_search_        = m_strsrch_->search;
        }
    }
}

StringSearch::~StringSearch()
{
    if (m_strsrch_ != NULL) {
        usearch_close(m_strsrch_);
        m_search_ = NULL;
    }
}

StringSearch *
StringSearch::clone() const {
    return new StringSearch(*this);
}

// operator overloading ---------------------------------------------
StringSearch & StringSearch::operator=(const StringSearch &that)
{
    if ((*this) != that) {
        UErrorCode status = U_ZERO_ERROR;
        m_text_          = that.m_text_;
        m_breakiterator_ = that.m_breakiterator_;
        m_pattern_       = that.m_pattern_;
        // all m_search_ in the parent class is linked up with m_strsrch_
        usearch_close(m_strsrch_);
        m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
                                              m_pattern_.length(),
                                              m_text_.getBuffer(),
                                              m_text_.length(),
                                              that.m_strsrch_->collator,
                                              NULL, &status);
        // Check null pointer
        if (m_strsrch_ != NULL) {
            m_search_ = m_strsrch_->search;
        }
    }
    return *this;
}

UBool StringSearch::operator==(const SearchIterator &that) const
{
    if (this == &that) {
        return TRUE;
    }
    if (SearchIterator::operator ==(that)) {
        StringSearch &thatsrch = (StringSearch &)that;
        return (this->m_pattern_ == thatsrch.m_pattern_ &&
                this->m_strsrch_->collator == thatsrch.m_strsrch_->collator);
    }
    return FALSE;
}

// public get and set methods ----------------------------------------

void StringSearch::setOffset(int32_t position, UErrorCode &status)
{
    // status checked in usearch_setOffset
    usearch_setOffset(m_strsrch_, position, &status);
}

int32_t StringSearch::getOffset(void) const
{
    return usearch_getOffset(m_strsrch_);
}

void StringSearch::setText(const UnicodeString &text, UErrorCode &status)
{
    if (U_SUCCESS(status)) {
        m_text_ = text;
        usearch_setText(m_strsrch_, text.getBuffer(), text.length(), &status);
    }
}

void StringSearch::setText(CharacterIterator &text, UErrorCode &status)
{
    if (U_SUCCESS(status)) {
        text.getText(m_text_);
        usearch_setText(m_strsrch_, m_text_.getBuffer(), m_text_.length(), &status);
    }
}

RuleBasedCollator * StringSearch::getCollator() const
{
    // Note the const_cast. It would be cleaner if this const method returned a const collator.
    return RuleBasedCollator::rbcFromUCollator(const_cast<UCollator *>(m_strsrch_->collator));
}

void StringSearch::setCollator(RuleBasedCollator *coll, UErrorCode &status)
{
    if (U_SUCCESS(status)) {
        usearch_setCollator(m_strsrch_, coll->toUCollator(), &status);
    }
}

void StringSearch::setPattern(const UnicodeString &pattern,
                                    UErrorCode    &status)
{
    if (U_SUCCESS(status)) {
        m_pattern_ = pattern;
        usearch_setPattern(m_strsrch_, m_pattern_.getBuffer(), m_pattern_.length(),
                           &status);
    }
}

const UnicodeString & StringSearch::getPattern() const
{
    return m_pattern_;
}

// public methods ----------------------------------------------------

void StringSearch::reset()
{
    usearch_reset(m_strsrch_);
}

SearchIterator * StringSearch::safeClone(void) const
{
    UErrorCode status = U_ZERO_ERROR;
    StringSearch *result = new StringSearch(m_pattern_, m_text_,
                                            getCollator(),
                                            m_breakiterator_,
                                            status);
    /* test for NULL */
    if (result == 0) {
        status = U_MEMORY_ALLOCATION_ERROR;
        return 0;
    }
    result->setOffset(getOffset(), status);
    result->setMatchStart(m_strsrch_->search->matchedIndex);
    result->setMatchLength(m_strsrch_->search->matchedLength);
    if (U_FAILURE(status)) {
        return NULL;
    }
    return result;
}

// protected method -------------------------------------------------

int32_t StringSearch::handleNext(int32_t position, UErrorCode &status)
{
    // values passed here are already in the pre-shift position
    if (U_SUCCESS(status)) {
        if (m_strsrch_->pattern.cesLength == 0) {
            m_search_->matchedIndex =
                                    m_search_->matchedIndex == USEARCH_DONE ?
                                    getOffset() : m_search_->matchedIndex + 1;
            m_search_->matchedLength = 0;
            ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex,
                           &status);
            if (m_search_->matchedIndex == m_search_->textLength) {
                m_search_->matchedIndex = USEARCH_DONE;
            }
        }
        else {
            // looking at usearch.cpp, this part is shifted out to
            // StringSearch instead of SearchIterator because m_strsrch_ is
            // not accessible in SearchIterator
#if 0
            if (position + m_strsrch_->pattern.defaultShiftSize
                > m_search_->textLength) {
                setMatchNotFound();
                return USEARCH_DONE;
            }
#endif
            if (m_search_->matchedLength <= 0) {
                // the flipping direction issue has already been handled
                // in next()
                // for boundary check purposes. this will ensure that the
                // next match will not preceed the current offset
                // note search->matchedIndex will always be set to something
                // in the code
                m_search_->matchedIndex = position - 1;
            }

            ucol_setOffset(m_strsrch_->textIter, position, &status);
            
#if 0
            for (;;) {
                if (m_search_->isCanonicalMatch) {
                    // can't use exact here since extra accents are allowed.
                    usearch_handleNextCanonical(m_strsrch_, &status);
                }
                else {
                    usearch_handleNextExact(m_strsrch_, &status);
                }
                if (U_FAILURE(status)) {
                    return USEARCH_DONE;
                }
                if (m_breakiterator_ == NULL
#if !UCONFIG_NO_BREAK_ITERATION
                    ||
                    m_search_->matchedIndex == USEARCH_DONE ||
                    (m_breakiterator_->isBoundary(m_search_->matchedIndex) &&
                     m_breakiterator_->isBoundary(m_search_->matchedIndex +
                                                  m_search_->matchedLength))
#endif
                ) {
                    if (m_search_->matchedIndex == USEARCH_DONE) {
                        ucol_setOffset(m_strsrch_->textIter,
                                       m_search_->textLength, &status);
                    }
                    else {
                        ucol_setOffset(m_strsrch_->textIter,
                                       m_search_->matchedIndex, &status);
                    }
                    return m_search_->matchedIndex;
                }
            }
#else
            // if m_strsrch_->breakIter is always the same as m_breakiterator_
            // then we don't need to check the match boundaries here because
            // usearch_handleNextXXX will already have done it.
            if (m_search_->isCanonicalMatch) {
            	// *could* actually use exact here 'cause no extra accents allowed...
            	usearch_handleNextCanonical(m_strsrch_, &status);
            } else {
            	usearch_handleNextExact(m_strsrch_, &status);
            }
            
            if (U_FAILURE(status)) {
            	return USEARCH_DONE;
            }
            
            if (m_search_->matchedIndex == USEARCH_DONE) {
            	ucol_setOffset(m_strsrch_->textIter, m_search_->textLength, &status);
            } else {
            	ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex, &status);
            }
            
            return m_search_->matchedIndex;
#endif
        }
    }
    return USEARCH_DONE;
}

int32_t StringSearch::handlePrev(int32_t position, UErrorCode &status)
{
    // values passed here are already in the pre-shift position
    if (U_SUCCESS(status)) {
        if (m_strsrch_->pattern.cesLength == 0) {
            m_search_->matchedIndex =
                  (m_search_->matchedIndex == USEARCH_DONE ? getOffset() :
                   m_search_->matchedIndex);
            if (m_search_->matchedIndex == 0) {
                setMatchNotFound();
            }
            else {
                m_search_->matchedIndex --;
                ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex,
                               &status);
                m_search_->matchedLength = 0;
            }
        }
        else {
            // looking at usearch.cpp, this part is shifted out to
            // StringSearch instead of SearchIterator because m_strsrch_ is
            // not accessible in SearchIterator
#if 0
            if (!m_search_->isOverlap &&
                position - m_strsrch_->pattern.defaultShiftSize < 0) {
                setMatchNotFound();
                return USEARCH_DONE;
            }
            
            for (;;) {
                if (m_search_->isCanonicalMatch) {
                    // can't use exact here since extra accents are allowed.
                    usearch_handlePreviousCanonical(m_strsrch_, &status);
                }
                else {
                    usearch_handlePreviousExact(m_strsrch_, &status);
                }
                if (U_FAILURE(status)) {
                    return USEARCH_DONE;
                }
                if (m_breakiterator_ == NULL
#if !UCONFIG_NO_BREAK_ITERATION
                    ||
                    m_search_->matchedIndex == USEARCH_DONE ||
                    (m_breakiterator_->isBoundary(m_search_->matchedIndex) &&
                     m_breakiterator_->isBoundary(m_search_->matchedIndex +
                                                  m_search_->matchedLength))
#endif
                ) {
                    return m_search_->matchedIndex;
                }
            }
#else
            ucol_setOffset(m_strsrch_->textIter, position, &status);
            
            if (m_search_->isCanonicalMatch) {
            	// *could* use exact match here since extra accents *not* allowed!
            	usearch_handlePreviousCanonical(m_strsrch_, &status);
            } else {
            	usearch_handlePreviousExact(m_strsrch_, &status);
            }
            
            if (U_FAILURE(status)) {
            	return USEARCH_DONE;
            }
            
            return m_search_->matchedIndex;
#endif
        }

        return m_search_->matchedIndex;
    }
    return USEARCH_DONE;
}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_COLLATION */
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
b75a7d8f A	3	/*
b75a7d8f A	4	**********************************************************************
57a6839d	5	* Copyright (C) 2001-2014 IBM and others. All rights reserved.
b75a7d8f A	6	**********************************************************************
	7	* Date Name Description
	8	* 03/22/2000 helena Creation.
	9	**********************************************************************
	10	*/
	11
	12	#include "unicode/utypes.h"
	13
46f4442e	14	#if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION
b75a7d8f A	15
	16	#include "unicode/stsearch.h"
	17	#include "usrchimp.h"
	18	#include "cmemory.h"
	19
	20	U_NAMESPACE_BEGIN
	21
374ca955	22	UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringSearch)
b75a7d8f A	23
	24	// public constructors and destructors -----------------------------------
	25
73c04bcf	26	StringSearch::StringSearch(const UnicodeString &pattern,
b75a7d8f	27	const UnicodeString &text,
73c04bcf	28	const Locale &locale,
b75a7d8f A	29	BreakIterator *breakiter,
b75a7d8f A	30	UErrorCode &status) :
73c04bcf	31	SearchIterator(text, breakiter),
b75a7d8f A	32	m_pattern_(pattern)
	33	{
	34	if (U_FAILURE(status)) {
	35	m_strsrch_ = NULL;
	36	return;
	37	}
	38
73c04bcf A	39	m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(),
	40	m_text_.getBuffer(), m_text_.length(),
	41	locale.getName(), (UBreakIterator *)breakiter,
b75a7d8f A	42	&status);
	43	uprv_free(m_search_);
	44	m_search_ = NULL;
	45
b75a7d8f	46	if (U_SUCCESS(status)) {
b75a7d8f A	47	// m_search_ has been created by the base SearchIterator class
	48	m_search_ = m_strsrch_->search;
	49	}
	50	}
	51
73c04bcf	52	StringSearch::StringSearch(const UnicodeString &pattern,
b75a7d8f	53	const UnicodeString &text,
73c04bcf	54	RuleBasedCollator *coll,
b75a7d8f A	55	BreakIterator *breakiter,
b75a7d8f A	56	UErrorCode &status) :
73c04bcf	57	SearchIterator(text, breakiter),
b75a7d8f A	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	}
73c04bcf A	69	m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
	70	m_pattern_.length(),
	71	m_text_.getBuffer(),
57a6839d	72	m_text_.length(), coll->toUCollator(),
73c04bcf	73	(UBreakIterator *)breakiter,
b75a7d8f A	74	&status);
	75	uprv_free(m_search_);
	76	m_search_ = NULL;
	77
	78	if (U_SUCCESS(status)) {
b75a7d8f A	79	// m_search_ has been created by the base SearchIterator class
	80	m_search_ = m_strsrch_->search;
	81	}
	82	}
	83
73c04bcf	84	StringSearch::StringSearch(const UnicodeString &pattern,
b75a7d8f	85	CharacterIterator &text,
73c04bcf	86	const Locale &locale,
b75a7d8f A	87	BreakIterator *breakiter,
b75a7d8f A	88	UErrorCode &status) :
73c04bcf	89	SearchIterator(text, breakiter),
b75a7d8f A	90	m_pattern_(pattern)
	91	{
	92	if (U_FAILURE(status)) {
	93	m_strsrch_ = NULL;
	94	return;
	95	}
73c04bcf A	96	m_strsrch_ = usearch_open(m_pattern_.getBuffer(), m_pattern_.length(),
	97	m_text_.getBuffer(), m_text_.length(),
	98	locale.getName(), (UBreakIterator *)breakiter,
b75a7d8f A	99	&status);
	100	uprv_free(m_search_);
	101	m_search_ = NULL;
	102
	103	if (U_SUCCESS(status)) {
b75a7d8f A	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,
73c04bcf	111	RuleBasedCollator *coll,
b75a7d8f A	112	BreakIterator *breakiter,
b75a7d8f A	113	UErrorCode &status) :
73c04bcf	114	SearchIterator(text, breakiter),
b75a7d8f A	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	}
73c04bcf A	126	m_strsrch_ = usearch_openFromCollator(m_pattern_.getBuffer(),
	127	m_pattern_.length(),
	128	m_text_.getBuffer(),
57a6839d	129	m_text_.length(), coll->toUCollator(),
73c04bcf	130	(UBreakIterator *)breakiter,
b75a7d8f A	131	&status);
	132	uprv_free(m_search_);
	133	m_search_ = NULL;
	134
	135	if (U_SUCCESS(status)) {
b75a7d8f A	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_),
b75a7d8f A	143	m_pattern_(that.m_pattern_)
	144	{
	145	UErrorCode status = U_ZERO_ERROR;
73c04bcf A	146
	147	// Free m_search_ from the superclass
	148	uprv_free(m_search_);
	149	m_search_ = NULL;
	150
b75a7d8f	151	if (that.m_strsrch_ == NULL) {
73c04bcf	152	// This was not a good copy
b75a7d8f	153	m_strsrch_ = NULL;
b75a7d8f A	154	}
b75a7d8f A	155	else {
73c04bcf A	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_,
b75a7d8f	163	&status);
73c04bcf	164	if (U_SUCCESS(status)) {
73c04bcf A	165	// m_search_ has been created by the base SearchIterator class
	166	m_search_ = m_strsrch_->search;
	167	}
b75a7d8f A	168	}
	169	}
	170
	171	StringSearch::~StringSearch()
	172	{
	173	if (m_strsrch_ != NULL) {
	174	usearch_close(m_strsrch_);
	175	m_search_ = NULL;
	176	}
	177	}
	178
374ca955 A	179	StringSearch *
	180	StringSearch::clone() const {
	181	return new StringSearch(*this);
	182	}
	183
b75a7d8f A	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_);
73c04bcf A	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,
b75a7d8f	199	NULL, &status);
46f4442e A	200	// Check null pointer
46f4442e A	201	if (m_strsrch_ != NULL) {
57a6839d	202	m_search_ = m_strsrch_->search;
46f4442e	203	}
b75a7d8f A	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	}
73c04bcf	241
b75a7d8f A	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	{
57a6839d A	252	// Note the const_cast. It would be cleaner if this const method returned a const collator.
57a6839d A	253	return RuleBasedCollator::rbcFromUCollator(const_cast<UCollator *>(m_strsrch_->collator));
b75a7d8f	254	}
73c04bcf	255
b75a7d8f A	256	void StringSearch::setCollator(RuleBasedCollator *coll, UErrorCode &status)
	257	{
	258	if (U_SUCCESS(status)) {
57a6839d	259	usearch_setCollator(m_strsrch_, coll->toUCollator(), &status);
b75a7d8f A	260	}
b75a7d8f A	261	}
73c04bcf A	262
73c04bcf A	263	void StringSearch::setPattern(const UnicodeString &pattern,
b75a7d8f A	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	}
73c04bcf	272
b75a7d8f A	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;
73c04bcf	288	StringSearch *result = new StringSearch(m_pattern_, m_text_,
57a6839d	289	getCollator(),
b75a7d8f A	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	}
73c04bcf	305
b75a7d8f A	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)) {
b331163b	312	if (m_strsrch_->pattern.cesLength == 0) {
73c04bcf A	313	m_search_->matchedIndex =
73c04bcf A	314	m_search_->matchedIndex == USEARCH_DONE ?
b75a7d8f A	315	getOffset() : m_search_->matchedIndex + 1;
b75a7d8f A	316	m_search_->matchedLength = 0;
73c04bcf	317	ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex,
b75a7d8f A	318	&status);
	319	if (m_search_->matchedIndex == m_search_->textLength) {
	320	m_search_->matchedIndex = USEARCH_DONE;
	321	}
	322	}
	323	else {
73c04bcf	324	// looking at usearch.cpp, this part is shifted out to
b75a7d8f A	325	// StringSearch instead of SearchIterator because m_strsrch_ is
b75a7d8f A	326	// not accessible in SearchIterator
46f4442e	327	#if 0
73c04bcf	328	if (position + m_strsrch_->pattern.defaultShiftSize
374ca955	329	> m_search_->textLength) {
b75a7d8f A	330	setMatchNotFound();
	331	return USEARCH_DONE;
	332	}
46f4442e	333	#endif
374ca955	334	if (m_search_->matchedLength <= 0) {
73c04bcf	335	// the flipping direction issue has already been handled
374ca955 A	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);
46f4442e A	345
	346	#if 0
	347	for (;;) {
b75a7d8f A	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
73c04bcf	360	\|\|
b75a7d8f A	361	m_search_->matchedIndex == USEARCH_DONE \|\|
b75a7d8f A	362	(m_breakiterator_->isBoundary(m_search_->matchedIndex) &&
73c04bcf	363	m_breakiterator_->isBoundary(m_search_->matchedIndex +
b75a7d8f A	364	m_search_->matchedLength))
	365	#endif
	366	) {
374ca955	367	if (m_search_->matchedIndex == USEARCH_DONE) {
73c04bcf	368	ucol_setOffset(m_strsrch_->textIter,
374ca955 A	369	m_search_->textLength, &status);
	370	}
	371	else {
73c04bcf	372	ucol_setOffset(m_strsrch_->textIter,
374ca955 A	373	m_search_->matchedIndex, &status);
374ca955 A	374	}
b75a7d8f A	375	return m_search_->matchedIndex;
	376	}
	377	}
46f4442e A	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
b75a7d8f A	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)) {
b331163b	410	if (m_strsrch_->pattern.cesLength == 0) {
73c04bcf A	411	m_search_->matchedIndex =
73c04bcf A	412	(m_search_->matchedIndex == USEARCH_DONE ? getOffset() :
b75a7d8f A	413	m_search_->matchedIndex);
	414	if (m_search_->matchedIndex == 0) {
	415	setMatchNotFound();
	416	}
	417	else {
	418	m_search_->matchedIndex --;
73c04bcf	419	ucol_setOffset(m_strsrch_->textIter, m_search_->matchedIndex,
b75a7d8f A	420	&status);
	421	m_search_->matchedLength = 0;
	422	}
	423	}
	424	else {
73c04bcf	425	// looking at usearch.cpp, this part is shifted out to
b75a7d8f A	426	// StringSearch instead of SearchIterator because m_strsrch_ is
b75a7d8f A	427	// not accessible in SearchIterator
46f4442e	428	#if 0
73c04bcf	429	if (!m_search_->isOverlap &&
b75a7d8f A	430	position - m_strsrch_->pattern.defaultShiftSize < 0) {
	431	setMatchNotFound();
	432	return USEARCH_DONE;
	433	}
46f4442e A	434
46f4442e A	435	for (;;) {
b75a7d8f A	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
73c04bcf	448	\|\|
b75a7d8f A	449	m_search_->matchedIndex == USEARCH_DONE \|\|
b75a7d8f A	450	(m_breakiterator_->isBoundary(m_search_->matchedIndex) &&
73c04bcf	451	m_breakiterator_->isBoundary(m_search_->matchedIndex +
b75a7d8f A	452	m_search_->matchedLength))
	453	#endif
	454	) {
	455	return m_search_->matchedIndex;
	456	}
	457	}
46f4442e A	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
b75a7d8f	474	}
73c04bcf	475
b75a7d8f A	476	return m_search_->matchedIndex;
	477	}
	478	return USEARCH_DONE;
	479	}
	480
	481	U_NAMESPACE_END
	482
	483	#endif /* #if !UCONFIG_NO_COLLATION */