ICU 77.1  77.1
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
unistr.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **********************************************************************
5 * Copyright (C) 1998-2016, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 **********************************************************************
8 *
9 * File unistr.h
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 09/25/98 stephen Creation.
15 * 11/11/98 stephen Changed per 11/9 code review.
16 * 04/20/99 stephen Overhauled per 4/16 code review.
17 * 11/18/99 aliu Made to inherit from Replaceable. Added method
18 * handleReplaceBetween(); other methods unchanged.
19 * 06/25/01 grhoten Remove dependency on iostream.
20 ******************************************************************************
21 */
22 
23 #ifndef UNISTR_H
24 #define UNISTR_H
25 
31 #include "unicode/utypes.h"
32 
33 #if U_SHOW_CPLUSPLUS_API
34 
35 #include <cstddef>
36 #include <string_view>
37 #include "unicode/char16ptr.h"
38 #include "unicode/rep.h"
39 #include "unicode/std_string.h"
40 #include "unicode/stringpiece.h"
41 #include "unicode/bytestream.h"
42 
43 struct UConverter; // unicode/ucnv.h
44 
45 #ifndef USTRING_H
51 U_CAPI int32_t U_EXPORT2 u_strlen(const UChar *s);
52 #endif
53 
54 U_NAMESPACE_BEGIN
55 
56 #if !UCONFIG_NO_BREAK_ITERATION
57 class BreakIterator; // unicode/brkiter.h
58 #endif
59 class Edits;
60 
61 U_NAMESPACE_END
62 
63 // Not #ifndef U_HIDE_INTERNAL_API because UnicodeString needs the UStringCaseMapper.
70 typedef int32_t U_CALLCONV
71 UStringCaseMapper(int32_t caseLocale, uint32_t options,
72 #if !UCONFIG_NO_BREAK_ITERATION
73  icu::BreakIterator *iter,
74 #endif
75  char16_t *dest, int32_t destCapacity,
76  const char16_t *src, int32_t srcLength,
77  icu::Edits *edits,
78  UErrorCode &errorCode);
79 
80 U_NAMESPACE_BEGIN
81 
82 class Locale; // unicode/locid.h
83 class StringCharacterIterator;
84 class UnicodeStringAppendable; // unicode/appendable.h
85 
86 /* The <iostream> include has been moved to unicode/ustream.h */
87 
98 #define US_INV icu::UnicodeString::kInvariant
99 
120 #if !U_CHAR16_IS_TYPEDEF
121 # define UNICODE_STRING(cs, _length) icu::UnicodeString(true, u ## cs, _length)
122 #else
123 # define UNICODE_STRING(cs, _length) icu::UnicodeString(true, (const char16_t*)u ## cs, _length)
124 #endif
125 
135 #define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1)
136 
144 #ifndef UNISTR_FROM_CHAR_EXPLICIT
145 # if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION) || defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION)
146  // Auto-"explicit" in ICU library code.
147 # define UNISTR_FROM_CHAR_EXPLICIT explicit
148 # else
149  // Empty by default for source code compatibility.
150 # define UNISTR_FROM_CHAR_EXPLICIT
151 # endif
152 #endif
153 
164 #ifndef UNISTR_FROM_STRING_EXPLICIT
165 # if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION) || defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION)
166  // Auto-"explicit" in ICU library code.
167 # define UNISTR_FROM_STRING_EXPLICIT explicit
168 # else
169  // Empty by default for source code compatibility.
170 # define UNISTR_FROM_STRING_EXPLICIT
171 # endif
172 #endif
173 
207 #ifndef UNISTR_OBJECT_SIZE
208 # define UNISTR_OBJECT_SIZE 64
209 #endif
210 
295 class U_COMMON_API UnicodeString : public Replaceable
296 {
297 public:
298 
307  enum EInvariant {
312  kInvariant
313  };
314 
315  //========================================
316  // Read-only operations
317  //========================================
318 
319  /* Comparison - bitwise only - for international comparison use collation */
320 
328  inline bool operator== (const UnicodeString& text) const;
329 
330 #ifndef U_HIDE_DRAFT_API
346  template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
347  inline bool operator==(const S &text) const {
348  std::u16string_view sv(internal::toU16StringView(text));
349  uint32_t len; // unsigned to avoid a compiler warning
350  return !isBogus() && (len = length()) == sv.length() && doEquals(sv.data(), len);
351  }
352 #endif // U_HIDE_DRAFT_API
353 
361  inline bool operator!= (const UnicodeString& text) const;
362 
363 #ifndef U_HIDE_DRAFT_API
381  template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
382  inline bool operator!=(const S &text) const {
383  return !operator==(text);
384  }
385 #endif // U_HIDE_DRAFT_API
386 
394  inline UBool operator> (const UnicodeString& text) const;
395 
403  inline UBool operator< (const UnicodeString& text) const;
404 
412  inline UBool operator>= (const UnicodeString& text) const;
413 
421  inline UBool operator<= (const UnicodeString& text) const;
422 
434  inline int8_t compare(const UnicodeString& text) const;
435 
451  inline int8_t compare(int32_t start,
452  int32_t length,
453  const UnicodeString& text) const;
454 
472  inline int8_t compare(int32_t start,
473  int32_t length,
474  const UnicodeString& srcText,
475  int32_t srcStart,
476  int32_t srcLength) const;
477 
490  inline int8_t compare(ConstChar16Ptr srcChars,
491  int32_t srcLength) const;
492 
507  inline int8_t compare(int32_t start,
508  int32_t length,
509  const char16_t *srcChars) const;
510 
528  inline int8_t compare(int32_t start,
529  int32_t length,
530  const char16_t *srcChars,
531  int32_t srcStart,
532  int32_t srcLength) const;
533 
551  inline int8_t compareBetween(int32_t start,
552  int32_t limit,
553  const UnicodeString& srcText,
554  int32_t srcStart,
555  int32_t srcLimit) const;
556 
574  inline int8_t compareCodePointOrder(const UnicodeString& text) const;
575 
595  inline int8_t compareCodePointOrder(int32_t start,
596  int32_t length,
597  const UnicodeString& srcText) const;
598 
620  inline int8_t compareCodePointOrder(int32_t start,
621  int32_t length,
622  const UnicodeString& srcText,
623  int32_t srcStart,
624  int32_t srcLength) const;
625 
644  inline int8_t compareCodePointOrder(ConstChar16Ptr srcChars,
645  int32_t srcLength) const;
646 
666  inline int8_t compareCodePointOrder(int32_t start,
667  int32_t length,
668  const char16_t *srcChars) const;
669 
691  inline int8_t compareCodePointOrder(int32_t start,
692  int32_t length,
693  const char16_t *srcChars,
694  int32_t srcStart,
695  int32_t srcLength) const;
696 
718  inline int8_t compareCodePointOrderBetween(int32_t start,
719  int32_t limit,
720  const UnicodeString& srcText,
721  int32_t srcStart,
722  int32_t srcLimit) const;
723 
742  inline int8_t caseCompare(const UnicodeString& text, uint32_t options) const;
743 
764  inline int8_t caseCompare(int32_t start,
765  int32_t length,
766  const UnicodeString& srcText,
767  uint32_t options) const;
768 
791  inline int8_t caseCompare(int32_t start,
792  int32_t length,
793  const UnicodeString& srcText,
794  int32_t srcStart,
795  int32_t srcLength,
796  uint32_t options) const;
797 
817  inline int8_t caseCompare(ConstChar16Ptr srcChars,
818  int32_t srcLength,
819  uint32_t options) const;
820 
841  inline int8_t caseCompare(int32_t start,
842  int32_t length,
843  const char16_t *srcChars,
844  uint32_t options) const;
845 
868  inline int8_t caseCompare(int32_t start,
869  int32_t length,
870  const char16_t *srcChars,
871  int32_t srcStart,
872  int32_t srcLength,
873  uint32_t options) const;
874 
897  inline int8_t caseCompareBetween(int32_t start,
898  int32_t limit,
899  const UnicodeString& srcText,
900  int32_t srcStart,
901  int32_t srcLimit,
902  uint32_t options) const;
903 
911  inline UBool startsWith(const UnicodeString& text) const;
912 
923  inline UBool startsWith(const UnicodeString& srcText,
924  int32_t srcStart,
925  int32_t srcLength) const;
926 
935  inline UBool startsWith(ConstChar16Ptr srcChars,
936  int32_t srcLength) const;
937 
947  inline UBool startsWith(const char16_t *srcChars,
948  int32_t srcStart,
949  int32_t srcLength) const;
950 
958  inline UBool endsWith(const UnicodeString& text) const;
959 
970  inline UBool endsWith(const UnicodeString& srcText,
971  int32_t srcStart,
972  int32_t srcLength) const;
973 
982  inline UBool endsWith(ConstChar16Ptr srcChars,
983  int32_t srcLength) const;
984 
995  inline UBool endsWith(const char16_t *srcChars,
996  int32_t srcStart,
997  int32_t srcLength) const;
998 
999 
1000  /* Searching - bitwise only */
1001 
1010  inline int32_t indexOf(const UnicodeString& text) const;
1011 
1021  inline int32_t indexOf(const UnicodeString& text,
1022  int32_t start) const;
1023 
1035  inline int32_t indexOf(const UnicodeString& text,
1036  int32_t start,
1037  int32_t length) const;
1038 
1055  inline int32_t indexOf(const UnicodeString& srcText,
1056  int32_t srcStart,
1057  int32_t srcLength,
1058  int32_t start,
1059  int32_t length) const;
1060 
1072  inline int32_t indexOf(const char16_t *srcChars,
1073  int32_t srcLength,
1074  int32_t start) const;
1075 
1088  inline int32_t indexOf(ConstChar16Ptr srcChars,
1089  int32_t srcLength,
1090  int32_t start,
1091  int32_t length) const;
1092 
1109  int32_t indexOf(const char16_t *srcChars,
1110  int32_t srcStart,
1111  int32_t srcLength,
1112  int32_t start,
1113  int32_t length) const;
1114 
1122  inline int32_t indexOf(char16_t c) const;
1123 
1132  inline int32_t indexOf(UChar32 c) const;
1133 
1142  inline int32_t indexOf(char16_t c,
1143  int32_t start) const;
1144 
1154  inline int32_t indexOf(UChar32 c,
1155  int32_t start) const;
1156 
1167  inline int32_t indexOf(char16_t c,
1168  int32_t start,
1169  int32_t length) const;
1170 
1182  inline int32_t indexOf(UChar32 c,
1183  int32_t start,
1184  int32_t length) const;
1185 
1194  inline int32_t lastIndexOf(const UnicodeString& text) const;
1195 
1205  inline int32_t lastIndexOf(const UnicodeString& text,
1206  int32_t start) const;
1207 
1219  inline int32_t lastIndexOf(const UnicodeString& text,
1220  int32_t start,
1221  int32_t length) const;
1222 
1239  inline int32_t lastIndexOf(const UnicodeString& srcText,
1240  int32_t srcStart,
1241  int32_t srcLength,
1242  int32_t start,
1243  int32_t length) const;
1244 
1255  inline int32_t lastIndexOf(const char16_t *srcChars,
1256  int32_t srcLength,
1257  int32_t start) const;
1258 
1271  inline int32_t lastIndexOf(ConstChar16Ptr srcChars,
1272  int32_t srcLength,
1273  int32_t start,
1274  int32_t length) const;
1275 
1292  int32_t lastIndexOf(const char16_t *srcChars,
1293  int32_t srcStart,
1294  int32_t srcLength,
1295  int32_t start,
1296  int32_t length) const;
1297 
1305  inline int32_t lastIndexOf(char16_t c) const;
1306 
1315  inline int32_t lastIndexOf(UChar32 c) const;
1316 
1325  inline int32_t lastIndexOf(char16_t c,
1326  int32_t start) const;
1327 
1337  inline int32_t lastIndexOf(UChar32 c,
1338  int32_t start) const;
1339 
1350  inline int32_t lastIndexOf(char16_t c,
1351  int32_t start,
1352  int32_t length) const;
1353 
1365  inline int32_t lastIndexOf(UChar32 c,
1366  int32_t start,
1367  int32_t length) const;
1368 
1369 
1370  /* Character access */
1371 
1380  inline char16_t charAt(int32_t offset) const;
1381 
1389  inline char16_t operator[] (int32_t offset) const;
1390 
1402  UChar32 char32At(int32_t offset) const;
1403 
1419  int32_t getChar32Start(int32_t offset) const;
1420 
1437  int32_t getChar32Limit(int32_t offset) const;
1438 
1489  int32_t moveIndex32(int32_t index, int32_t delta) const;
1490 
1491  /* Substring extraction */
1492 
1508  inline void extract(int32_t start,
1509  int32_t length,
1510  Char16Ptr dst,
1511  int32_t dstStart = 0) const;
1512 
1534  int32_t
1535  extract(Char16Ptr dest, int32_t destCapacity,
1536  UErrorCode &errorCode) const;
1537 
1547  inline void extract(int32_t start,
1548  int32_t length,
1549  UnicodeString& target) const;
1550 
1562  inline void extractBetween(int32_t start,
1563  int32_t limit,
1564  char16_t *dst,
1565  int32_t dstStart = 0) const;
1566 
1575  virtual void extractBetween(int32_t start,
1576  int32_t limit,
1577  UnicodeString& target) const override;
1578 
1600  int32_t extract(int32_t start,
1601  int32_t startLength,
1602  char *target,
1603  int32_t targetCapacity,
1604  enum EInvariant inv) const;
1605 
1606 #if U_CHARSET_IS_UTF8 || !UCONFIG_NO_CONVERSION
1607 
1627  int32_t extract(int32_t start,
1628  int32_t startLength,
1629  char *target,
1630  uint32_t targetLength) const;
1631 
1632 #endif
1633 
1634 #if !UCONFIG_NO_CONVERSION
1635 
1661  inline int32_t extract(int32_t start,
1662  int32_t startLength,
1663  char* target,
1664  const char* codepage = nullptr) const;
1665 
1695  int32_t extract(int32_t start,
1696  int32_t startLength,
1697  char *target,
1698  uint32_t targetLength,
1699  const char *codepage) const;
1700 
1718  int32_t extract(char *dest, int32_t destCapacity,
1719  UConverter *cnv,
1720  UErrorCode &errorCode) const;
1721 
1722 #endif
1723 
1737  UnicodeString tempSubString(int32_t start=0, int32_t length=INT32_MAX) const;
1738 
1749  inline UnicodeString tempSubStringBetween(int32_t start, int32_t limit=INT32_MAX) const;
1750 
1762  void toUTF8(ByteSink &sink) const;
1763 
1776  template<typename StringClass>
1777  StringClass &toUTF8String(StringClass &result) const {
1778  StringByteSink<StringClass> sbs(&result, length());
1779  toUTF8(sbs);
1780  return result;
1781  }
1782 
1798  int32_t toUTF32(UChar32 *utf32, int32_t capacity, UErrorCode &errorCode) const;
1799 
1800  /* Length operations */
1801 
1810  inline int32_t length() const;
1811 
1825  int32_t
1826  countChar32(int32_t start=0, int32_t length=INT32_MAX) const;
1827 
1851  UBool
1852  hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const;
1853 
1859  inline UBool isEmpty() const;
1860 
1870  inline int32_t getCapacity() const;
1871 
1872  /* Other operations */
1873 
1879  inline int32_t hashCode() const;
1880 
1893  inline UBool isBogus() const;
1894 
1895  //========================================
1896  // Write operations
1897  //========================================
1898 
1899  /* Assignment operations */
1900 
1919  UnicodeString &operator=(const UnicodeString &srcText);
1920 
1946  UnicodeString &fastCopyFrom(const UnicodeString &src);
1947 
1948 #ifndef U_HIDE_DRAFT_API
1959  template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
1960  inline UnicodeString &operator=(const S &src) {
1961  unBogus();
1962  return doReplace(0, length(), internal::toU16StringView(src));
1963  }
1964 #endif // U_HIDE_DRAFT_API
1965 
1974  UnicodeString &operator=(UnicodeString &&src) noexcept;
1975 
1981  void swap(UnicodeString &other) noexcept;
1982 
1989  friend inline void U_EXPORT2
1990  swap(UnicodeString &s1, UnicodeString &s2) noexcept {
1991  s1.swap(s2);
1992  }
1993 
2001  inline UnicodeString& operator= (char16_t ch);
2002 
2010  inline UnicodeString& operator= (UChar32 ch);
2011 
2023  inline UnicodeString& setTo(const UnicodeString& srcText,
2024  int32_t srcStart);
2025 
2039  inline UnicodeString& setTo(const UnicodeString& srcText,
2040  int32_t srcStart,
2041  int32_t srcLength);
2042 
2051  inline UnicodeString& setTo(const UnicodeString& srcText);
2052 
2061  inline UnicodeString& setTo(const char16_t *srcChars,
2062  int32_t srcLength);
2063 
2072  inline UnicodeString& setTo(char16_t srcChar);
2073 
2082  inline UnicodeString& setTo(UChar32 srcChar);
2083 
2107  UnicodeString &setTo(UBool isTerminated,
2108  ConstChar16Ptr text,
2109  int32_t textLength);
2110 
2130  UnicodeString &setTo(char16_t *buffer,
2131  int32_t buffLength,
2132  int32_t buffCapacity);
2133 
2173  void setToBogus();
2174 
2182  UnicodeString& setCharAt(int32_t offset,
2183  char16_t ch);
2184 
2185 
2186  /* Append operations */
2187 
2195  inline UnicodeString& operator+= (char16_t ch);
2196 
2204  inline UnicodeString& operator+= (UChar32 ch);
2205 
2213  inline UnicodeString& operator+= (const UnicodeString& srcText);
2214 
2215 #ifndef U_HIDE_DRAFT_API
2226  template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
2227  inline UnicodeString& operator+=(const S &src) {
2228  return doAppend(internal::toU16StringView(src));
2229  }
2230 #endif // U_HIDE_DRAFT_API
2231 
2246  inline UnicodeString& append(const UnicodeString& srcText,
2247  int32_t srcStart,
2248  int32_t srcLength);
2249 
2257  inline UnicodeString& append(const UnicodeString& srcText);
2258 
2272  inline UnicodeString& append(const char16_t *srcChars,
2273  int32_t srcStart,
2274  int32_t srcLength);
2275 
2285  inline UnicodeString& append(ConstChar16Ptr srcChars,
2286  int32_t srcLength);
2287 
2288 #ifndef U_HIDE_DRAFT_API
2299  template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
2300  inline UnicodeString& append(const S &src) {
2301  return doAppend(internal::toU16StringView(src));
2302  }
2303 #endif // U_HIDE_DRAFT_API
2304 
2311  inline UnicodeString& append(char16_t srcChar);
2312 
2319  UnicodeString& append(UChar32 srcChar);
2320 
2321 
2322  /* Insert operations */
2323 
2337  inline UnicodeString& insert(int32_t start,
2338  const UnicodeString& srcText,
2339  int32_t srcStart,
2340  int32_t srcLength);
2341 
2350  inline UnicodeString& insert(int32_t start,
2351  const UnicodeString& srcText);
2352 
2366  inline UnicodeString& insert(int32_t start,
2367  const char16_t *srcChars,
2368  int32_t srcStart,
2369  int32_t srcLength);
2370 
2380  inline UnicodeString& insert(int32_t start,
2381  ConstChar16Ptr srcChars,
2382  int32_t srcLength);
2383 
2392  inline UnicodeString& insert(int32_t start,
2393  char16_t srcChar);
2394 
2403  inline UnicodeString& insert(int32_t start,
2404  UChar32 srcChar);
2405 
2406 
2407  /* Replace operations */
2408 
2426  inline UnicodeString& replace(int32_t start,
2427  int32_t length,
2428  const UnicodeString& srcText,
2429  int32_t srcStart,
2430  int32_t srcLength);
2431 
2444  inline UnicodeString& replace(int32_t start,
2445  int32_t length,
2446  const UnicodeString& srcText);
2447 
2465  inline UnicodeString& replace(int32_t start,
2466  int32_t length,
2467  const char16_t *srcChars,
2468  int32_t srcStart,
2469  int32_t srcLength);
2470 
2483  inline UnicodeString& replace(int32_t start,
2484  int32_t length,
2485  ConstChar16Ptr srcChars,
2486  int32_t srcLength);
2487 
2499  inline UnicodeString& replace(int32_t start,
2500  int32_t length,
2501  char16_t srcChar);
2502 
2514  UnicodeString& replace(int32_t start, int32_t length, UChar32 srcChar);
2515 
2525  inline UnicodeString& replaceBetween(int32_t start,
2526  int32_t limit,
2527  const UnicodeString& srcText);
2528 
2543  inline UnicodeString& replaceBetween(int32_t start,
2544  int32_t limit,
2545  const UnicodeString& srcText,
2546  int32_t srcStart,
2547  int32_t srcLimit);
2548 
2556  virtual void handleReplaceBetween(int32_t start,
2557  int32_t limit,
2558  const UnicodeString& text) override;
2559 
2565  virtual UBool hasMetaData() const override;
2566 
2580  virtual void copy(int32_t start, int32_t limit, int32_t dest) override;
2581 
2582  /* Search and replace operations */
2583 
2592  inline UnicodeString& findAndReplace(const UnicodeString& oldText,
2593  const UnicodeString& newText);
2594 
2606  inline UnicodeString& findAndReplace(int32_t start,
2607  int32_t length,
2608  const UnicodeString& oldText,
2609  const UnicodeString& newText);
2610 
2628  UnicodeString& findAndReplace(int32_t start,
2629  int32_t length,
2630  const UnicodeString& oldText,
2631  int32_t oldStart,
2632  int32_t oldLength,
2633  const UnicodeString& newText,
2634  int32_t newStart,
2635  int32_t newLength);
2636 
2637 
2638  /* Remove operations */
2639 
2648  inline UnicodeString& remove();
2649 
2658  inline UnicodeString& remove(int32_t start,
2659  int32_t length = static_cast<int32_t>(INT32_MAX));
2660 
2669  inline UnicodeString& removeBetween(int32_t start,
2670  int32_t limit = static_cast<int32_t>(INT32_MAX));
2671 
2681  inline UnicodeString &retainBetween(int32_t start, int32_t limit = INT32_MAX);
2682 
2683  /* Length operations */
2684 
2696  UBool padLeading(int32_t targetLength,
2697  char16_t padChar = 0x0020);
2698 
2710  UBool padTrailing(int32_t targetLength,
2711  char16_t padChar = 0x0020);
2712 
2719  inline UBool truncate(int32_t targetLength);
2720 
2726  UnicodeString& trim();
2727 
2728  /* Miscellaneous operations */
2729 
2735  inline UnicodeString& reverse();
2736 
2745  inline UnicodeString& reverse(int32_t start,
2746  int32_t length);
2747 
2754  UnicodeString& toUpper();
2755 
2763  UnicodeString& toUpper(const Locale& locale);
2764 
2771  UnicodeString& toLower();
2772 
2780  UnicodeString& toLower(const Locale& locale);
2781 
2782 #if !UCONFIG_NO_BREAK_ITERATION
2783 
2810  UnicodeString &toTitle(BreakIterator *titleIter);
2811 
2839  UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale);
2840 
2871  UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale, uint32_t options);
2872 
2873 #endif
2874 
2888  UnicodeString &foldCase(uint32_t options=0 /*U_FOLD_CASE_DEFAULT*/);
2889 
2890  //========================================
2891  // Access to the internal buffer
2892  //========================================
2893 
2937  char16_t *getBuffer(int32_t minCapacity);
2938 
2959  void releaseBuffer(int32_t newLength=-1);
2960 
2991  inline const char16_t *getBuffer() const;
2992 
3026  const char16_t *getTerminatedBuffer();
3027 
3028 #ifndef U_HIDE_DRAFT_API
3035  inline operator std::u16string_view() const {
3036  return {getBuffer(), static_cast<std::u16string_view::size_type>(length())};
3037  }
3038 
3039 #if U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN)
3049  inline operator std::wstring_view() const {
3050  const char16_t *p = getBuffer();
3051 #ifdef U_ALIASING_BARRIER
3052  U_ALIASING_BARRIER(p);
3053 #endif
3054  return { reinterpret_cast<const wchar_t *>(p), (std::wstring_view::size_type)length() };
3055  }
3056 #endif // U_SIZEOF_WCHAR_T
3057 #endif // U_HIDE_DRAFT_API
3058 
3059  //========================================
3060  // Constructors
3061  //========================================
3062 
3066  inline UnicodeString();
3067 
3079  UnicodeString(int32_t capacity, UChar32 c, int32_t count);
3080 
3090  UNISTR_FROM_CHAR_EXPLICIT UnicodeString(char16_t ch);
3091 
3101  UNISTR_FROM_CHAR_EXPLICIT UnicodeString(UChar32 ch);
3102 
3103 #ifdef U_HIDE_DRAFT_API
3123  UNISTR_FROM_STRING_EXPLICIT UnicodeString(const char16_t *text) :
3124  UnicodeString(text, -1) {}
3125 #endif // U_HIDE_DRAFT_API
3126 
3127 #if !U_CHAR16_IS_TYPEDEF && \
3128  (defined(U_HIDE_DRAFT_API) || (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION >= 180000))
3148  UNISTR_FROM_STRING_EXPLICIT UnicodeString(const uint16_t *text) :
3149  UnicodeString(ConstChar16Ptr(text), -1) {}
3150 #endif
3151 
3152 #if defined(U_HIDE_DRAFT_API) && (U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN))
3173  UNISTR_FROM_STRING_EXPLICIT UnicodeString(const wchar_t *text) :
3174  UnicodeString(ConstChar16Ptr(text), -1) {}
3175 #endif
3176 
3187  UNISTR_FROM_STRING_EXPLICIT inline UnicodeString(const std::nullptr_t text);
3188 
3205  UnicodeString(const char16_t *text,
3206  int32_t textLength);
3207 
3208 #if !U_CHAR16_IS_TYPEDEF
3225  UnicodeString(const uint16_t *text, int32_t textLength) :
3226  UnicodeString(ConstChar16Ptr(text), textLength) {}
3227 #endif
3228 
3229 #if U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN)
3247  UnicodeString(const wchar_t *text, int32_t textLength) :
3248  UnicodeString(ConstChar16Ptr(text), textLength) {}
3249 #endif
3250 
3258  inline UnicodeString(const std::nullptr_t text, int32_t textLength);
3259 
3260 #ifndef U_HIDE_DRAFT_API
3273  template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
3274  UNISTR_FROM_STRING_EXPLICIT UnicodeString(const S &text) {
3275  fUnion.fFields.fLengthAndFlags = kShortString;
3276  doAppend(internal::toU16StringViewNullable(text));
3277  }
3278 #endif // U_HIDE_DRAFT_API
3279 
3310  UnicodeString(UBool isTerminated,
3311  ConstChar16Ptr text,
3312  int32_t textLength);
3313 
3332  UnicodeString(char16_t *buffer, int32_t buffLength, int32_t buffCapacity);
3333 
3334 #if !U_CHAR16_IS_TYPEDEF
3343  UnicodeString(uint16_t *buffer, int32_t buffLength, int32_t buffCapacity) :
3344  UnicodeString(Char16Ptr(buffer), buffLength, buffCapacity) {}
3345 #endif
3346 
3347 #if U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN)
3357  UnicodeString(wchar_t *buffer, int32_t buffLength, int32_t buffCapacity) :
3358  UnicodeString(Char16Ptr(buffer), buffLength, buffCapacity) {}
3359 #endif
3360 
3369  inline UnicodeString(std::nullptr_t buffer, int32_t buffLength, int32_t buffCapacity);
3370 
3371 #if U_CHARSET_IS_UTF8 || !UCONFIG_NO_CONVERSION
3372 
3396  UNISTR_FROM_STRING_EXPLICIT UnicodeString(const char *codepageData);
3397 
3406  UnicodeString(const char *codepageData, int32_t dataLength);
3407 
3408 #endif
3409 
3410 #if !UCONFIG_NO_CONVERSION
3411 
3429  UnicodeString(const char *codepageData, const char *codepage);
3430 
3448  UnicodeString(const char *codepageData, int32_t dataLength, const char *codepage);
3449 
3471  UnicodeString(
3472  const char *src, int32_t srcLength,
3473  UConverter *cnv,
3474  UErrorCode &errorCode);
3475 
3476 #endif
3477 
3510  UnicodeString(const char *src, int32_t textLength, enum EInvariant inv);
3511 
3512 
3529  UnicodeString(const UnicodeString& that);
3530 
3537  UnicodeString(UnicodeString &&src) noexcept;
3538 
3545  UnicodeString(const UnicodeString& src, int32_t srcStart);
3546 
3554  UnicodeString(const UnicodeString& src, int32_t srcStart, int32_t srcLength);
3555 
3569  virtual UnicodeString *clone() const override;
3570 
3574  virtual ~UnicodeString();
3575 
3576 #ifndef U_HIDE_DRAFT_API
3599  template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
3600  static inline UnicodeString readOnlyAlias(const S &text) {
3601  return readOnlyAliasFromU16StringView(internal::toU16StringView(text));
3602  }
3603 
3623  static inline UnicodeString readOnlyAlias(const UnicodeString &text) {
3624  return readOnlyAliasFromUnicodeString(text);
3625  }
3626 #endif // U_HIDE_DRAFT_API
3627 
3641  static UnicodeString fromUTF8(StringPiece utf8);
3642 
3654  static UnicodeString fromUTF32(const UChar32 *utf32, int32_t length);
3655 
3656  /* Miscellaneous operations */
3657 
3692  UnicodeString unescape() const;
3693 
3713  UChar32 unescapeAt(int32_t &offset) const;
3714 
3720  static UClassID U_EXPORT2 getStaticClassID();
3721 
3727  virtual UClassID getDynamicClassID() const override;
3728 
3729  //========================================
3730  // Implementation methods
3731  //========================================
3732 
3733 protected:
3738  virtual int32_t getLength() const override;
3739 
3745  virtual char16_t getCharAt(int32_t offset) const override;
3746 
3752  virtual UChar32 getChar32At(int32_t offset) const override;
3753 
3754 private:
3755  static UnicodeString readOnlyAliasFromU16StringView(std::u16string_view text);
3756  static UnicodeString readOnlyAliasFromUnicodeString(const UnicodeString &text);
3757 
3758  // For char* constructors. Could be made public.
3759  UnicodeString &setToUTF8(StringPiece utf8);
3760  // For extract(char*).
3761  // We could make a toUTF8(target, capacity, errorCode) public but not
3762  // this version: New API will be cleaner if we make callers create substrings
3763  // rather than having start+length on every method,
3764  // and it should take a UErrorCode&.
3765  int32_t
3766  toUTF8(int32_t start, int32_t len,
3767  char *target, int32_t capacity) const;
3768 
3773  inline UBool doEquals(const UnicodeString &text, int32_t len) const {
3774  return doEquals(text.getArrayStart(), len);
3775  }
3776  UBool doEquals(const char16_t *text, int32_t len) const;
3777 
3778  inline UBool
3779  doEqualsSubstring(int32_t start,
3780  int32_t length,
3781  const UnicodeString& srcText,
3782  int32_t srcStart,
3783  int32_t srcLength) const;
3784 
3785  UBool doEqualsSubstring(int32_t start,
3786  int32_t length,
3787  const char16_t *srcChars,
3788  int32_t srcStart,
3789  int32_t srcLength) const;
3790 
3791  inline int8_t
3792  doCompare(int32_t start,
3793  int32_t length,
3794  const UnicodeString& srcText,
3795  int32_t srcStart,
3796  int32_t srcLength) const;
3797 
3798  int8_t doCompare(int32_t start,
3799  int32_t length,
3800  const char16_t *srcChars,
3801  int32_t srcStart,
3802  int32_t srcLength) const;
3803 
3804  inline int8_t
3805  doCompareCodePointOrder(int32_t start,
3806  int32_t length,
3807  const UnicodeString& srcText,
3808  int32_t srcStart,
3809  int32_t srcLength) const;
3810 
3811  int8_t doCompareCodePointOrder(int32_t start,
3812  int32_t length,
3813  const char16_t *srcChars,
3814  int32_t srcStart,
3815  int32_t srcLength) const;
3816 
3817  inline int8_t
3818  doCaseCompare(int32_t start,
3819  int32_t length,
3820  const UnicodeString &srcText,
3821  int32_t srcStart,
3822  int32_t srcLength,
3823  uint32_t options) const;
3824 
3825  int8_t
3826  doCaseCompare(int32_t start,
3827  int32_t length,
3828  const char16_t *srcChars,
3829  int32_t srcStart,
3830  int32_t srcLength,
3831  uint32_t options) const;
3832 
3833  int32_t doIndexOf(char16_t c,
3834  int32_t start,
3835  int32_t length) const;
3836 
3837  int32_t doIndexOf(UChar32 c,
3838  int32_t start,
3839  int32_t length) const;
3840 
3841  int32_t doLastIndexOf(char16_t c,
3842  int32_t start,
3843  int32_t length) const;
3844 
3845  int32_t doLastIndexOf(UChar32 c,
3846  int32_t start,
3847  int32_t length) const;
3848 
3849  void doExtract(int32_t start,
3850  int32_t length,
3851  char16_t *dst,
3852  int32_t dstStart) const;
3853 
3854  inline void doExtract(int32_t start,
3855  int32_t length,
3856  UnicodeString& target) const;
3857 
3858  inline char16_t doCharAt(int32_t offset) const;
3859 
3860  UnicodeString& doReplace(int32_t start,
3861  int32_t length,
3862  const UnicodeString& srcText,
3863  int32_t srcStart,
3864  int32_t srcLength);
3865 
3866  UnicodeString& doReplace(int32_t start,
3867  int32_t length,
3868  const char16_t *srcChars,
3869  int32_t srcStart,
3870  int32_t srcLength);
3871  UnicodeString& doReplace(int32_t start, int32_t length, std::u16string_view src);
3872 
3873  UnicodeString& doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcLength);
3874  UnicodeString& doAppend(const char16_t *srcChars, int32_t srcStart, int32_t srcLength);
3875  UnicodeString& doAppend(std::u16string_view src);
3876 
3877  UnicodeString& doReverse(int32_t start,
3878  int32_t length);
3879 
3880  // calculate hash code
3881  int32_t doHashCode() const;
3882 
3883  // get pointer to start of array
3884  // these do not check for kOpenGetBuffer, unlike the public getBuffer() function
3885  inline char16_t* getArrayStart();
3886  inline const char16_t* getArrayStart() const;
3887 
3888  inline UBool hasShortLength() const;
3889  inline int32_t getShortLength() const;
3890 
3891  // A UnicodeString object (not necessarily its current buffer)
3892  // is writable unless it isBogus() or it has an "open" getBuffer(minCapacity).
3893  inline UBool isWritable() const;
3894 
3895  // Is the current buffer writable?
3896  inline UBool isBufferWritable() const;
3897 
3898  // None of the following does releaseArray().
3899  inline void setZeroLength();
3900  inline void setShortLength(int32_t len);
3901  inline void setLength(int32_t len);
3902  inline void setToEmpty();
3903  inline void setArray(char16_t *array, int32_t len, int32_t capacity); // sets length but not flags
3904 
3905  // allocate the array; result may be the stack buffer
3906  // sets refCount to 1 if appropriate
3907  // sets fArray, fCapacity, and flags
3908  // sets length to 0
3909  // returns boolean for success or failure
3910  UBool allocate(int32_t capacity);
3911 
3912  // release the array if owned
3913  void releaseArray();
3914 
3915  // turn a bogus string into an empty one
3916  void unBogus();
3917 
3918  // implements assignment operator, copy constructor, and fastCopyFrom()
3919  UnicodeString &copyFrom(const UnicodeString &src, UBool fastCopy=false);
3920 
3921  // Copies just the fields without memory management.
3922  void copyFieldsFrom(UnicodeString &src, UBool setSrcToBogus) noexcept;
3923 
3924  // Pin start and limit to acceptable values.
3925  inline void pinIndex(int32_t& start) const;
3926  inline void pinIndices(int32_t& start,
3927  int32_t& length) const;
3928 
3929 #if !UCONFIG_NO_CONVERSION
3930 
3931  /* Internal extract() using UConverter. */
3932  int32_t doExtract(int32_t start, int32_t length,
3933  char *dest, int32_t destCapacity,
3934  UConverter *cnv,
3935  UErrorCode &errorCode) const;
3936 
3937  /*
3938  * Real constructor for converting from codepage data.
3939  * It assumes that it is called with !fRefCounted.
3940  *
3941  * If `codepage==0`, then the default converter
3942  * is used for the platform encoding.
3943  * If `codepage` is an empty string (`""`),
3944  * then a simple conversion is performed on the codepage-invariant
3945  * subset ("invariant characters") of the platform encoding. See utypes.h.
3946  */
3947  void doCodepageCreate(const char *codepageData,
3948  int32_t dataLength,
3949  const char *codepage);
3950 
3951  /*
3952  * Worker function for creating a UnicodeString from
3953  * a codepage string using a UConverter.
3954  */
3955  void
3956  doCodepageCreate(const char *codepageData,
3957  int32_t dataLength,
3958  UConverter *converter,
3959  UErrorCode &status);
3960 
3961 #endif
3962 
3963  /*
3964  * This function is called when write access to the array
3965  * is necessary.
3966  *
3967  * We need to make a copy of the array if
3968  * the buffer is read-only, or
3969  * the buffer is refCounted (shared), and refCount>1, or
3970  * the buffer is too small.
3971  *
3972  * Return false if memory could not be allocated.
3973  */
3974  UBool cloneArrayIfNeeded(int32_t newCapacity = -1,
3975  int32_t growCapacity = -1,
3976  UBool doCopyArray = true,
3977  int32_t** pBufferToDelete = nullptr,
3978  UBool forceClone = false);
3979 
3985  UnicodeString &
3986  caseMap(int32_t caseLocale, uint32_t options,
3987 #if !UCONFIG_NO_BREAK_ITERATION
3988  BreakIterator *iter,
3989 #endif
3990  UStringCaseMapper *stringCaseMapper);
3991 
3992  // ref counting
3993  void addRef();
3994  int32_t removeRef();
3995  int32_t refCount() const;
3996 
3997  // constants
3998  enum {
4004  US_STACKBUF_SIZE = static_cast<int32_t>(UNISTR_OBJECT_SIZE - sizeof(void*) - 2) / U_SIZEOF_UCHAR,
4005  kInvalidUChar=0xffff, // U+FFFF returned by charAt(invalid index)
4006  kInvalidHashCode=0, // invalid hash code
4007  kEmptyHashCode=1, // hash code for empty string
4008 
4009  // bit flag values for fLengthAndFlags
4010  kIsBogus=1, // this string is bogus, i.e., not valid or nullptr
4011  kUsingStackBuffer=2,// using fUnion.fStackFields instead of fUnion.fFields
4012  kRefCounted=4, // there is a refCount field before the characters in fArray
4013  kBufferIsReadonly=8,// do not write to this buffer
4014  kOpenGetBuffer=16, // getBuffer(minCapacity) was called (is "open"),
4015  // and releaseBuffer(newLength) must be called
4016  kAllStorageFlags=0x1f,
4017 
4018  kLengthShift=5, // remaining 11 bits for non-negative short length, or negative if long
4019  kLength1=1<<kLengthShift,
4020  kMaxShortLength=0x3ff, // max non-negative short length (leaves top bit 0)
4021  kLengthIsLarge=0xffe0, // short length < 0, real length is in fUnion.fFields.fLength
4022 
4023  // combined values for convenience
4024  kShortString=kUsingStackBuffer,
4025  kLongString=kRefCounted,
4026  kReadonlyAlias=kBufferIsReadonly,
4027  kWritableAlias=0
4028  };
4029 
4030  friend class UnicodeStringAppendable;
4031 
4032  union StackBufferOrFields; // forward declaration necessary before friend declaration
4033  friend union StackBufferOrFields; // make US_STACKBUF_SIZE visible inside fUnion
4034 
4035  /*
4036  * The following are all the class fields that are stored
4037  * in each UnicodeString object.
4038  * Note that UnicodeString has virtual functions,
4039  * therefore there is an implicit vtable pointer
4040  * as the first real field.
4041  * The fields should be aligned such that no padding is necessary.
4042  * On 32-bit machines, the size should be 32 bytes,
4043  * on 64-bit machines (8-byte pointers), it should be 40 bytes.
4044  *
4045  * We use a hack to achieve this.
4046  *
4047  * With at least some compilers, each of the following is forced to
4048  * a multiple of sizeof(pointer) [the largest field base unit here is a data pointer],
4049  * rounded up with additional padding if the fields do not already fit that requirement:
4050  * - sizeof(class UnicodeString)
4051  * - offsetof(UnicodeString, fUnion)
4052  * - sizeof(fUnion)
4053  * - sizeof(fStackFields)
4054  *
4055  * We optimize for the longest possible internal buffer for short strings.
4056  * fUnion.fStackFields begins with 2 bytes for storage flags
4057  * and the length of relatively short strings,
4058  * followed by the buffer for short string contents.
4059  * There is no padding inside fStackFields.
4060  *
4061  * Heap-allocated and aliased strings use fUnion.fFields.
4062  * Both fStackFields and fFields must begin with the same fields for flags and short length,
4063  * that is, those must have the same memory offsets inside the object,
4064  * because the flags must be inspected in order to decide which half of fUnion is being used.
4065  * We assume that the compiler does not reorder the fields.
4066  *
4067  * (Padding at the end of fFields is ok:
4068  * As long as it is no larger than fStackFields, it is not wasted space.)
4069  *
4070  * For some of the history of the UnicodeString class fields layout, see
4071  * - ICU ticket #11551 "longer UnicodeString contents in stack buffer"
4072  * - ICU ticket #11336 "UnicodeString: recombine stack buffer arrays"
4073  * - ICU ticket #8322 "why is sizeof(UnicodeString)==48?"
4074  */
4075  // (implicit) *vtable;
4076  union StackBufferOrFields {
4077  // fStackFields is used iff (fLengthAndFlags&kUsingStackBuffer) else fFields is used.
4078  // Each struct of the union must begin with fLengthAndFlags.
4079  struct {
4080  int16_t fLengthAndFlags; // bit fields: see constants above
4081  char16_t fBuffer[US_STACKBUF_SIZE]; // buffer for short strings
4082  } fStackFields;
4083  struct {
4084  int16_t fLengthAndFlags; // bit fields: see constants above
4085  int32_t fLength; // number of characters in fArray if >127; else undefined
4086  int32_t fCapacity; // capacity of fArray (in char16_ts)
4087  // array pointer last to minimize padding for machines with P128 data model
4088  // or pointer sizes that are not a power of 2
4089  char16_t *fArray; // the Unicode data
4090  } fFields;
4091  } fUnion;
4092 };
4093 
4102 U_COMMON_API UnicodeString U_EXPORT2
4103 operator+ (const UnicodeString &s1, const UnicodeString &s2);
4104 
4105 #ifndef U_HIDE_DRAFT_API
4116 template<typename S, typename = std::enable_if_t<ConvertibleToU16StringView<S>>>
4117 inline UnicodeString operator+(const UnicodeString &s1, const S &s2) {
4118  return unistr_internalConcat(s1, internal::toU16StringView(s2));
4119 }
4120 #endif // U_HIDE_DRAFT_API
4121 
4122 #ifndef U_FORCE_HIDE_INTERNAL_API
4124 U_COMMON_API UnicodeString U_EXPORT2
4125 unistr_internalConcat(const UnicodeString &s1, std::u16string_view s2);
4126 #endif
4127 
4128 //========================================
4129 // Inline members
4130 //========================================
4131 
4132 //========================================
4133 // Privates
4134 //========================================
4135 
4136 inline void
4137 UnicodeString::pinIndex(int32_t& start) const
4138 {
4139  // pin index
4140  if(start < 0) {
4141  start = 0;
4142  } else if(start > length()) {
4143  start = length();
4144  }
4145 }
4146 
4147 inline void
4148 UnicodeString::pinIndices(int32_t& start,
4149  int32_t& _length) const
4150 {
4151  // pin indices
4152  int32_t len = length();
4153  if(start < 0) {
4154  start = 0;
4155  } else if(start > len) {
4156  start = len;
4157  }
4158  if(_length < 0) {
4159  _length = 0;
4160  } else if(_length > (len - start)) {
4161  _length = (len - start);
4162  }
4163 }
4164 
4165 inline char16_t*
4166 UnicodeString::getArrayStart() {
4167  return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ?
4168  fUnion.fStackFields.fBuffer : fUnion.fFields.fArray;
4169 }
4170 
4171 inline const char16_t*
4172 UnicodeString::getArrayStart() const {
4173  return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ?
4174  fUnion.fStackFields.fBuffer : fUnion.fFields.fArray;
4175 }
4176 
4177 //========================================
4178 // Default constructor
4179 //========================================
4180 
4181 inline
4182 UnicodeString::UnicodeString() {
4183  fUnion.fStackFields.fLengthAndFlags=kShortString;
4184 }
4185 
4186 inline UnicodeString::UnicodeString(const std::nullptr_t /*text*/) {
4187  fUnion.fStackFields.fLengthAndFlags=kShortString;
4188 }
4189 
4190 inline UnicodeString::UnicodeString(const std::nullptr_t /*text*/, int32_t /*length*/) {
4191  fUnion.fStackFields.fLengthAndFlags=kShortString;
4192 }
4193 
4194 inline UnicodeString::UnicodeString(std::nullptr_t /*buffer*/, int32_t /*buffLength*/, int32_t /*buffCapacity*/) {
4195  fUnion.fStackFields.fLengthAndFlags=kShortString;
4196 }
4197 
4198 //========================================
4199 // Read-only implementation methods
4200 //========================================
4201 inline UBool
4202 UnicodeString::hasShortLength() const {
4203  return fUnion.fFields.fLengthAndFlags>=0;
4204 }
4205 
4206 inline int32_t
4207 UnicodeString::getShortLength() const {
4208  // fLengthAndFlags must be non-negative -> short length >= 0
4209  // and arithmetic or logical shift does not matter.
4210  return fUnion.fFields.fLengthAndFlags>>kLengthShift;
4211 }
4212 
4213 inline int32_t
4214 UnicodeString::length() const {
4215  return hasShortLength() ? getShortLength() : fUnion.fFields.fLength;
4216 }
4217 
4218 inline int32_t
4219 UnicodeString::getCapacity() const {
4220  return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ?
4221  US_STACKBUF_SIZE : fUnion.fFields.fCapacity;
4222 }
4223 
4224 inline int32_t
4225 UnicodeString::hashCode() const
4226 { return doHashCode(); }
4227 
4228 inline UBool
4229 UnicodeString::isBogus() const
4230 { return fUnion.fFields.fLengthAndFlags & kIsBogus; }
4231 
4232 inline UBool
4233 UnicodeString::isWritable() const
4234 { return !(fUnion.fFields.fLengthAndFlags & (kOpenGetBuffer | kIsBogus)); }
4235 
4236 inline UBool
4237 UnicodeString::isBufferWritable() const
4238 {
4239  return
4240  !(fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kIsBogus|kBufferIsReadonly)) &&
4241  (!(fUnion.fFields.fLengthAndFlags&kRefCounted) || refCount()==1);
4242 }
4243 
4244 inline const char16_t *
4245 UnicodeString::getBuffer() const {
4246  if(fUnion.fFields.fLengthAndFlags&(kIsBogus|kOpenGetBuffer)) {
4247  return nullptr;
4248  } else if(fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) {
4249  return fUnion.fStackFields.fBuffer;
4250  } else {
4251  return fUnion.fFields.fArray;
4252  }
4253 }
4254 
4255 //========================================
4256 // Read-only alias methods
4257 //========================================
4258 inline int8_t
4259 UnicodeString::doCompare(int32_t start,
4260  int32_t thisLength,
4261  const UnicodeString& srcText,
4262  int32_t srcStart,
4263  int32_t srcLength) const
4264 {
4265  if(srcText.isBogus()) {
4266  return static_cast<int8_t>(!isBogus()); // 0 if both are bogus, 1 otherwise
4267  } else {
4268  srcText.pinIndices(srcStart, srcLength);
4269  return doCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength);
4270  }
4271 }
4272 
4273 inline UBool
4274 UnicodeString::doEqualsSubstring(int32_t start,
4275  int32_t thisLength,
4276  const UnicodeString& srcText,
4277  int32_t srcStart,
4278  int32_t srcLength) const
4279 {
4280  if(srcText.isBogus()) {
4281  return isBogus();
4282  } else {
4283  srcText.pinIndices(srcStart, srcLength);
4284  return !isBogus() && doEqualsSubstring(start, thisLength, srcText.getArrayStart(), srcStart, srcLength);
4285  }
4286 }
4287 
4288 inline bool
4289 UnicodeString::operator== (const UnicodeString& text) const
4290 {
4291  if(isBogus()) {
4292  return text.isBogus();
4293  } else {
4294  int32_t len = length(), textLength = text.length();
4295  return !text.isBogus() && len == textLength && doEquals(text, len);
4296  }
4297 }
4298 
4299 inline bool
4300 UnicodeString::operator!= (const UnicodeString& text) const
4301 { return (! operator==(text)); }
4302 
4303 inline UBool
4304 UnicodeString::operator> (const UnicodeString& text) const
4305 { return doCompare(0, length(), text, 0, text.length()) == 1; }
4306 
4307 inline UBool
4308 UnicodeString::operator< (const UnicodeString& text) const
4309 { return doCompare(0, length(), text, 0, text.length()) == -1; }
4310 
4311 inline UBool
4312 UnicodeString::operator>= (const UnicodeString& text) const
4313 { return doCompare(0, length(), text, 0, text.length()) != -1; }
4314 
4315 inline UBool
4316 UnicodeString::operator<= (const UnicodeString& text) const
4317 { return doCompare(0, length(), text, 0, text.length()) != 1; }
4318 
4319 inline int8_t
4320 UnicodeString::compare(const UnicodeString& text) const
4321 { return doCompare(0, length(), text, 0, text.length()); }
4322 
4323 inline int8_t
4324 UnicodeString::compare(int32_t start,
4325  int32_t _length,
4326  const UnicodeString& srcText) const
4327 { return doCompare(start, _length, srcText, 0, srcText.length()); }
4328 
4329 inline int8_t
4330 UnicodeString::compare(ConstChar16Ptr srcChars,
4331  int32_t srcLength) const
4332 { return doCompare(0, length(), srcChars, 0, srcLength); }
4333 
4334 inline int8_t
4335 UnicodeString::compare(int32_t start,
4336  int32_t _length,
4337  const UnicodeString& srcText,
4338  int32_t srcStart,
4339  int32_t srcLength) const
4340 { return doCompare(start, _length, srcText, srcStart, srcLength); }
4341 
4342 inline int8_t
4343 UnicodeString::compare(int32_t start,
4344  int32_t _length,
4345  const char16_t *srcChars) const
4346 { return doCompare(start, _length, srcChars, 0, _length); }
4347 
4348 inline int8_t
4349 UnicodeString::compare(int32_t start,
4350  int32_t _length,
4351  const char16_t *srcChars,
4352  int32_t srcStart,
4353  int32_t srcLength) const
4354 { return doCompare(start, _length, srcChars, srcStart, srcLength); }
4355 
4356 inline int8_t
4357 UnicodeString::compareBetween(int32_t start,
4358  int32_t limit,
4359  const UnicodeString& srcText,
4360  int32_t srcStart,
4361  int32_t srcLimit) const
4362 { return doCompare(start, limit - start,
4363  srcText, srcStart, srcLimit - srcStart); }
4364 
4365 inline int8_t
4366 UnicodeString::doCompareCodePointOrder(int32_t start,
4367  int32_t thisLength,
4368  const UnicodeString& srcText,
4369  int32_t srcStart,
4370  int32_t srcLength) const
4371 {
4372  if(srcText.isBogus()) {
4373  return static_cast<int8_t>(!isBogus()); // 0 if both are bogus, 1 otherwise
4374  } else {
4375  srcText.pinIndices(srcStart, srcLength);
4376  return doCompareCodePointOrder(start, thisLength, srcText.getArrayStart(), srcStart, srcLength);
4377  }
4378 }
4379 
4380 inline int8_t
4381 UnicodeString::compareCodePointOrder(const UnicodeString& text) const
4382 { return doCompareCodePointOrder(0, length(), text, 0, text.length()); }
4383 
4384 inline int8_t
4385 UnicodeString::compareCodePointOrder(int32_t start,
4386  int32_t _length,
4387  const UnicodeString& srcText) const
4388 { return doCompareCodePointOrder(start, _length, srcText, 0, srcText.length()); }
4389 
4390 inline int8_t
4391 UnicodeString::compareCodePointOrder(ConstChar16Ptr srcChars,
4392  int32_t srcLength) const
4393 { return doCompareCodePointOrder(0, length(), srcChars, 0, srcLength); }
4394 
4395 inline int8_t
4396 UnicodeString::compareCodePointOrder(int32_t start,
4397  int32_t _length,
4398  const UnicodeString& srcText,
4399  int32_t srcStart,
4400  int32_t srcLength) const
4401 { return doCompareCodePointOrder(start, _length, srcText, srcStart, srcLength); }
4402 
4403 inline int8_t
4404 UnicodeString::compareCodePointOrder(int32_t start,
4405  int32_t _length,
4406  const char16_t *srcChars) const
4407 { return doCompareCodePointOrder(start, _length, srcChars, 0, _length); }
4408 
4409 inline int8_t
4410 UnicodeString::compareCodePointOrder(int32_t start,
4411  int32_t _length,
4412  const char16_t *srcChars,
4413  int32_t srcStart,
4414  int32_t srcLength) const
4415 { return doCompareCodePointOrder(start, _length, srcChars, srcStart, srcLength); }
4416 
4417 inline int8_t
4418 UnicodeString::compareCodePointOrderBetween(int32_t start,
4419  int32_t limit,
4420  const UnicodeString& srcText,
4421  int32_t srcStart,
4422  int32_t srcLimit) const
4423 { return doCompareCodePointOrder(start, limit - start,
4424  srcText, srcStart, srcLimit - srcStart); }
4425 
4426 inline int8_t
4427 UnicodeString::doCaseCompare(int32_t start,
4428  int32_t thisLength,
4429  const UnicodeString &srcText,
4430  int32_t srcStart,
4431  int32_t srcLength,
4432  uint32_t options) const
4433 {
4434  if(srcText.isBogus()) {
4435  return static_cast<int8_t>(!isBogus()); // 0 if both are bogus, 1 otherwise
4436  } else {
4437  srcText.pinIndices(srcStart, srcLength);
4438  return doCaseCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength, options);
4439  }
4440 }
4441 
4442 inline int8_t
4443 UnicodeString::caseCompare(const UnicodeString &text, uint32_t options) const {
4444  return doCaseCompare(0, length(), text, 0, text.length(), options);
4445 }
4446 
4447 inline int8_t
4448 UnicodeString::caseCompare(int32_t start,
4449  int32_t _length,
4450  const UnicodeString &srcText,
4451  uint32_t options) const {
4452  return doCaseCompare(start, _length, srcText, 0, srcText.length(), options);
4453 }
4454 
4455 inline int8_t
4456 UnicodeString::caseCompare(ConstChar16Ptr srcChars,
4457  int32_t srcLength,
4458  uint32_t options) const {
4459  return doCaseCompare(0, length(), srcChars, 0, srcLength, options);
4460 }
4461 
4462 inline int8_t
4463 UnicodeString::caseCompare(int32_t start,
4464  int32_t _length,
4465  const UnicodeString &srcText,
4466  int32_t srcStart,
4467  int32_t srcLength,
4468  uint32_t options) const {
4469  return doCaseCompare(start, _length, srcText, srcStart, srcLength, options);
4470 }
4471 
4472 inline int8_t
4473 UnicodeString::caseCompare(int32_t start,
4474  int32_t _length,
4475  const char16_t *srcChars,
4476  uint32_t options) const {
4477  return doCaseCompare(start, _length, srcChars, 0, _length, options);
4478 }
4479 
4480 inline int8_t
4481 UnicodeString::caseCompare(int32_t start,
4482  int32_t _length,
4483  const char16_t *srcChars,
4484  int32_t srcStart,
4485  int32_t srcLength,
4486  uint32_t options) const {
4487  return doCaseCompare(start, _length, srcChars, srcStart, srcLength, options);
4488 }
4489 
4490 inline int8_t
4491 UnicodeString::caseCompareBetween(int32_t start,
4492  int32_t limit,
4493  const UnicodeString &srcText,
4494  int32_t srcStart,
4495  int32_t srcLimit,
4496  uint32_t options) const {
4497  return doCaseCompare(start, limit - start, srcText, srcStart, srcLimit - srcStart, options);
4498 }
4499 
4500 inline int32_t
4501 UnicodeString::indexOf(const UnicodeString& srcText,
4502  int32_t srcStart,
4503  int32_t srcLength,
4504  int32_t start,
4505  int32_t _length) const
4506 {
4507  if(!srcText.isBogus()) {
4508  srcText.pinIndices(srcStart, srcLength);
4509  if(srcLength > 0) {
4510  return indexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
4511  }
4512  }
4513  return -1;
4514 }
4515 
4516 inline int32_t
4517 UnicodeString::indexOf(const UnicodeString& text) const
4518 { return indexOf(text, 0, text.length(), 0, length()); }
4519 
4520 inline int32_t
4521 UnicodeString::indexOf(const UnicodeString& text,
4522  int32_t start) const {
4523  pinIndex(start);
4524  return indexOf(text, 0, text.length(), start, length() - start);
4525 }
4526 
4527 inline int32_t
4528 UnicodeString::indexOf(const UnicodeString& text,
4529  int32_t start,
4530  int32_t _length) const
4531 { return indexOf(text, 0, text.length(), start, _length); }
4532 
4533 inline int32_t
4534 UnicodeString::indexOf(const char16_t *srcChars,
4535  int32_t srcLength,
4536  int32_t start) const {
4537  pinIndex(start);
4538  return indexOf(srcChars, 0, srcLength, start, length() - start);
4539 }
4540 
4541 inline int32_t
4542 UnicodeString::indexOf(ConstChar16Ptr srcChars,
4543  int32_t srcLength,
4544  int32_t start,
4545  int32_t _length) const
4546 { return indexOf(srcChars, 0, srcLength, start, _length); }
4547 
4548 inline int32_t
4549 UnicodeString::indexOf(char16_t c,
4550  int32_t start,
4551  int32_t _length) const
4552 { return doIndexOf(c, start, _length); }
4553 
4554 inline int32_t
4555 UnicodeString::indexOf(UChar32 c,
4556  int32_t start,
4557  int32_t _length) const
4558 { return doIndexOf(c, start, _length); }
4559 
4560 inline int32_t
4561 UnicodeString::indexOf(char16_t c) const
4562 { return doIndexOf(c, 0, length()); }
4563 
4564 inline int32_t
4565 UnicodeString::indexOf(UChar32 c) const
4566 { return indexOf(c, 0, length()); }
4567 
4568 inline int32_t
4569 UnicodeString::indexOf(char16_t c,
4570  int32_t start) const {
4571  pinIndex(start);
4572  return doIndexOf(c, start, length() - start);
4573 }
4574 
4575 inline int32_t
4576 UnicodeString::indexOf(UChar32 c,
4577  int32_t start) const {
4578  pinIndex(start);
4579  return indexOf(c, start, length() - start);
4580 }
4581 
4582 inline int32_t
4583 UnicodeString::lastIndexOf(ConstChar16Ptr srcChars,
4584  int32_t srcLength,
4585  int32_t start,
4586  int32_t _length) const
4587 { return lastIndexOf(srcChars, 0, srcLength, start, _length); }
4588 
4589 inline int32_t
4590 UnicodeString::lastIndexOf(const char16_t *srcChars,
4591  int32_t srcLength,
4592  int32_t start) const {
4593  pinIndex(start);
4594  return lastIndexOf(srcChars, 0, srcLength, start, length() - start);
4595 }
4596 
4597 inline int32_t
4598 UnicodeString::lastIndexOf(const UnicodeString& srcText,
4599  int32_t srcStart,
4600  int32_t srcLength,
4601  int32_t start,
4602  int32_t _length) const
4603 {
4604  if(!srcText.isBogus()) {
4605  srcText.pinIndices(srcStart, srcLength);
4606  if(srcLength > 0) {
4607  return lastIndexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
4608  }
4609  }
4610  return -1;
4611 }
4612 
4613 inline int32_t
4614 UnicodeString::lastIndexOf(const UnicodeString& text,
4615  int32_t start,
4616  int32_t _length) const
4617 { return lastIndexOf(text, 0, text.length(), start, _length); }
4618 
4619 inline int32_t
4620 UnicodeString::lastIndexOf(const UnicodeString& text,
4621  int32_t start) const {
4622  pinIndex(start);
4623  return lastIndexOf(text, 0, text.length(), start, length() - start);
4624 }
4625 
4626 inline int32_t
4627 UnicodeString::lastIndexOf(const UnicodeString& text) const
4628 { return lastIndexOf(text, 0, text.length(), 0, length()); }
4629 
4630 inline int32_t
4631 UnicodeString::lastIndexOf(char16_t c,
4632  int32_t start,
4633  int32_t _length) const
4634 { return doLastIndexOf(c, start, _length); }
4635 
4636 inline int32_t
4637 UnicodeString::lastIndexOf(UChar32 c,
4638  int32_t start,
4639  int32_t _length) const {
4640  return doLastIndexOf(c, start, _length);
4641 }
4642 
4643 inline int32_t
4644 UnicodeString::lastIndexOf(char16_t c) const
4645 { return doLastIndexOf(c, 0, length()); }
4646 
4647 inline int32_t
4648 UnicodeString::lastIndexOf(UChar32 c) const {
4649  return lastIndexOf(c, 0, length());
4650 }
4651 
4652 inline int32_t
4653 UnicodeString::lastIndexOf(char16_t c,
4654  int32_t start) const {
4655  pinIndex(start);
4656  return doLastIndexOf(c, start, length() - start);
4657 }
4658 
4659 inline int32_t
4660 UnicodeString::lastIndexOf(UChar32 c,
4661  int32_t start) const {
4662  pinIndex(start);
4663  return lastIndexOf(c, start, length() - start);
4664 }
4665 
4666 inline UBool
4667 UnicodeString::startsWith(const UnicodeString& text) const
4668 { return doEqualsSubstring(0, text.length(), text, 0, text.length()); }
4669 
4670 inline UBool
4671 UnicodeString::startsWith(const UnicodeString& srcText,
4672  int32_t srcStart,
4673  int32_t srcLength) const
4674 { return doEqualsSubstring(0, srcLength, srcText, srcStart, srcLength); }
4675 
4676 inline UBool
4677 UnicodeString::startsWith(ConstChar16Ptr srcChars, int32_t srcLength) const {
4678  if(srcLength < 0) {
4679  srcLength = u_strlen(toUCharPtr(srcChars));
4680  }
4681  return doEqualsSubstring(0, srcLength, srcChars, 0, srcLength);
4682 }
4683 
4684 inline UBool
4685 UnicodeString::startsWith(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) const {
4686  if(srcLength < 0) {
4687  srcLength = u_strlen(toUCharPtr(srcChars));
4688  }
4689  return doEqualsSubstring(0, srcLength, srcChars, srcStart, srcLength);
4690 }
4691 
4692 inline UBool
4693 UnicodeString::endsWith(const UnicodeString& text) const
4694 { return doEqualsSubstring(length() - text.length(), text.length(),
4695  text, 0, text.length()); }
4696 
4697 inline UBool
4698 UnicodeString::endsWith(const UnicodeString& srcText,
4699  int32_t srcStart,
4700  int32_t srcLength) const {
4701  srcText.pinIndices(srcStart, srcLength);
4702  return doEqualsSubstring(length() - srcLength, srcLength,
4703  srcText, srcStart, srcLength);
4704 }
4705 
4706 inline UBool
4707 UnicodeString::endsWith(ConstChar16Ptr srcChars,
4708  int32_t srcLength) const {
4709  if(srcLength < 0) {
4710  srcLength = u_strlen(toUCharPtr(srcChars));
4711  }
4712  return doEqualsSubstring(length() - srcLength, srcLength, srcChars, 0, srcLength);
4713 }
4714 
4715 inline UBool
4716 UnicodeString::endsWith(const char16_t *srcChars,
4717  int32_t srcStart,
4718  int32_t srcLength) const {
4719  if(srcLength < 0) {
4720  srcLength = u_strlen(toUCharPtr(srcChars + srcStart));
4721  }
4722  return doEqualsSubstring(length() - srcLength, srcLength,
4723  srcChars, srcStart, srcLength);
4724 }
4725 
4726 //========================================
4727 // replace
4728 //========================================
4729 inline UnicodeString&
4730 UnicodeString::replace(int32_t start,
4731  int32_t _length,
4732  const UnicodeString& srcText)
4733 { return doReplace(start, _length, srcText, 0, srcText.length()); }
4734 
4735 inline UnicodeString&
4736 UnicodeString::replace(int32_t start,
4737  int32_t _length,
4738  const UnicodeString& srcText,
4739  int32_t srcStart,
4740  int32_t srcLength)
4741 { return doReplace(start, _length, srcText, srcStart, srcLength); }
4742 
4743 inline UnicodeString&
4744 UnicodeString::replace(int32_t start,
4745  int32_t _length,
4746  ConstChar16Ptr srcChars,
4747  int32_t srcLength)
4748 { return doReplace(start, _length, srcChars, 0, srcLength); }
4749 
4750 inline UnicodeString&
4751 UnicodeString::replace(int32_t start,
4752  int32_t _length,
4753  const char16_t *srcChars,
4754  int32_t srcStart,
4755  int32_t srcLength)
4756 { return doReplace(start, _length, srcChars, srcStart, srcLength); }
4757 
4758 inline UnicodeString&
4759 UnicodeString::replace(int32_t start,
4760  int32_t _length,
4761  char16_t srcChar)
4762 { return doReplace(start, _length, &srcChar, 0, 1); }
4763 
4764 inline UnicodeString&
4765 UnicodeString::replaceBetween(int32_t start,
4766  int32_t limit,
4767  const UnicodeString& srcText)
4768 { return doReplace(start, limit - start, srcText, 0, srcText.length()); }
4769 
4770 inline UnicodeString&
4771 UnicodeString::replaceBetween(int32_t start,
4772  int32_t limit,
4773  const UnicodeString& srcText,
4774  int32_t srcStart,
4775  int32_t srcLimit)
4776 { return doReplace(start, limit - start, srcText, srcStart, srcLimit - srcStart); }
4777 
4778 inline UnicodeString&
4779 UnicodeString::findAndReplace(const UnicodeString& oldText,
4780  const UnicodeString& newText)
4781 { return findAndReplace(0, length(), oldText, 0, oldText.length(),
4782  newText, 0, newText.length()); }
4783 
4784 inline UnicodeString&
4785 UnicodeString::findAndReplace(int32_t start,
4786  int32_t _length,
4787  const UnicodeString& oldText,
4788  const UnicodeString& newText)
4789 { return findAndReplace(start, _length, oldText, 0, oldText.length(),
4790  newText, 0, newText.length()); }
4791 
4792 // ============================
4793 // extract
4794 // ============================
4795 inline void
4796 UnicodeString::doExtract(int32_t start,
4797  int32_t _length,
4798  UnicodeString& target) const
4799 { target.replace(0, target.length(), *this, start, _length); }
4800 
4801 inline void
4802 UnicodeString::extract(int32_t start,
4803  int32_t _length,
4804  Char16Ptr target,
4805  int32_t targetStart) const
4806 { doExtract(start, _length, target, targetStart); }
4807 
4808 inline void
4809 UnicodeString::extract(int32_t start,
4810  int32_t _length,
4811  UnicodeString& target) const
4812 { doExtract(start, _length, target); }
4813 
4814 #if !UCONFIG_NO_CONVERSION
4815 
4816 inline int32_t
4817 UnicodeString::extract(int32_t start,
4818  int32_t _length,
4819  char *dst,
4820  const char *codepage) const
4821 
4822 {
4823  // This dstSize value will be checked explicitly
4824  return extract(start, _length, dst, dst != nullptr ? 0xffffffff : 0, codepage);
4825 }
4826 
4827 #endif
4828 
4829 inline void
4830 UnicodeString::extractBetween(int32_t start,
4831  int32_t limit,
4832  char16_t *dst,
4833  int32_t dstStart) const {
4834  pinIndex(start);
4835  pinIndex(limit);
4836  doExtract(start, limit - start, dst, dstStart);
4837 }
4838 
4839 inline UnicodeString
4840 UnicodeString::tempSubStringBetween(int32_t start, int32_t limit) const {
4841  return tempSubString(start, limit - start);
4842 }
4843 
4844 inline char16_t
4845 UnicodeString::doCharAt(int32_t offset) const
4846 {
4847  if (static_cast<uint32_t>(offset) < static_cast<uint32_t>(length())) {
4848  return getArrayStart()[offset];
4849  } else {
4850  return kInvalidUChar;
4851  }
4852 }
4853 
4854 inline char16_t
4855 UnicodeString::charAt(int32_t offset) const
4856 { return doCharAt(offset); }
4857 
4858 inline char16_t
4859 UnicodeString::operator[] (int32_t offset) const
4860 { return doCharAt(offset); }
4861 
4862 inline UBool
4863 UnicodeString::isEmpty() const {
4864  // Arithmetic or logical right shift does not matter: only testing for 0.
4865  return (fUnion.fFields.fLengthAndFlags>>kLengthShift) == 0;
4866 }
4867 
4868 //========================================
4869 // Write implementation methods
4870 //========================================
4871 inline void
4872 UnicodeString::setZeroLength() {
4873  fUnion.fFields.fLengthAndFlags &= kAllStorageFlags;
4874 }
4875 
4876 inline void
4877 UnicodeString::setShortLength(int32_t len) {
4878  // requires 0 <= len <= kMaxShortLength
4879  fUnion.fFields.fLengthAndFlags =
4880  static_cast<int16_t>((fUnion.fFields.fLengthAndFlags & kAllStorageFlags) | (len << kLengthShift));
4881 }
4882 
4883 inline void
4884 UnicodeString::setLength(int32_t len) {
4885  if(len <= kMaxShortLength) {
4886  setShortLength(len);
4887  } else {
4888  fUnion.fFields.fLengthAndFlags |= kLengthIsLarge;
4889  fUnion.fFields.fLength = len;
4890  }
4891 }
4892 
4893 inline void
4894 UnicodeString::setToEmpty() {
4895  fUnion.fFields.fLengthAndFlags = kShortString;
4896 }
4897 
4898 inline void
4899 UnicodeString::setArray(char16_t *array, int32_t len, int32_t capacity) {
4900  setLength(len);
4901  fUnion.fFields.fArray = array;
4902  fUnion.fFields.fCapacity = capacity;
4903 }
4904 
4905 inline UnicodeString&
4906 UnicodeString::operator= (char16_t ch)
4907 { return doReplace(0, length(), &ch, 0, 1); }
4908 
4909 inline UnicodeString&
4910 UnicodeString::operator= (UChar32 ch)
4911 { return replace(0, length(), ch); }
4912 
4913 inline UnicodeString&
4914 UnicodeString::setTo(const UnicodeString& srcText,
4915  int32_t srcStart,
4916  int32_t srcLength)
4917 {
4918  unBogus();
4919  return doReplace(0, length(), srcText, srcStart, srcLength);
4920 }
4921 
4922 inline UnicodeString&
4923 UnicodeString::setTo(const UnicodeString& srcText,
4924  int32_t srcStart)
4925 {
4926  unBogus();
4927  srcText.pinIndex(srcStart);
4928  return doReplace(0, length(), srcText, srcStart, srcText.length() - srcStart);
4929 }
4930 
4931 inline UnicodeString&
4932 UnicodeString::setTo(const UnicodeString& srcText)
4933 {
4934  return copyFrom(srcText);
4935 }
4936 
4937 inline UnicodeString&
4938 UnicodeString::setTo(const char16_t *srcChars,
4939  int32_t srcLength)
4940 {
4941  unBogus();
4942  return doReplace(0, length(), srcChars, 0, srcLength);
4943 }
4944 
4945 inline UnicodeString&
4946 UnicodeString::setTo(char16_t srcChar)
4947 {
4948  unBogus();
4949  return doReplace(0, length(), &srcChar, 0, 1);
4950 }
4951 
4952 inline UnicodeString&
4953 UnicodeString::setTo(UChar32 srcChar)
4954 {
4955  unBogus();
4956  return replace(0, length(), srcChar);
4957 }
4958 
4959 inline UnicodeString&
4960 UnicodeString::append(const UnicodeString& srcText,
4961  int32_t srcStart,
4962  int32_t srcLength)
4963 { return doAppend(srcText, srcStart, srcLength); }
4964 
4965 inline UnicodeString&
4966 UnicodeString::append(const UnicodeString& srcText)
4967 { return doAppend(srcText, 0, srcText.length()); }
4968 
4969 inline UnicodeString&
4970 UnicodeString::append(const char16_t *srcChars,
4971  int32_t srcStart,
4972  int32_t srcLength)
4973 { return doAppend(srcChars, srcStart, srcLength); }
4974 
4975 inline UnicodeString&
4976 UnicodeString::append(ConstChar16Ptr srcChars,
4977  int32_t srcLength)
4978 { return doAppend(srcChars, 0, srcLength); }
4979 
4980 inline UnicodeString&
4981 UnicodeString::append(char16_t srcChar)
4982 { return doAppend(&srcChar, 0, 1); }
4983 
4984 inline UnicodeString&
4985 UnicodeString::operator+= (char16_t ch)
4986 { return doAppend(&ch, 0, 1); }
4987 
4988 inline UnicodeString&
4989 UnicodeString::operator+= (UChar32 ch) {
4990  return append(ch);
4991 }
4992 
4993 inline UnicodeString&
4994 UnicodeString::operator+= (const UnicodeString& srcText)
4995 { return doAppend(srcText, 0, srcText.length()); }
4996 
4997 inline UnicodeString&
4998 UnicodeString::insert(int32_t start,
4999  const UnicodeString& srcText,
5000  int32_t srcStart,
5001  int32_t srcLength)
5002 { return doReplace(start, 0, srcText, srcStart, srcLength); }
5003 
5004 inline UnicodeString&
5005 UnicodeString::insert(int32_t start,
5006  const UnicodeString& srcText)
5007 { return doReplace(start, 0, srcText, 0, srcText.length()); }
5008 
5009 inline UnicodeString&
5010 UnicodeString::insert(int32_t start,
5011  const char16_t *srcChars,
5012  int32_t srcStart,
5013  int32_t srcLength)
5014 { return doReplace(start, 0, srcChars, srcStart, srcLength); }
5015 
5016 inline UnicodeString&
5017 UnicodeString::insert(int32_t start,
5018  ConstChar16Ptr srcChars,
5019  int32_t srcLength)
5020 { return doReplace(start, 0, srcChars, 0, srcLength); }
5021 
5022 inline UnicodeString&
5023 UnicodeString::insert(int32_t start,
5024  char16_t srcChar)
5025 { return doReplace(start, 0, &srcChar, 0, 1); }
5026 
5027 inline UnicodeString&
5028 UnicodeString::insert(int32_t start,
5029  UChar32 srcChar)
5030 { return replace(start, 0, srcChar); }
5031 
5032 
5033 inline UnicodeString&
5034 UnicodeString::remove()
5035 {
5036  // remove() of a bogus string makes the string empty and non-bogus
5037  if(isBogus()) {
5038  setToEmpty();
5039  } else {
5040  setZeroLength();
5041  }
5042  return *this;
5043 }
5044 
5045 inline UnicodeString&
5046 UnicodeString::remove(int32_t start,
5047  int32_t _length)
5048 {
5049  if(start <= 0 && _length == INT32_MAX) {
5050  // remove(guaranteed everything) of a bogus string makes the string empty and non-bogus
5051  return remove();
5052  }
5053  return doReplace(start, _length, nullptr, 0, 0);
5054 }
5055 
5056 inline UnicodeString&
5057 UnicodeString::removeBetween(int32_t start,
5058  int32_t limit)
5059 { return doReplace(start, limit - start, nullptr, 0, 0); }
5060 
5061 inline UnicodeString &
5062 UnicodeString::retainBetween(int32_t start, int32_t limit) {
5063  truncate(limit);
5064  return doReplace(0, start, nullptr, 0, 0);
5065 }
5066 
5067 inline UBool
5068 UnicodeString::truncate(int32_t targetLength)
5069 {
5070  if(isBogus() && targetLength == 0) {
5071  // truncate(0) of a bogus string makes the string empty and non-bogus
5072  unBogus();
5073  return false;
5074  } else if (static_cast<uint32_t>(targetLength) < static_cast<uint32_t>(length())) {
5075  setLength(targetLength);
5076  return true;
5077  } else {
5078  return false;
5079  }
5080 }
5081 
5082 inline UnicodeString&
5083 UnicodeString::reverse()
5084 { return doReverse(0, length()); }
5085 
5086 inline UnicodeString&
5087 UnicodeString::reverse(int32_t start,
5088  int32_t _length)
5089 { return doReverse(start, _length); }
5090 
5091 U_NAMESPACE_END
5092 
5093 #endif /* U_SHOW_CPLUSPLUS_API */
5094 
5095 #endif
bytestream.h
C++ API: Interface for writing bytes, and implementation classes.
char16ptr.h
C++ API: char16_t pointer wrappers with implicit conversion from bit-compatible raw pointer types.
U_ALIASING_BARRIER
#define U_ALIASING_BARRIER(ptr)
Barrier for pointer anti-aliasing optimizations even across function boundaries.
Definition: char16ptr.h:37
icu::BreakIterator
The BreakIterator class implements methods for finding the location of boundaries in text.
Definition: brkiter.h:108
icu::ByteSink
A ByteSink can be filled with bytes.
Definition: bytestream.h:53
icu::Char16Ptr
char16_t * wrapper with implicit conversion from distinct but bit-compatible pointer types.
Definition: char16ptr.h:49
icu::ConstChar16Ptr
const char16_t * wrapper with implicit conversion from distinct but bit-compatible pointer types.
Definition: char16ptr.h:156
icu::Edits
Records lengths of string edits but not replacement text.
Definition: edits.h:80
icu::Locale
A Locale object represents a specific geographical, political, or cultural region.
Definition: locid.h:195
icu::Replaceable
Replaceable is an abstract base class representing a string of characters that supports the replaceme...
Definition: rep.h:77
icu::Replaceable::extractBetween
virtual void extractBetween(int32_t start, int32_t limit, UnicodeString &target) const =0
Copies characters in the range [start, limit) into the UnicodeString target.
icu::Replaceable::charAt
char16_t charAt(int32_t offset) const
Returns the 16-bit code unit at the given offset into the text.
Definition: rep.h:251
icu::Replaceable::length
int32_t length() const
Returns the number of 16-bit code units in the text.
Definition: rep.h:246
icu::StringByteSink
Implementation of ByteSink that writes to a "string".
Definition: bytestream.h:267
icu::StringPiece
A string-like object that points to a sized piece of memory.
Definition: stringpiece.h:61
icu::UnicodeString
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:296
icu::UnicodeString::indexOf
int32_t indexOf(const char16_t *srcChars, int32_t srcStart, int32_t srcLength, int32_t start, int32_t length) const
Locate in this the first occurrence in the range [start, start + length) of the characters in srcChar...
icu::UnicodeString::UnicodeString
UnicodeString(const UnicodeString &that)
Copy constructor.
icu::UnicodeString::swap
void swap(UnicodeString &other) noexcept
Swap strings.
icu::UnicodeString::getCharAt
virtual char16_t getCharAt(int32_t offset) const override
The change in Replaceable to use virtual getCharAt() allows UnicodeString::charAt() to be inline agai...
icu::UnicodeString::operator==
bool operator==(const S &text) const
Equality operator.
Definition: unistr.h:347
icu::UnicodeString::getLength
virtual int32_t getLength() const override
Implement Replaceable::getLength() (see jitterbug 1027).
icu::UnicodeString::foldCase
UnicodeString & foldCase(uint32_t options=0)
Case-folds the characters in this string.
icu::UnicodeString::unescapeAt
UChar32 unescapeAt(int32_t &offset) const
Unescape a single escape sequence and return the represented character.
icu::UnicodeString::UnicodeString
UnicodeString(const wchar_t *text, int32_t textLength)
wchar_t * constructor.
Definition: unistr.h:3247
icu::UnicodeString::handleReplaceBetween
virtual void handleReplaceBetween(int32_t start, int32_t limit, const UnicodeString &text) override
Replace a substring of this object with the given text.
icu::UnicodeString::hasMoreChar32Than
UBool hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const
Check if the length char16_t code units of the string contain more Unicode code points than a certain...
icu::UnicodeString::UnicodeString
UnicodeString(const UnicodeString &src, int32_t srcStart, int32_t srcLength)
'Substring' constructor from subrange of source string.
icu::UnicodeString::operator=
UnicodeString & operator=(const S &src)
Assignment operator.
Definition: unistr.h:1960
icu::UnicodeString::append
UnicodeString & append(const S &src)
Appends the characters in src which is, or which is implicitly convertible to, a std::u16string_view ...
Definition: unistr.h:2300
icu::UnicodeString::operator=
UnicodeString & operator=(UnicodeString &&src) noexcept
Move assignment operator; might leave src in bogus state.
icu::UnicodeString::~UnicodeString
virtual ~UnicodeString()
Destructor.
icu::UnicodeString::UnicodeString
UnicodeString(const char *codepageData, int32_t dataLength, const char *codepage)
char* constructor.
icu::UnicodeString::toLower
UnicodeString & toLower()
Convert the characters in this to lower case following the conventions of the default locale.
icu::UnicodeString::UnicodeString
UnicodeString(const char *codepageData, const char *codepage)
char* constructor.
icu::UnicodeString::UnicodeString
UnicodeString(UBool isTerminated, ConstChar16Ptr text, int32_t textLength)
Readonly-aliasing char16_t* constructor.
icu::UnicodeString::readOnlyAlias
static UnicodeString readOnlyAlias(const UnicodeString &text)
Readonly-aliasing factory method.
Definition: unistr.h:3623
icu::UnicodeString::fastCopyFrom
UnicodeString & fastCopyFrom(const UnicodeString &src)
Almost the same as the assignment operator.
icu::UnicodeString::toTitle
UnicodeString & toTitle(BreakIterator *titleIter)
Titlecase this string, convenience function using the default locale.
icu::UnicodeString::EInvariant
EInvariant
Constant to be used in the UnicodeString(char *, int32_t, EInvariant) constructor which constructs a ...
Definition: unistr.h:307
icu::UnicodeString::operator!=
bool operator!=(const S &text) const
Inequality operator.
Definition: unistr.h:382
icu::UnicodeString::unescape
UnicodeString unescape() const
Unescape a string of characters and return a string containing the result.
icu::UnicodeString::UnicodeString
UnicodeString(const UnicodeString &src, int32_t srcStart)
'Substring' constructor from tail of source string.
icu::UnicodeString::getChar32Limit
int32_t getChar32Limit(int32_t offset) const
Adjust a random-access offset so that it points behind a Unicode character.
icu::UnicodeString::UnicodeString
UnicodeString(char16_t *buffer, int32_t buffLength, int32_t buffCapacity)
Writable-aliasing char16_t* constructor.
icu::UnicodeString::UnicodeString
UnicodeString(int32_t capacity, UChar32 c, int32_t count)
Construct a UnicodeString with capacity to hold capacity char16_ts.
icu::UnicodeString::extract
int32_t extract(int32_t start, int32_t startLength, char *target, uint32_t targetLength, const char *codepage) const
Copy the characters in the range [start, start + length) into an array of characters in a specified c...
icu::UnicodeString::findAndReplace
UnicodeString & findAndReplace(int32_t start, int32_t length, const UnicodeString &oldText, int32_t oldStart, int32_t oldLength, const UnicodeString &newText, int32_t newStart, int32_t newLength)
Replace all occurrences of characters in oldText in the range [oldStart, oldStart + oldLength) with t...
icu::UnicodeString::copy
virtual void copy(int32_t start, int32_t limit, int32_t dest) override
Copy a substring of this object, retaining attribute (out-of-band) information.
icu::UnicodeString::extractBetween
virtual void extractBetween(int32_t start, int32_t limit, UnicodeString &target) const override
Copy the characters in the range [start, limit) into the UnicodeString target.
icu::UnicodeString::replace
UnicodeString & replace(int32_t start, int32_t length, const UnicodeString &srcText, int32_t srcStart, int32_t srcLength)
Replace the characters in the range [start, start + length) with the characters in srcText in the ran...
Definition: unistr.h:4736
icu::UnicodeString::padLeading
UBool padLeading(int32_t targetLength, char16_t padChar=0x0020)
Pad the start of this UnicodeString with the character padChar.
icu::UnicodeString::getChar32Start
int32_t getChar32Start(int32_t offset) const
Adjust a random-access offset so that it points to the beginning of a Unicode character.
icu::UnicodeString::char32At
UChar32 char32At(int32_t offset) const
Return the code point that contains the code unit at offset offset.
icu::UnicodeString::UnicodeString
UnicodeString(const char *src, int32_t textLength, enum EInvariant inv)
Constructs a Unicode string from an invariant-character char * string.
icu::UnicodeString::operator=
UnicodeString & operator=(const UnicodeString &srcText)
Assignment operator.
icu::UnicodeString::append
UnicodeString & append(UChar32 srcChar)
Append the code point srcChar to the UnicodeString object.
icu::UnicodeString::toUTF8String
StringClass & toUTF8String(StringClass &result) const
Convert the UnicodeString to UTF-8 and append the result to a standard string.
Definition: unistr.h:1777
icu::UnicodeString::toLower
UnicodeString & toLower(const Locale &locale)
Convert the characters in this to lower case following the conventions of a specific locale.
icu::UnicodeString::toTitle
UnicodeString & toTitle(BreakIterator *titleIter, const Locale &locale)
Titlecase this string.
icu::UnicodeString::tempSubString
UnicodeString tempSubString(int32_t start=0, int32_t length=INT32_MAX) const
Create a temporary substring for the specified range.
icu::UnicodeString::extract
int32_t extract(Char16Ptr dest, int32_t destCapacity, UErrorCode &errorCode) const
Copy the contents of the string into dest.
icu::UnicodeString::length
int32_t length() const
Return the length of the UnicodeString object.
Definition: unistr.h:4214
icu::UnicodeString::getChar32At
virtual UChar32 getChar32At(int32_t offset) const override
The change in Replaceable to use virtual getChar32At() allows UnicodeString::char32At() to be inline ...
icu::UnicodeString::extract
int32_t extract(int32_t start, int32_t startLength, char *target, uint32_t targetLength) const
Copy the characters in the range [start, start + length) into an array of characters in the platform'...
icu::UnicodeString::fromUTF8
static UnicodeString fromUTF8(StringPiece utf8)
Create a UnicodeString from a UTF-8 string.
icu::UnicodeString::UnicodeString
UNISTR_FROM_CHAR_EXPLICIT UnicodeString(char16_t ch)
Single char16_t (code unit) constructor.
icu::UnicodeString::lastIndexOf
int32_t lastIndexOf(const char16_t *srcChars, int32_t srcStart, int32_t srcLength, int32_t start, int32_t length) const
Locate in this the last occurrence in the range [start, start + length) of the characters in srcChars...
icu::UnicodeString::UnicodeString
UnicodeString(wchar_t *buffer, int32_t buffLength, int32_t buffCapacity)
Writable-aliasing wchar_t * constructor.
Definition: unistr.h:3357
icu::UnicodeString::setToBogus
void setToBogus()
Make this UnicodeString object invalid.
icu::UnicodeString::swap
friend void swap(UnicodeString &s1, UnicodeString &s2) noexcept
Non-member UnicodeString swap function.
Definition: unistr.h:1990
icu::UnicodeString::moveIndex32
int32_t moveIndex32(int32_t index, int32_t delta) const
Move the code unit index along the string by delta code points.
icu::UnicodeString::fromUTF32
static UnicodeString fromUTF32(const UChar32 *utf32, int32_t length)
Create a UnicodeString from a UTF-32 string.
icu::UnicodeString::UnicodeString
UNISTR_FROM_STRING_EXPLICIT UnicodeString(const S &text)
Constructor from text which is, or which is implicitly convertible to, a std::u16string_view or (if U...
Definition: unistr.h:3274
icu::UnicodeString::countChar32
int32_t countChar32(int32_t start=0, int32_t length=INT32_MAX) const
Count Unicode code points in the length char16_t code units of the string.
icu::UnicodeString::UnicodeString
UNISTR_FROM_CHAR_EXPLICIT UnicodeString(UChar32 ch)
Single UChar32 (code point) constructor.
icu::UnicodeString::setTo
UnicodeString & setTo(UBool isTerminated, ConstChar16Ptr text, int32_t textLength)
Aliasing setTo() function, analogous to the readonly-aliasing char16_t* constructor.
icu::UnicodeString::readOnlyAlias
static UnicodeString readOnlyAlias(const S &text)
Readonly-aliasing factory method.
Definition: unistr.h:3600
icu::UnicodeString::operator+=
UnicodeString & operator+=(const S &src)
Append operator.
Definition: unistr.h:2227
icu::UnicodeString::toTitle
UnicodeString & toTitle(BreakIterator *titleIter, const Locale &locale, uint32_t options)
Titlecase this string, with options.
icu::UnicodeString::clone
virtual UnicodeString * clone() const override
Clone this object, an instance of a subclass of Replaceable.
icu::UnicodeString::extract
int32_t extract(char *dest, int32_t destCapacity, UConverter *cnv, UErrorCode &errorCode) const
Convert the UnicodeString into a codepage string using an existing UConverter.
icu::UnicodeString::UnicodeString
UnicodeString(UnicodeString &&src) noexcept
Move constructor; might leave src in bogus state.
icu::UnicodeString::UnicodeString
UnicodeString(const char16_t *text, int32_t textLength)
char16_t* constructor.
icu::UnicodeString::replace
UnicodeString & replace(int32_t start, int32_t length, UChar32 srcChar)
Replace the characters in the range [start, start + length) with the code point srcChar.
icu::UnicodeString::UnicodeString
UnicodeString(const char *src, int32_t srcLength, UConverter *cnv, UErrorCode &errorCode)
char * / UConverter constructor.
icu::UnicodeString::UnicodeString
UnicodeString(const char *codepageData, int32_t dataLength)
char* constructor.
icu::UnicodeString::getStaticClassID
static UClassID getStaticClassID()
ICU "poor man's RTTI", returns a UClassID for this class.
icu::UnicodeString::UnicodeString
UnicodeString(uint16_t *buffer, int32_t buffLength, int32_t buffCapacity)
Writable-aliasing uint16_t * constructor.
Definition: unistr.h:3343
icu::UnicodeString::toUTF32
int32_t toUTF32(UChar32 *utf32, int32_t capacity, UErrorCode &errorCode) const
Convert the UnicodeString to UTF-32.
icu::UnicodeString::isBogus
UBool isBogus() const
Determine if this object contains a valid string.
Definition: unistr.h:4229
icu::UnicodeString::getTerminatedBuffer
const char16_t * getTerminatedBuffer()
Get a read-only pointer to the internal buffer, making sure that it is NUL-terminated.
icu::UnicodeString::UnicodeString
UnicodeString(const uint16_t *text, int32_t textLength)
uint16_t * constructor.
Definition: unistr.h:3225
icu::UnicodeString::getDynamicClassID
virtual UClassID getDynamicClassID() const override
ICU "poor man's RTTI", returns a UClassID for the actual class.
icu::UnicodeString::extract
int32_t extract(int32_t start, int32_t startLength, char *target, int32_t targetCapacity, enum EInvariant inv) const
Copy the characters in the range [start, start + startLength) into an array of characters.
icu::UnicodeString::setCharAt
UnicodeString & setCharAt(int32_t offset, char16_t ch)
Set the character at the specified offset to the specified character.
icu::UnicodeString::setTo
UnicodeString & setTo(char16_t *buffer, int32_t buffLength, int32_t buffCapacity)
Aliasing setTo() function, analogous to the writable-aliasing char16_t* constructor.
icu::UnicodeString::padTrailing
UBool padTrailing(int32_t targetLength, char16_t padChar=0x0020)
Pad the end of this UnicodeString with the character padChar.
icu::UnicodeString::UnicodeString
UNISTR_FROM_STRING_EXPLICIT UnicodeString(const char *codepageData)
char* constructor.
icu::UnicodeString::releaseBuffer
void releaseBuffer(int32_t newLength=-1)
Release a read/write buffer on a UnicodeString object with an "open" getBuffer(minCapacity).
icu::UnicodeString::getBuffer
char16_t * getBuffer(int32_t minCapacity)
Get a read/write pointer to the internal buffer.
icu::UnicodeString::toUTF8
void toUTF8(ByteSink &sink) const
Convert the UnicodeString to UTF-8 and write the result to a ByteSink.
icu::UnicodeString::hasMetaData
virtual UBool hasMetaData() const override
Replaceable API.
icu::UnicodeString::toUpper
UnicodeString & toUpper()
Convert the characters in this to UPPER CASE following the conventions of the default locale.
icu::UnicodeString::toUpper
UnicodeString & toUpper(const Locale &locale)
Convert the characters in this to UPPER CASE following the conventions of a specific locale.
icu::UnicodeString::trim
UnicodeString & trim()
Trims leading and trailing whitespace from this UnicodeString.
u_strlen
U_CAPI int32_t u_strlen(const UChar *s)
icu::operator==
U_EXPORT UBool operator==(const StringPiece &x, const StringPiece &y)
Global operator == for StringPiece.
icu::unistr_internalConcat
U_COMMON_API UnicodeString unistr_internalConcat(const UnicodeString &s1, std::u16string_view s2)
icu::operator!=
bool operator!=(const StringPiece &x, const StringPiece &y)
Global operator != for StringPiece.
Definition: stringpiece.h:346
icu::operator+
UnicodeString operator+(const UnicodeString &s1, const S &s2)
Creates a new UnicodeString from the concatenation of a UnicodeString and s2 which is,...
Definition: unistr.h:4117
U_CALLCONV
#define U_CALLCONV
Similar to U_CDECL_BEGIN/U_CDECL_END, this qualifier is necessary in callback function typedefs to ma...
Definition: platform.h:846
rep.h
C++ API: Replaceable String.
std_string.h
C++ API: Central ICU header for including the C++ standard <string> header and for related definition...
stringpiece.h
C++ API: StringPiece: Read-only byte string wrapper class.
UConverter
struct UConverter UConverter
Definition: ucnv_err.h:96
UCONFIG_NO_BREAK_ITERATION
#define UCONFIG_NO_BREAK_ITERATION
This switch turns off break iteration.
Definition: uconfig.h:358
UChar32
int32_t UChar32
Define UChar32 as a type for single Unicode code points.
Definition: umachine.h:427
INT32_MAX
#define INT32_MAX
The largest value a 32 bit signed integer can hold.
Definition: umachine.h:186
UBool
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition: umachine.h:247
U_CAPI
#define U_CAPI
This is used to declare a function as a public ICU C API.
Definition: umachine.h:110
UChar
char16_t UChar
The base type for UTF-16 code units and pointers.
Definition: umachine.h:378
U_SIZEOF_UCHAR
#define U_SIZEOF_UCHAR
Number of bytes in a UChar (always 2).
Definition: umachine.h:330
UNISTR_FROM_CHAR_EXPLICIT
#define UNISTR_FROM_CHAR_EXPLICIT
This can be defined to be empty or "explicit".
Definition: unistr.h:150
UStringCaseMapper
int32_t UStringCaseMapper(int32_t caseLocale, uint32_t options, icu::BreakIterator *iter, char16_t *dest, int32_t destCapacity, const char16_t *src, int32_t srcLength, icu::Edits *edits, UErrorCode &errorCode)
Internal string case mapping function type.
Definition: unistr.h:71
UNISTR_FROM_STRING_EXPLICIT
#define UNISTR_FROM_STRING_EXPLICIT
This can be defined to be empty or "explicit".
Definition: unistr.h:170
UNISTR_OBJECT_SIZE
#define UNISTR_OBJECT_SIZE
Desired sizeof(UnicodeString) in bytes.
Definition: unistr.h:208
UClassID
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition: uobject.h:96
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
UErrorCode
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition: utypes.h:430
U_COMMON_API
#define U_COMMON_API
Set to export library symbols from inside the common library, and to import them from outside.
Definition: utypes.h:315
Generated by doxygen 1.9.1