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