The Tor Browser / file comparison

comparison: intl/icu/source/common/uchriter.cpp

intl/icu/source/common/uchriter.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:7fb866f66f29
1 /*
2 ******************************************************************************
3 * Copyright (C) 1998-2012, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ******************************************************************************
6 */
7
8 #include "utypeinfo.h" // for 'typeid' to work
9
10 #include "unicode/uchriter.h"
11 #include "unicode/ustring.h"
12 #include "unicode/utf16.h"
13 #include "ustr_imp.h"
14
15 U_NAMESPACE_BEGIN
16
17 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UCharCharacterIterator)
18
19 UCharCharacterIterator::UCharCharacterIterator()
20 : CharacterIterator(),
21 text(0)
22 {
23 // never default construct!
24 }
25
26 UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr,
27 int32_t length)
28 : CharacterIterator(textPtr != 0 ? (length>=0 ? length : u_strlen(textPtr)) : 0),
29 text(textPtr)
30 {
31 }
32
33 UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr,
34 int32_t length,
35 int32_t position)
36 : CharacterIterator(textPtr != 0 ? (length>=0 ? length : u_strlen(textPtr)) : 0, position),
37 text(textPtr)
38 {
39 }
40
41 UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr,
42 int32_t length,
43 int32_t textBegin,
44 int32_t textEnd,
45 int32_t position)
46 : CharacterIterator(textPtr != 0 ? (length>=0 ? length : u_strlen(textPtr)) : 0, textBegin, textEnd, position),
47 text(textPtr)
48 {
49 }
50
51 UCharCharacterIterator::UCharCharacterIterator(const UCharCharacterIterator& that)
52 : CharacterIterator(that),
53 text(that.text)
54 {
55 }
56
57 UCharCharacterIterator&
58 UCharCharacterIterator::operator=(const UCharCharacterIterator& that) {
59 CharacterIterator::operator=(that);
60 text = that.text;
61 return *this;
62 }
63
64 UCharCharacterIterator::~UCharCharacterIterator() {
65 }
66
67 UBool
68 UCharCharacterIterator::operator==(const ForwardCharacterIterator& that) const {
69 if (this == &that) {
70 return TRUE;
71 }
72 if (typeid(*this) != typeid(that)) {
73 return FALSE;
74 }
75
76 UCharCharacterIterator& realThat = (UCharCharacterIterator&)that;
77
78 return text == realThat.text
79 && textLength == realThat.textLength
80 && pos == realThat.pos
81 && begin == realThat.begin
82 && end == realThat.end;
83 }
84
85 int32_t
86 UCharCharacterIterator::hashCode() const {
87 return ustr_hashUCharsN(text, textLength) ^ pos ^ begin ^ end;
88 }
89
90 CharacterIterator*
91 UCharCharacterIterator::clone() const {
92 return new UCharCharacterIterator(*this);
93 }
94
95 UChar
96 UCharCharacterIterator::first() {
97 pos = begin;
98 if(pos < end) {
99 return text[pos];
100 } else {
101 return DONE;
102 }
103 }
104
105 UChar
106 UCharCharacterIterator::firstPostInc() {
107 pos = begin;
108 if(pos < end) {
109 return text[pos++];
110 } else {
111 return DONE;
112 }
113 }
114
115 UChar
116 UCharCharacterIterator::last() {
117 pos = end;
118 if(pos > begin) {
119 return text[--pos];
120 } else {
121 return DONE;
122 }
123 }
124
125 UChar
126 UCharCharacterIterator::setIndex(int32_t position) {
127 if(position < begin) {
128 pos = begin;
129 } else if(position > end) {
130 pos = end;
131 } else {
132 pos = position;
133 }
134 if(pos < end) {
135 return text[pos];
136 } else {
137 return DONE;
138 }
139 }
140
141 UChar
142 UCharCharacterIterator::current() const {
143 if (pos >= begin && pos < end) {
144 return text[pos];
145 } else {
146 return DONE;
147 }
148 }
149
150 UChar
151 UCharCharacterIterator::next() {
152 if (pos + 1 < end) {
153 return text[++pos];
154 } else {
155 /* make current() return DONE */
156 pos = end;
157 return DONE;
158 }
159 }
160
161 UChar
162 UCharCharacterIterator::nextPostInc() {
163 if (pos < end) {
164 return text[pos++];
165 } else {
166 return DONE;
167 }
168 }
169
170 UBool
171 UCharCharacterIterator::hasNext() {
172 return (UBool)(pos < end ? TRUE : FALSE);
173 }
174
175 UChar
176 UCharCharacterIterator::previous() {
177 if (pos > begin) {
178 return text[--pos];
179 } else {
180 return DONE;
181 }
182 }
183
184 UBool
185 UCharCharacterIterator::hasPrevious() {
186 return (UBool)(pos > begin ? TRUE : FALSE);
187 }
188
189 UChar32
190 UCharCharacterIterator::first32() {
191 pos = begin;
192 if(pos < end) {
193 int32_t i = pos;
194 UChar32 c;
195 U16_NEXT(text, i, end, c);
196 return c;
197 } else {
198 return DONE;
199 }
200 }
201
202 UChar32
203 UCharCharacterIterator::first32PostInc() {
204 pos = begin;
205 if(pos < end) {
206 UChar32 c;
207 U16_NEXT(text, pos, end, c);
208 return c;
209 } else {
210 return DONE;
211 }
212 }
213
214 UChar32
215 UCharCharacterIterator::last32() {
216 pos = end;
217 if(pos > begin) {
218 UChar32 c;
219 U16_PREV(text, begin, pos, c);
220 return c;
221 } else {
222 return DONE;
223 }
224 }
225
226 UChar32
227 UCharCharacterIterator::setIndex32(int32_t position) {
228 if(position < begin) {
229 position = begin;
230 } else if(position > end) {
231 position = end;
232 }
233 if(position < end) {
234 U16_SET_CP_START(text, begin, position);
235 int32_t i = this->pos = position;
236 UChar32 c;
237 U16_NEXT(text, i, end, c);
238 return c;
239 } else {
240 this->pos = position;
241 return DONE;
242 }
243 }
244
245 UChar32
246 UCharCharacterIterator::current32() const {
247 if (pos >= begin && pos < end) {
248 UChar32 c;
249 U16_GET(text, begin, pos, end, c);
250 return c;
251 } else {
252 return DONE;
253 }
254 }
255
256 UChar32
257 UCharCharacterIterator::next32() {
258 if (pos < end) {
259 U16_FWD_1(text, pos, end);
260 if(pos < end) {
261 int32_t i = pos;
262 UChar32 c;
263 U16_NEXT(text, i, end, c);
264 return c;
265 }
266 }
267 /* make current() return DONE */
268 pos = end;
269 return DONE;
270 }
271
272 UChar32
273 UCharCharacterIterator::next32PostInc() {
274 if (pos < end) {
275 UChar32 c;
276 U16_NEXT(text, pos, end, c);
277 return c;
278 } else {
279 return DONE;
280 }
281 }
282
283 UChar32
284 UCharCharacterIterator::previous32() {
285 if (pos > begin) {
286 UChar32 c;
287 U16_PREV(text, begin, pos, c);
288 return c;
289 } else {
290 return DONE;
291 }
292 }
293
294 int32_t
295 UCharCharacterIterator::move(int32_t delta, CharacterIterator::EOrigin origin) {
296 switch(origin) {
297 case kStart:
298 pos = begin + delta;
299 break;
300 case kCurrent:
301 pos += delta;
302 break;
303 case kEnd:
304 pos = end + delta;
305 break;
306 default:
307 break;
308 }
309
310 if(pos < begin) {
311 pos = begin;
312 } else if(pos > end) {
313 pos = end;
314 }
315
316 return pos;
317 }
318
319 int32_t
320 UCharCharacterIterator::move32(int32_t delta, CharacterIterator::EOrigin origin) {
321 // this implementation relies on the "safe" version of the UTF macros
322 // (or the trustworthiness of the caller)
323 switch(origin) {
324 case kStart:
325 pos = begin;
326 if(delta > 0) {
327 U16_FWD_N(text, pos, end, delta);
328 }
329 break;
330 case kCurrent:
331 if(delta > 0) {
332 U16_FWD_N(text, pos, end, delta);
333 } else {
334 U16_BACK_N(text, begin, pos, -delta);
335 }
336 break;
337 case kEnd:
338 pos = end;
339 if(delta < 0) {
340 U16_BACK_N(text, begin, pos, -delta);
341 }
342 break;
343 default:
344 break;
345 }
346
347 return pos;
348 }
349
350 void UCharCharacterIterator::setText(const UChar* newText,
351 int32_t newTextLength) {
352 text = newText;
353 if(newText == 0 || newTextLength < 0) {
354 newTextLength = 0;
355 }
356 end = textLength = newTextLength;
357 pos = begin = 0;
358 }
359
360 void
361 UCharCharacterIterator::getText(UnicodeString& result) {
362 result = UnicodeString(text, textLength);
363 }
364
365 U_NAMESPACE_END

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial