Lines Matching refs:index
111 static inline UBool positionIsValid(UTransPosition& index, int32_t len) {
112 return !(index.contextStart < 0 ||
113 index.start < index.contextStart ||
114 index.limit < index.start ||
115 index.contextLimit < index.limit ||
116 len < index.contextLimit);
183 * @param start the beginning index, inclusive; <code>0 <= start
185 * @param limit the ending index, exclusive; <code>start <= limit
187 * @return the new limit index, or -1
219 * at <code>index.contextLimit</code>, advancing
220 * <code>index.contextLimit</code> by <code>insertion.length()</code>.
222 * <code>text</code> between <code>index.start</code> and
223 * <code>index.contextLimit</code>. Characters before
224 * <code>index.start</code> will not be changed.
226 * <p>Upon return, values in <code>index</code> will be updated.
227 * <code>index.contextStart</code> will be advanced to the first
229 * <code>index.start</code> and <code>index.contextLimit</code> will
234 * with <code>index.contextStart</code> and <code>index.contextLimit</code>
236 * transliterated, and <code>index.start == index.contextStart</code>.
237 * Thereafter, <code>index</code> can be used without
251 * @param index an array of three integers.
253 * <ul><li><code>index.contextStart</code>: the beginning index,
254 * inclusive; <code>0 <= index.contextStart <= index.contextLimit</code>.
256 * <li><code>index.contextLimit</code>: the ending index, exclusive;
257 * <code>index.contextStart <= index.contextLimit <= text.length()</code>.
259 * <code>index.contextLimit</code>.
261 * <li><code>index.start</code>: the next character to be
262 * considered for transliteration; <code>index.contextStart <=
263 * index.start <= index.contextLimit</code>. Characters before
264 * <code>index.start</code> will not be changed by future calls
269 * <code>index.contextLimit</code>. If <code>null</code> then no text
275 * @exception IllegalArgumentException if <code>index</code>
279 UTransPosition& index,
282 _transliterate(text, index, &insertion, status);
293 * @param index an array of three integers. See {@link
297 * <code>index.contextLimit</code>.
301 UTransPosition& index,
305 _transliterate(text, index, &str, status);
315 * @param index an array of three integers. See {@link
320 UTransPosition& index,
322 _transliterate(text, index, 0, status);
332 * @param index the array of indices previously passed to {@link
336 UTransPosition& index) const {
337 if (!positionIsValid(index, text.length())) {
341 filteredTransliterate(text, index, FALSE, TRUE);
352 UTransPosition& index,
359 if (!positionIsValid(index, text.length())) {
364 // int32_t originalStart = index.contextStart;
366 text.handleReplaceBetween(index.limit, index.limit, *insertion);
367 index.limit += insertion->length();
368 index.contextLimit += insertion->length();
371 if (index.limit > 0 &&
372 U16_IS_LEAD(text.charAt(index.limit - 1))) {
380 filteredTransliterate(text, index, TRUE, TRUE);
407 int32_t newCS = index.start;
413 index.contextStart = uprv_max(newCS, originalStart);
426 UTransPosition& index,
432 handleTransliterate(text, index, incremental);
455 // set index.limit to the end of each unfiltered run before
457 // value of index.limit here. After each transliteration, we
460 int32_t globalLimit = index.limit;
476 // of unfiltered characters at or after index.start.
480 while (index.start < globalLimit &&
481 !filter->contains(c=text.char32At(index.start))) {
482 index.start += U16_LENGTH(c);
486 index.limit = index.start;
487 while (index.limit < globalLimit &&
488 filter->contains(c=text.char32At(index.limit))) {
489 index.limit += U16_LENGTH(c);
496 if (index.limit == index.start) {
497 // assert(index.start == globalLimit);
506 (index.limit < globalLimit ? FALSE : incremental);
540 int32_t runStart = index.start;
541 int32_t runLimit = index.limit;
558 int32_t passLimit = index.start;
579 index.limit = passLimit;
585 handleTransliterate(text, index, TRUE);
587 delta = index.limit - passLimit; // change in length
592 if (index.start != index.limit) {
595 int32_t rs = rollbackStart + delta - (index.limit - passStart);
598 text.handleReplaceBetween(passStart, index.limit, UnicodeString());
604 index.start = passStart;
605 index.limit = passLimit;
606 index.contextLimit -= delta;
614 passStart = passLimit = index.start;
639 index.start = passStart;
644 int32_t limit = index.limit;
645 handleTransliterate(text, index, isIncrementalRun);
646 delta = index.limit - limit; // change in length
655 if (!incremental && index.start != index.limit) {
657 index.start = index.limit;
676 index.limit = globalLimit;
680 UTransPosition& index,
682 filteredTransliterate(text, index, incremental, FALSE);
1163 const Transliterator& Transliterator::getElement(int32_t index, UErrorCode& ec) const {
1169 if (index < 0 || index >= n) {
1173 return (n == 1) ? *this : cpd->getTransliterator(index);
1313 * Return the index-th available ID. index must be between 0
1314 * and countAvailableIDs() - 1, inclusive. If index is out of
1317 const UnicodeString& U_EXPORT2 Transliterator::getAvailableID(int32_t index) {
1322 result = ®istry->getAvailableID(index);
1349 UnicodeString& U_EXPORT2 Transliterator::getAvailableSource(int32_t index,
1354 _getAvailableSource(index, result);
1365 UnicodeString& U_EXPORT2 Transliterator::getAvailableTarget(int32_t index,
1371 _getAvailableTarget(index, source, result);
1383 UnicodeString& U_EXPORT2 Transliterator::getAvailableVariant(int32_t index,
1390 _getAvailableVariant(index, source, target, result);
1399 UnicodeString& Transliterator::_getAvailableSource(int32_t index,
1401 return registry->getAvailableSource(index, result);
1408 UnicodeString& Transliterator::_getAvailableTarget(int32_t index,
1411 return registry->getAvailableTarget(index, source, result);
1419 UnicodeString& Transliterator::_getAvailableVariant(int32_t index,
1423 return registry->getAvailableVariant(index, source, target, result);
1465 /* The following code parses the index table located in
1466 * icu/data/translit/root.txt. The index is an n x 4 table