• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
SearchIterator(const SearchIterator & other)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 
~SearchIterator()41 SearchIterator::~SearchIterator()
42 {
43     if (m_search_ != NULL) {
44         uprv_free(m_search_);
45     }
46 }
47 
48 // public get and set methods ----------------------------------------
49 
setAttribute(USearchAttribute attribute,USearchAttributeValue value,UErrorCode & status)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 
getAttribute(USearchAttribute attribute) const79 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 
getMatchedStart() const102 int32_t SearchIterator::getMatchedStart() const
103 {
104     return m_search_->matchedIndex;
105 }
106 
getMatchedLength() const107 int32_t SearchIterator::getMatchedLength() const
108 {
109     return m_search_->matchedLength;
110 }
111 
getMatchedText(UnicodeString & result) const112 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 
setBreakIterator(BreakIterator * breakiter,UErrorCode & status)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 
getBreakIterator(void) const147 const BreakIterator * SearchIterator::getBreakIterator(void) const
148 {
149     return m_breakiterator_;
150 }
151 
setText(const UnicodeString & text,UErrorCode & status)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 
setText(CharacterIterator & text,UErrorCode & status)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 
getText(void) const174 const UnicodeString & SearchIterator::getText(void) const
175 {
176     return m_text_;
177 }
178 
179 // operator overloading ----------------------------------------------
180 
operator ==(const SearchIterator & that) const181 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 
first(UErrorCode & status)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 
following(int32_t position,UErrorCode & status)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 
last(UErrorCode & status)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 
preceding(int32_t position,UErrorCode & status)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 
next(UErrorCode & status)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 
previous(UErrorCode & status)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 
reset()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 
SearchIterator()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 
SearchIterator(const UnicodeString & text,BreakIterator * breakiter)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 
SearchIterator(CharacterIterator & text,BreakIterator * breakiter)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 
operator =(const SearchIterator & that)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 
setMatchLength(int32_t length)417 void SearchIterator::setMatchLength(int32_t length)
418 {
419     m_search_->matchedLength = length;
420 }
421 
setMatchStart(int32_t position)422 void SearchIterator::setMatchStart(int32_t position)
423 {
424     m_search_->matchedIndex = position;
425 }
426 
setMatchNotFound()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 */
446