The Tor Browser / file comparison

comparison: intl/icu/source/i18n/search.cpp

intl/icu/source/i18n/search.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial