Lines Matching refs:start
381 * [<TT>start</TT>, <TT>start + length</TT>) with the characters
383 * (The parameters "start" and "length" are not applied to the other text "text".)
384 * @param start the offset at which the compare operation begins
394 inline int8_t compare(int32_t start,
400 * [<TT>start</TT>, <TT>start + length</TT>) with the characters
403 * @param start the offset at which the compare operation begins
406 * @param srcStart the offset into <TT>srcText</TT> to start comparison
415 inline int8_t compare(int32_t start,
438 * [<TT>start</TT>, <TT>start + length</TT>) with the first
440 * @param start the offset at which the compare operation begins
450 inline int8_t compare(int32_t start,
456 * [<TT>start</TT>, <TT>start + length</TT>) with the characters
459 * @param start the offset at which the compare operation begins
462 * @param srcStart the offset into <TT>srcChars</TT> to start comparison
471 inline int8_t compare(int32_t start,
479 * [<TT>start</TT>, <TT>limit</TT>) with the characters
482 * @param start the offset at which the compare operation begins
485 * @param srcStart the offset into <TT>srcText</TT> to start comparison
494 inline int8_t compareBetween(int32_t start,
530 * @param start The start offset in this string at which the compare operation begins.
538 inline int8_t compareCodePointOrder(int32_t start,
553 * @param start The start offset in this string at which the compare operation begins.
556 * @param srcStart The start offset in that string at which the compare operation begins.
563 inline int8_t compareCodePointOrder(int32_t start,
601 * @param start The start offset in this string at which the compare operation begins.
609 inline int8_t compareCodePointOrder(int32_t start,
624 * @param start The start offset in this string at which the compare operation begins.
627 * @param srcStart The start offset in that string at which the compare operation begins.
634 inline int8_t compareCodePointOrder(int32_t start,
651 * @param start The start offset in this string at which the compare operation begins.
654 * @param srcStart The start offset in that string at which the compare operation begins.
661 inline int8_t compareCodePointOrderBetween(int32_t start,
691 * @param start The start offset in this string at which the compare operation begins.
707 inline int8_t caseCompare(int32_t start,
716 * @param start The start offset in this string at which the compare operation begins.
719 * @param srcStart The start offset in that string at which the compare operation begins.
734 inline int8_t caseCompare(int32_t start,
768 * @param start The start offset in this string at which the compare operation begins.
784 inline int8_t caseCompare(int32_t start,
793 * @param start The start offset in this string at which the compare operation begins.
796 * @param srcStart The start offset in that string at which the compare operation begins.
811 inline int8_t caseCompare(int32_t start,
822 * @param start The start offset in this string at which the compare operation begins.
825 * @param srcStart The start offset in that string at which the compare operation begins.
840 inline int8_t caseCompareBetween(int32_t start,
860 * @param srcStart the offset into <TT>srcText</TT> to start matching
885 * @param srcStart the offset into <TT>srcText</TT> to start matching
907 * @param srcStart the offset into <TT>srcText</TT> to start matching
932 * @param srcStart the offset into <TT>srcText</TT> to start matching
949 * @return The offset into this of the start of <TT>text</TT>,
957 * starting at offset <TT>start</TT>, using bitwise comparison.
959 * @param start The offset at which searching will start.
960 * @return The offset into this of the start of <TT>text</TT>,
965 int32_t start) const;
969 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
972 * @param start The offset at which searching will start.
974 * @return The offset into this of the start of <TT>text</TT>,
979 int32_t start,
984 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
990 * to start matching
992 * @param start the offset into this at which to start matching
994 * @return The offset into this of the start of <TT>text</TT>,
1001 int32_t start,
1007 * starting at offset <TT>start</TT>, using bitwise comparison.
1010 * @param start the offset into this at which to start matching
1011 * @return The offset into this of the start of <TT>text</TT>,
1017 int32_t start) const;
1021 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
1025 * @param start The offset at which searching will start.
1027 * @return The offset into this of the start of <TT>srcChars</TT>,
1033 int32_t start,
1038 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
1044 * to start matching
1046 * @param start the offset into this at which to start matching
1048 * @return The offset into this of the start of <TT>text</TT>,
1055 int32_t start,
1079 * starting at offset <TT>start</TT>, using bitwise comparison.
1081 * @param start The offset at which searching will start.
1086 int32_t start) const;
1090 * starting at offset <TT>start</TT>, using bitwise comparison.
1093 * @param start The offset at which searching will start.
1098 int32_t start) const;
1102 * in the range [<TT>start</TT>, <TT>start + length</TT>),
1105 * @param start the offset into this at which to start matching
1111 int32_t start,
1116 * in the range [<TT>start</TT>, <TT>start + length</TT>),
1120 * @param start the offset into this at which to start matching
1126 int32_t start,
1133 * @return The offset into this of the start of <TT>text</TT>,
1141 * starting at offset <TT>start</TT>, using bitwise comparison.
1143 * @param start The offset at which searching will start.
1144 * @return The offset into this of the start of <TT>text</TT>,
1149 int32_t start) const;
1153 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
1156 * @param start The offset at which searching will start.
1158 * @return The offset into this of the start of <TT>text</TT>,
1163 int32_t start,
1168 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
1174 * to start matching
1176 * @param start the offset into this at which to start matching
1178 * @return The offset into this of the start of <TT>text</TT>,
1185 int32_t start,
1190 * starting at offset <TT>start</TT>, using bitwise comparison.
1193 * @param start the offset into this at which to start matching
1194 * @return The offset into this of the start of <TT>text</TT>,
1200 int32_t start) const;
1204 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
1208 * @param start The offset at which searching will start.
1210 * @return The offset into this of the start of <TT>srcChars</TT>,
1216 int32_t start,
1221 * [<TT>start</TT>, <TT>start + length</TT>) of the characters
1227 * to start matching
1229 * @param start the offset into this at which to start matching
1231 * @return The offset into this of the start of <TT>text</TT>,
1238 int32_t start,
1262 * starting at offset <TT>start</TT>, using bitwise comparison.
1264 * @param start The offset at which searching will start.
1269 int32_t start) const;
1273 * starting at offset <TT>start</TT>, using bitwise comparison.
1276 * @param start The offset at which searching will start.
1281 int32_t start) const;
1285 * in the range [<TT>start</TT>, <TT>start + length</TT>),
1288 * @param start the offset into this at which to start matching
1294 int32_t start,
1299 * in the range [<TT>start</TT>, <TT>start + length</TT>),
1303 * @param start the offset into this at which to start matching
1309 int32_t start,
1392 * If delta<0 then the index is moved backward (toward the start of the string).
1419 * // go to the 3rd code point from the start of s (0-based)
1438 * [<tt>start</tt>, <tt>start + length</tt>) into the array <tt>dst</tt>,
1443 * @param start offset of first character which will be copied into the array
1451 inline void extract(int32_t start,
1483 * [<tt>start</tt>, <tt>start + length</tt>) into the UnicodeString
1485 * @param start offset of first character which will be copied
1491 inline void extract(int32_t start,
1496 * Copy the characters in the range [<tt>start</tt>, <tt>limit</tt>)
1498 * @param start offset of first character which will be copied into the array
1501 * must be at least (<tt>dstStart + (limit - start)</tt>).
1506 inline void extractBetween(int32_t start,
1512 * Copy the characters in the range [<tt>start</tt>, <tt>limit</tt>)
1514 * @param start offset of first character which will be copied
1520 virtual void extractBetween(int32_t start,
1526 * [<tt>start</TT>, <tt>start + startLength</TT>) into an array of characters.
1536 * @param start offset of first character which will be copied
1545 int32_t extract(int32_t start,
1555 * [<tt>start</TT>, <tt>start + length</TT>) into an array of characters
1563 * @param start offset of first character which will be copied
1572 int32_t extract(int32_t start,
1583 * [<tt>start</TT>, <tt>start + length</TT>) into an array of characters
1588 * extract(int32_t start, int32_t length, char *target, int32_t targetCapacity, enum EInvariant inv) const
1592 * @param start offset of first character which will be copied
1606 inline int32_t extract(int32_t start,
1613 * [<tt>start</TT>, <tt>start + length</TT>) into an array of characters
1622 * extract(int32_t start, int32_t length, char *target, int32_t targetCapacity, enum EInvariant inv) const
1626 * @param start offset of first character which will be copied
1640 int32_t extract(int32_t start,
1677 * @param start offset of the first character visible in the substring
1682 UnicodeString tempSubString(int32_t start=0, int32_t length=INT32_MAX) const;
1686 * Same as tempSubString(start, length) except that the substring range
1687 * is specified as a (start, limit) pair (with an exclusive limit index)
1688 * rather than a (start, length) pair.
1689 * @param start offset of the first character visible in the substring
1694 inline UnicodeString tempSubStringBetween(int32_t start, int32_t limit=INT32_MAX) const;
1764 * @param start the index of the first code unit to check
1771 countChar32(int32_t start=0, int32_t length=INT32_MAX) const;
1781 * Logically equivalent to (countChar32(start, length)>number).
1784 * @param start the index of the first code unit to check (0 for the entire string)
1786 * (use INT32_MAX for the entire string; remember that start/length
1797 hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const;
2163 * UnicodeString object at offset <TT>start</TT>. <TT>srcText</TT>
2190 * <TT>start</TT>. <TT>srcChars</TT> is not modified.
2205 * at offset <TT>start</TT>. <TT>srcChars</TT> is not modified.
2237 * object at offset <TT>start</TT>. <TT>srcText</TT> is not modified.
2238 * @param start the offset where the insertion begins
2247 inline UnicodeString& insert(int32_t start,
2254 * at offset <TT>start</TT>. <TT>srcText</TT> is not modified.
2255 * @param start the offset where the insertion begins
2260 inline UnicodeString& insert(int32_t start,
2266 * object at offset <TT>start</TT>. <TT>srcChars</TT> is not modified.
2267 * @param start the offset at which the insertion begins
2276 inline UnicodeString& insert(int32_t start,
2283 * at offset <TT>start</TT>. <TT>srcChars</TT> is not modified.
2284 * @param start the offset where the insertion begins
2290 inline UnicodeString& insert(int32_t start,
2296 * offset <TT>start</TT>.
2297 * @param start the offset at which the insertion occurs
2302 inline UnicodeString& insert(int32_t start,
2307 * offset <TT>start</TT>.
2308 * @param start the offset at which the insertion occurs
2313 inline UnicodeString& insert(int32_t start,
2321 * [<TT>start</TT>, <TT>start + length</TT>) with the characters in
2325 * @param start the offset at which the replace operation begins
2327 * <TT>start + length</TT> is not modified.
2336 UnicodeString& replace(int32_t start,
2344 * [<TT>start</TT>, <TT>start + length</TT>)
2347 * @param start the offset at which the replace operation begins
2349 * <TT>start + length</TT> is not modified.
2354 UnicodeString& replace(int32_t start,
2360 * [<TT>start</TT>, <TT>start + length</TT>) with the characters in
2364 * @param start the offset at which the replace operation begins
2366 * <TT>start + length</TT> is not modified.
2375 UnicodeString& replace(int32_t start,
2383 * [<TT>start</TT>, <TT>start + length</TT>) with the characters in
2385 * @param start the offset at which the replace operation begins
2387 * <TT>start + length</TT> is not modified.
2393 inline UnicodeString& replace(int32_t start,
2400 * [<TT>start</TT>, <TT>start + length</TT>) with the code unit
2402 * @param start the offset at which the replace operation begins
2404 * <TT>start + length</TT> is not modified.
2409 inline UnicodeString& replace(int32_t start,
2415 * [<TT>start</TT>, <TT>start + length</TT>) with the code point
2417 * @param start the offset at which the replace operation begins
2419 * <TT>start + length</TT> is not modified.
2424 UnicodeString& replace(int32_t start, int32_t length, UChar32 srcChar);
2427 * Replace the characters in the range [<TT>start</TT>, <TT>limit</TT>)
2429 * @param start the offset at which the replace operation begins
2435 start,
2440 * Replace the characters in the range [<TT>start</TT>, <TT>limit</TT>)
2443 * @param start the offset at which the replace operation begins
2453 inline UnicodeString& replaceBetween(int32_t start,
2461 * @param start the beginning index, inclusive; <code>0 <= start
2463 * @param limit the ending index, exclusive; <code>start <= limit
2465 * @param text the text to replace characters <code>start</code>
2469 virtual void handleReplaceBetween(int32_t start,
2485 * @param start the beginning index, inclusive; <code>0 <= start <=
2487 * @param limit the ending index, exclusive; <code>start <= limit <=
2490 * <code>start..limit-1</code> will be copied to <code>dest</code>.
2491 * Implementations of this method may assume that <code>dest <= start ||
2495 virtual void copy(int32_t start, int32_t limit, int32_t dest);
2513 * in the range [<TT>start</TT>, <TT>start + length</TT>).
2514 * @param start the start of the range in which replace will performed
2521 inline UnicodeString& findAndReplace(int32_t start,
2531 * in the range [<TT>start</TT>, <TT>start + length</TT>).
2532 * @param start the start of the range in which replace will performed
2535 * @param oldStart the start of the search range in <TT>oldText</TT>
2538 * @param newStart the start of the replacement range in <TT>newText</TT>
2543 UnicodeString& findAndReplace(int32_t start,
2564 * [<TT>start</TT>, <TT>start + length</TT>) from the UnicodeString object.
2565 * @param start the offset of the first character to remove
2570 inline UnicodeString& remove(int32_t start,
2575 * [<TT>start</TT>, <TT>limit</TT>) from the UnicodeString object.
2576 * @param start the offset of the first character to remove
2581 inline UnicodeString& removeBetween(int32_t start,
2586 * [<code>start</code>, <code>limit</code>) from the UnicodeString object.
2587 * Removes characters before <code>start</code> and at and after <code>limit</code>.
2588 * @param start the offset of the first character to retain
2593 inline UnicodeString &retainBetween(int32_t start, int32_t limit = INT32_MAX);
2598 * Pad the start of this UnicodeString with the character <TT>padChar</TT>.
2651 * Reverse the range [<TT>start</TT>, <TT>start + length</TT>) in
2653 * @param start the start of the range to reverse
2658 inline UnicodeString& reverse(int32_t start,
3363 * @param srcStart The offset into <tt>src</tt> at which to start copying.
3371 * @param srcStart The offset into <tt>src</tt> at which to start copying.
3532 // rather than having start+length on every method,
3535 toUTF8(int32_t start, int32_t len,
3545 doCompare(int32_t start,
3551 int8_t doCompare(int32_t start,
3558 doCompareCodePointOrder(int32_t start,
3564 int8_t doCompareCodePointOrder(int32_t start,
3571 doCaseCompare(int32_t start,
3579 doCaseCompare(int32_t start,
3587 int32_t start,
3591 int32_t start,
3595 int32_t start,
3599 int32_t start,
3602 void doExtract(int32_t start,
3607 inline void doExtract(int32_t start,
3613 UnicodeString& doReplace(int32_t start,
3619 UnicodeString& doReplace(int32_t start,
3628 UnicodeString& doReverse(int32_t start,
3634 // get pointer to start of array
3675 // Pin start and limit to acceptable values.
3676 inline void pinIndex(int32_t& start) const;
3677 inline void pinIndices(int32_t& start,
3683 int32_t doExtract(int32_t start, int32_t length,
3865 UnicodeString::pinIndex(int32_t& start) const
3868 if(start < 0) {
3869 start = 0;
3870 } else if(start > length()) {
3871 start = length();
3876 UnicodeString::pinIndices(int32_t& start,
3881 if(start < 0) {
3882 start = 0;
3883 } else if(start > len) {
3884 start = len;
3888 } else if(_length > (len - start)) {
3889 _length = (len - start);
3987 UnicodeString::doCompare(int32_t start,
3997 return doCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength);
4037 UnicodeString::compare(int32_t start,
4040 { return doCompare(start, _length, srcText, 0, srcText.length()); }
4048 UnicodeString::compare(int32_t start,
4053 { return doCompare(start, _length, srcText, srcStart, srcLength); }
4056 UnicodeString::compare(int32_t start,
4059 { return doCompare(start, _length, srcChars, 0, _length); }
4062 UnicodeString::compare(int32_t start,
4067 { return doCompare(start, _length, srcChars, srcStart, srcLength); }
4070 UnicodeString::compareBetween(int32_t start,
4075 { return doCompare(start, limit - start,
4079 UnicodeString::doCompareCodePointOrder(int32_t start,
4089 return doCompareCodePointOrder(start, thisLength, srcText.getArrayStart(), srcStart, srcLength);
4098 UnicodeString::compareCodePointOrder(int32_t start,
4101 { return doCompareCodePointOrder(start, _length, srcText, 0, srcText.length()); }
4109 UnicodeString::compareCodePointOrder(int32_t start,
4114 { return doCompareCodePointOrder(start, _length, srcText, srcStart, srcLength); }
4117 UnicodeString::compareCodePointOrder(int32_t start,
4120 { return doCompareCodePointOrder(start, _length, srcChars, 0, _length); }
4123 UnicodeString::compareCodePointOrder(int32_t start,
4128 { return doCompareCodePointOrder(start, _length, srcChars, srcStart, srcLength); }
4131 UnicodeString::compareCodePointOrderBetween(int32_t start,
4136 { return doCompareCodePointOrder(start, limit - start,
4140 UnicodeString::doCaseCompare(int32_t start,
4151 return doCaseCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength, options);
4161 UnicodeString::caseCompare(int32_t start,
4165 return doCaseCompare(start, _length, srcText, 0, srcText.length(), options);
4176 UnicodeString::caseCompare(int32_t start,
4182 return doCaseCompare(start, _length, srcText, srcStart, srcLength, options);
4186 UnicodeString::caseCompare(int32_t start,
4190 return doCaseCompare(start, _length, srcChars, 0, _length, options);
4194 UnicodeString::caseCompare(int32_t start,
4200 return doCaseCompare(start, _length, srcChars, srcStart, srcLength, options);
4204 UnicodeString::caseCompareBetween(int32_t start,
4210 return doCaseCompare(start, limit - start, srcText, srcStart, srcLimit - srcStart, options);
4217 int32_t start,
4223 start, _length);
4235 int32_t start) const {
4236 pinIndex(start);
4237 return indexOf(text, 0, text.length(), start, length() - start);
4242 int32_t start,
4244 { return indexOf(text, 0, text.length(), start, _length); }
4249 int32_t start) const {
4250 pinIndex(start);
4251 return indexOf(srcChars, 0, srcLength, start, length() - start);
4257 int32_t start,
4259 { return indexOf(srcChars, 0, srcLength, start, _length); }
4263 int32_t start,
4265 { return doIndexOf(c, start, _length); }
4269 int32_t start,
4271 { return doIndexOf(c, start, _length); }
4283 int32_t start) const {
4284 pinIndex(start);
4285 return doIndexOf(c, start, length() - start);
4290 int32_t start) const {
4291 pinIndex(start);
4292 return indexOf(c, start, length() - start);
4298 int32_t start,
4300 { return lastIndexOf(srcChars, 0, srcLength, start, _length); }
4305 int32_t start) const {
4306 pinIndex(start);
4307 return lastIndexOf(srcChars, 0, srcLength, start, length() - start);
4314 int32_t start,
4320 return lastIndexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
4328 int32_t start,
4330 { return lastIndexOf(text, 0, text.length(), start, _length); }
4334 int32_t start) const {
4335 pinIndex(start);
4336 return lastIndexOf(text, 0, text.length(), start, length() - start);
4345 int32_t start,
4347 { return doLastIndexOf(c, start, _length); }
4351 int32_t start,
4353 return doLastIndexOf(c, start, _length);
4367 int32_t start) const {
4368 pinIndex(start);
4369 return doLastIndexOf(c, start, length() - start);
4374 int32_t start) const {
4375 pinIndex(start);
4376 return lastIndexOf(c, start, length() - start);
4444 UnicodeString::replace(int32_t start,
4447 { return doReplace(start, _length, srcText, 0, srcText.length()); }
4450 UnicodeString::replace(int32_t start,
4455 { return doReplace(start, _length, srcText, srcStart, srcLength); }
4458 UnicodeString::replace(int32_t start,
4462 { return doReplace(start, _length, srcChars, 0, srcLength); }
4465 UnicodeString::replace(int32_t start,
4470 { return doReplace(start, _length, srcChars, srcStart, srcLength); }
4473 UnicodeString::replace(int32_t start,
4476 { return doReplace(start, _length, &srcChar, 0, 1); }
4479 UnicodeString::replaceBetween(int32_t start,
4482 { return doReplace(start, limit - start, srcText, 0, srcText.length()); }
4485 UnicodeString::replaceBetween(int32_t start,
4490 { return doReplace(start, limit - start, srcText, srcStart, srcLimit - srcStart); }
4499 UnicodeString::findAndReplace(int32_t start,
4503 { return findAndReplace(start, _length, oldText, 0, oldText.length(),
4510 UnicodeString::doExtract(int32_t start,
4513 { target.replace(0, target.length(), *this, start, _length); }
4516 UnicodeString::extract(int32_t start,
4520 { doExtract(start, _length, target, targetStart); }
4523 UnicodeString::extract(int32_t start,
4526 { doExtract(start, _length, target); }
4531 UnicodeString::extract(int32_t start,
4538 return extract(start, _length, dst, dst!=0 ? 0xffffffff : 0, codepage);
4544 UnicodeString::extractBetween(int32_t start,
4548 pinIndex(start);
4550 doExtract(start, limit - start, dst, dstStart);
4554 UnicodeString::tempSubStringBetween(int32_t start, int32_t limit) const {
4555 return tempSubString(start, limit - start);
4712 UnicodeString::insert(int32_t start,
4716 { return doReplace(start, 0, srcText, srcStart, srcLength); }
4719 UnicodeString::insert(int32_t start,
4721 { return doReplace(start, 0, srcText, 0, srcText.length()); }
4724 UnicodeString::insert(int32_t start,
4728 { return doReplace(start, 0, srcChars, srcStart, srcLength); }
4731 UnicodeString::insert(int32_t start,
4734 { return doReplace(start, 0, srcChars, 0, srcLength); }
4737 UnicodeString::insert(int32_t start,
4739 { return doReplace(start, 0, &srcChar, 0, 1); }
4742 UnicodeString::insert(int32_t start,
4744 { return replace(start, 0, srcChar); }
4760 UnicodeString::remove(int32_t start,
4763 if(start <= 0 && _length == INT32_MAX) {
4767 return doReplace(start, _length, NULL, 0, 0);
4771 UnicodeString::removeBetween(int32_t start,
4773 { return doReplace(start, limit - start, NULL, 0, 0); }
4776 UnicodeString::retainBetween(int32_t start, int32_t limit) {
4778 return doReplace(0, start, NULL, 0, 0);
4801 UnicodeString::reverse(int32_t start,
4803 { return doReverse(start, _length); }
