../deps/icu-small/source/common/unicode/unistr.h

Bug Summary

File:	out/../deps/icu-small/source/common/unicode/unistr.h
Warning:	line 4542, column 74 The result of the left shift is undefined because the left operand is negative

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name unistr.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/common/unistr.cpp

../deps/icu-small/source/common/unistr.cpp

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5* Copyright (C) 1999-2016, International Business Machines Corporation and
6* others. All Rights Reserved.
7******************************************************************************
8*
9* File unistr.cpp
10*
11* Modification History:
12*
13*   Date        Name        Description
14*   09/25/98    stephen     Creation.
15*   04/20/99    stephen     Overhauled per 4/16 code review.
16*   07/09/99    stephen     Renamed {hi,lo},{byte,word} to icu_X for HP/UX
17*   11/18/99    aliu        Added handleReplaceBetween() to make inherit from
18*                           Replaceable.
19*   06/25/01    grhoten     Removed the dependency on iostream
20******************************************************************************
21*/

23#include "unicode/utypes.h"
24#include "unicode/appendable.h"
25#include "unicode/putil.h"
26#include "cstring.h"
27#include "cmemory.h"
28#include "unicode/ustring.h"
29#include "unicode/unistr.h"
30#include "unicode/utf.h"
31#include "unicode/utf16.h"
32#include "uelement.h"
33#include "ustr_imp.h"
34#include "umutex.h"
35#include "uassert.h"

37#if 0

39#include <iostream>
40using namespace std;

42//DEBUGGING
43void
44print(const UnicodeString& s,
    const char *name)
46{
UChar c;
cout << name << ":|";
for(int i = 0; i < s.length(); ++i) {
  c = s[i];
  if(c>= 0x007E || c < 0x0020)
    cout << "[0x" << hex << s[i] << "]";
  else
    cout << (char) s[i];
}
cout << '|' << endl;
57}

59void
60print(const UChar *s,
    int32_t len,
    const char *name)
63{
UChar c;
cout << name << ":|";
for(int i = 0; i < len; ++i) {
  c = s[i];
  if(c>= 0x007E || c < 0x0020)
    cout << "[0x" << hex << s[i] << "]";
  else
    cout << (char) s[i];
}
cout << '|' << endl;
74}
75// END DEBUGGING
76#endif

78// Local function definitions for now

80// need to copy areas that may overlap
81static
82inline void
83us_arrayCopy(const UChar *src, int32_t srcStart,
       UChar *dst, int32_t dstStart, int32_t count)
85{
if(count>0) {
  uprv_memmove(dst+dstStart, src+srcStart, (size_t)count*sizeof(*src))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memmove(dst+dstStart
, src+srcStart, (size_t)count*sizeof(*src)); } while (false);
}
89}

91// u_unescapeAt() callback to get a UChar from a UnicodeString
92U_CDECL_BEGINextern "C" {
93static UChar U_CALLCONV
94UnicodeString_charAt(int32_t offset, void *context) {
  return ((icu::UnicodeString*) context)->charAt(offset);
96}
97U_CDECL_END}

99U_NAMESPACE_BEGINnamespace icu_71 {

101/* The Replaceable virtual destructor can't be defined in the header
 due to how AIX works with multiple definitions of virtual functions.
103*/
104Replaceable::~Replaceable() {}

106UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeString)UClassID UnicodeString::getStaticClassID() { static char classID
 = 0; return (UClassID)&classID; } UClassID UnicodeString
::getDynamicClassID() const { return UnicodeString::getStaticClassID
(); }

108UnicodeString U_EXPORT2
109operator+ (const UnicodeString &s1, const UnicodeString &s2) {
  return
      UnicodeString(s1.length()+s2.length()+1, (UChar32)0, 0).
          append(s1).
              append(s2);
114}

116//========================================
117// Reference Counting functions, put at top of file so that optimizing compilers
118//                               have a chance to automatically inline.
119//========================================

121void
122UnicodeString::addRef() {
umtx_atomic_inc((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
124}

126int32_t
127UnicodeString::removeRef() {
return umtx_atomic_dec((u_atomic_int32_t *)fUnion.fFields.fArray - 1);
129}

131int32_t
132UnicodeString::refCount() const {
return umtx_loadAcquire(*((u_atomic_int32_t *)fUnion.fFields.fArray - 1));
134}

136void
137UnicodeString::releaseArray() {
if((fUnion.fFields.fLengthAndFlags & kRefCounted) && removeRef() == 0) {
  uprv_freeuprv_free_71((int32_t *)fUnion.fFields.fArray - 1);
}
141}



145//========================================
146// Constructors
147//========================================

149// The default constructor is inline in unistr.h.

151UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count) {
fUnion.fFields.fLengthAndFlags = 0;
if(count <= 0 || (uint32_t)c > 0x10ffff) {
  // just allocate and do not do anything else
  allocate(capacity);
} else if(c <= 0xffff) {
  int32_t length = count;
  if(capacity < length) {
    capacity = length;
  }
  if(allocate(capacity)) {
    UChar *array = getArrayStart();
    UChar unit = (UChar)c;
    for(int32_t i = 0; i < length; ++i) {
      array[i] = unit;
    }
    setLength(length);
  }
} else {  // supplementary code point, write surrogate pairs
  if(count > (INT32_MAX(2147483647) / 2)) {
    // We would get more than 2G UChars.
    allocate(capacity);
    return;
  }
  int32_t length = count * 2;
  if(capacity < length) {
    capacity = length;
  }
  if(allocate(capacity)) {
    UChar *array = getArrayStart();
    UChar lead = U16_LEAD(c)(UChar)(((c)>>10)+0xd7c0);
    UChar trail = U16_TRAIL(c)(UChar)(((c)&0x3ff)|0xdc00);
    for(int32_t i = 0; i < length; i += 2) {
      array[i] = lead;
      array[i + 1] = trail;
    }
    setLength(length);
  }
}
190}

192UnicodeString::UnicodeString(UChar ch) {
fUnion.fFields.fLengthAndFlags = kLength1 | kShortString;
fUnion.fStackFields.fBuffer[0] = ch;
195}

197UnicodeString::UnicodeString(UChar32 ch) {
fUnion.fFields.fLengthAndFlags = kShortString;
int32_t i = 0;
UBool isError = FALSE0;
U16_APPEND(fUnion.fStackFields.fBuffer, i, US_STACKBUF_SIZE, ch, isError)do { if((uint32_t)(ch)<=0xffff) { (fUnion.fStackFields.fBuffer
)[(i)++]=(uint16_t)(ch); } else if((uint32_t)(ch)<=0x10ffff
 && (i)+1<(US_STACKBUF_SIZE)) { (fUnion.fStackFields
.fBuffer)[(i)++]=(uint16_t)(((ch)>>10)+0xd7c0); (fUnion
.fStackFields.fBuffer)[(i)++]=(uint16_t)(((ch)&0x3ff)|0xdc00
); } else { (isError)=true; } } while (false);
// We test isError so that the compiler does not complain that we don't.
// If isError then i==0 which is what we want anyway.
if(!isError) {
  setShortLength(i);
}
207}

209UnicodeString::UnicodeString(const UChar *text) {
fUnion.fFields.fLengthAndFlags = kShortString;
doAppend(text, 0, -1);
212}

214UnicodeString::UnicodeString(const UChar *text,
                           int32_t textLength) {
fUnion.fFields.fLengthAndFlags = kShortString;
doAppend(text, 0, textLength);
218}

220UnicodeString::UnicodeString(UBool isTerminated,
                           ConstChar16Ptr textPtr,
                           int32_t textLength) {
fUnion.fFields.fLengthAndFlags = kReadonlyAlias;
const UChar *text = textPtr;
if(text == NULL__null) {
  // treat as an empty string, do not alias
  setToEmpty();
} else if(textLength < -1 ||
          (textLength == -1 && !isTerminated) ||
          (textLength >= 0 && isTerminated && text[textLength] != 0)
) {
  setToBogus();
} else {
  if(textLength == -1) {
    // text is terminated, or else it would have failed the above test
    textLength = u_strlenu_strlen_71(text);
  }
  setArray(const_cast<UChar *>(text), textLength,
           isTerminated ? textLength + 1 : textLength);
}
241}

243UnicodeString::UnicodeString(UChar *buff,
                           int32_t buffLength,
                           int32_t buffCapacity) {
fUnion.fFields.fLengthAndFlags = kWritableAlias;
if(buff == NULL__null) {
  // treat as an empty string, do not alias
  setToEmpty();
} else if(buffLength < -1 || buffCapacity < 0 || buffLength > buffCapacity) {
  setToBogus();
} else {
  if(buffLength == -1) {
    // fLength = u_strlen(buff); but do not look beyond buffCapacity
    const UChar *p = buff, *limit = buff + buffCapacity;
    while(p != limit && *p != 0) {
      ++p;
    }
    buffLength = (int32_t)(p - buff);
  }
  setArray(buff, buffLength, buffCapacity);
}
263}

265UnicodeString::UnicodeString(const char *src, int32_t length, EInvariant) {
fUnion.fFields.fLengthAndFlags = kShortString;
if(src==NULL__null) {
  // treat as an empty string
} else {
  if(length<0) {
    length=(int32_t)uprv_strlen(src):: strlen(src);
  }
  if(cloneArrayIfNeeded(length, length, FALSE0)) {
    u_charsToUCharsu_charsToUChars_71(src, getArrayStart(), length);
    setLength(length);
  } else {
    setToBogus();
  }
}
280}

282#if U_CHARSET_IS_UTF81

284UnicodeString::UnicodeString(const char *codepageData) {
fUnion.fFields.fLengthAndFlags = kShortString;
if(codepageData != 0) {
  setToUTF8(codepageData);
}
289}

291UnicodeString::UnicodeString(const char *codepageData, int32_t dataLength) {
fUnion.fFields.fLengthAndFlags = kShortString;
// if there's nothing to convert, do nothing
if(codepageData == 0 || dataLength == 0 || dataLength < -1) {
  return;
}
if(dataLength == -1) {
  dataLength = (int32_t)uprv_strlen(codepageData):: strlen(codepageData);
}
setToUTF8(StringPiece(codepageData, dataLength));
301}

303// else see unistr_cnv.cpp
304#endif

306UnicodeString::UnicodeString(const UnicodeString& that) {
fUnion.fFields.fLengthAndFlags = kShortString;
copyFrom(that);
309}

311UnicodeString::UnicodeString(UnicodeString &&src) U_NOEXCEPTnoexcept {
copyFieldsFrom(src, TRUE1);
313}

315UnicodeString::UnicodeString(const UnicodeString& that,
                           int32_t srcStart) {
fUnion.fFields.fLengthAndFlags = kShortString;
setTo(that, srcStart);
319}

321UnicodeString::UnicodeString(const UnicodeString& that,
                           int32_t srcStart,
                           int32_t srcLength) {
fUnion.fFields.fLengthAndFlags = kShortString;
setTo(that, srcStart, srcLength);
326}

328// Replaceable base class clone() default implementation, does not clone
329Replaceable *
330Replaceable::clone() const {
return NULL__null;
332}

334// UnicodeString overrides clone() with a real implementation
335UnicodeString *
336UnicodeString::clone() const {
LocalPointer<UnicodeString> clonedString(new UnicodeString(*this));
return clonedString.isValid() && !clonedString->isBogus() ? clonedString.orphan() : nullptr;
339}

341//========================================
342// array allocation
343//========================================

345namespace {

347const int32_t kGrowSize = 128;

349// The number of bytes for one int32_t reference counter and capacity UChars
350// must fit into a 32-bit size_t (at least when on a 32-bit platform).
351// We also add one for the NUL terminator, to avoid reallocation in getTerminatedBuffer(),
352// and round up to a multiple of 16 bytes.
353// This means that capacity must be at most (0xfffffff0 - 4) / 2 - 1 = 0x7ffffff5.
354// (With more complicated checks we could go up to 0x7ffffffd without rounding up,
355// but that does not seem worth it.)
356const int32_t kMaxCapacity = 0x7ffffff5;

358int32_t getGrowCapacity(int32_t newLength) {
int32_t growSize = (newLength >> 2) + kGrowSize;
if(growSize <= (kMaxCapacity - newLength)) {
  return newLength + growSize;
} else {
  return kMaxCapacity;
}
365}

367}  // namespace

369UBool
370UnicodeString::allocate(int32_t capacity) {
if(capacity <= US_STACKBUF_SIZE) {
  fUnion.fFields.fLengthAndFlags = kShortString;
  return TRUE1;
}
if(capacity <= kMaxCapacity) {
  ++capacity;  // for the NUL
  // Switch to size_t which is unsigned so that we can allocate up to 4GB.
  // Reference counter + UChars.
  size_t numBytes = sizeof(int32_t) + (size_t)capacity * U_SIZEOF_UCHAR2;
  // Round up to a multiple of 16.
  numBytes = (numBytes + 15) & ~15;
  int32_t *array = (int32_t *) uprv_mallocuprv_malloc_71(numBytes);
  if(array != NULL__null) {
    // set initial refCount and point behind the refCount
    *array++ = 1;
    numBytes -= sizeof(int32_t);

    // have fArray point to the first UChar
    fUnion.fFields.fArray = (UChar *)array;
    fUnion.fFields.fCapacity = (int32_t)(numBytes / U_SIZEOF_UCHAR2);
    fUnion.fFields.fLengthAndFlags = kLongString;
    return TRUE1;
  }
}
fUnion.fFields.fLengthAndFlags = kIsBogus;
fUnion.fFields.fArray = 0;
fUnion.fFields.fCapacity = 0;
return FALSE0;
399}

401//========================================
402// Destructor
403//========================================

405#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS
406static u_atomic_int32_t finalLengthCounts[0x400];  // UnicodeString::kMaxShortLength+1
407static u_atomic_int32_t beyondCount(0);

409U_CAPIextern "C" void unistr_printLengths() {
int32_t i;
for(i = 0; i <= 59; ++i) {
  printf("%2d,  %9d\n", i, (int32_t)finalLengthCounts[i]);
}
int32_t beyond = beyondCount;
for(; i < UPRV_LENGTHOF(finalLengthCounts)(int32_t)(sizeof(finalLengthCounts)/sizeof((finalLengthCounts
)[0])); ++i) {
  beyond += finalLengthCounts[i];
}
printf(">59, %9d\n", beyond);
419}
420#endif

422UnicodeString::~UnicodeString()
423{
424#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS
// Count lengths of strings at the end of their lifetime.
// Useful for discussion of a desirable stack buffer size.
// Count the contents length, not the optional NUL terminator nor further capacity.
// Ignore open-buffer strings and strings which alias external storage.
if((fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kReadonlyAlias|kWritableAlias)) == 0) {
  if(hasShortLength()) {
    umtx_atomic_inc(finalLengthCounts + getShortLength());
  } else {
    umtx_atomic_inc(&beyondCount);
  }
}
436#endif

releaseArray();
439}

441//========================================
442// Factory methods
443//========================================

445UnicodeString UnicodeString::fromUTF8(StringPiece utf8) {
UnicodeString result;
result.setToUTF8(utf8);
return result;
449}

451UnicodeString UnicodeString::fromUTF32(const UChar32 *utf32, int32_t length) {
UnicodeString result;
int32_t capacity;
// Most UTF-32 strings will be BMP-only and result in a same-length
// UTF-16 string. We overestimate the capacity just slightly,
// just in case there are a few supplementary characters.
if(length <= US_STACKBUF_SIZE) {
  capacity = US_STACKBUF_SIZE;
} else {
  capacity = length + (length >> 4) + 4;
}
do {
  UChar *utf16 = result.getBuffer(capacity);
  int32_t length16;
  UErrorCode errorCode = U_ZERO_ERROR;
  u_strFromUTF32WithSubu_strFromUTF32WithSub_71(utf16, result.getCapacity(), &length16,
      utf32, length,
      0xfffd,  // Substitution character.
      NULL__null,    // Don't care about number of substitutions.
      &errorCode);
  result.releaseBuffer(length16);
  if(errorCode == U_BUFFER_OVERFLOW_ERROR) {
    capacity = length16 + 1;  // +1 for the terminating NUL.
    continue;
  } else if(U_FAILURE(errorCode)) {
    result.setToBogus();
  }
  break;
} while(TRUE1);
return result;
481}

483//========================================
484// Assignment
485//========================================

487UnicodeString &
488UnicodeString::operator=(const UnicodeString &src) {
return copyFrom(src);
490}

492UnicodeString &
493UnicodeString::fastCopyFrom(const UnicodeString &src) {
return copyFrom(src, TRUE1);
495}

497UnicodeString &
498UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) {
// if assigning to ourselves, do nothing
if(this == &src) {
  return *this;
}

// is the right side bogus?
if(src.isBogus()) {
  setToBogus();
  return *this;
}

// delete the current contents
releaseArray();

if(src.isEmpty()) {
  // empty string - use the stack buffer
  setToEmpty();
  return *this;
}

// fLength>0 and not an "open" src.getBuffer(minCapacity)
fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags;
switch(src.fUnion.fFields.fLengthAndFlags & kAllStorageFlags) {
case kShortString:
  // short string using the stack buffer, do the same
  uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer,do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false)
              getShortLength() * U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false);
  break;
case kLongString:
  // src uses a refCounted string buffer, use that buffer with refCount
  // src is const, use a cast - we don't actually change it
  ((UnicodeString &)src).addRef();
  // copy all fields, share the reference-counted buffer
  fUnion.fFields.fArray = src.fUnion.fFields.fArray;
  fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;
  if(!hasShortLength()) {
    fUnion.fFields.fLength = src.fUnion.fFields.fLength;
  }
  break;
case kReadonlyAlias:
  if(fastCopy) {
    // src is a readonly alias, do the same
    // -> maintain the readonly alias as such
    fUnion.fFields.fArray = src.fUnion.fFields.fArray;
    fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;
    if(!hasShortLength()) {
      fUnion.fFields.fLength = src.fUnion.fFields.fLength;
    }
    break;
  }
  // else if(!fastCopy) fall through to case kWritableAlias
  // -> allocate a new buffer and copy the contents
  U_FALLTHROUGH[[clang::fallthrough]];
case kWritableAlias: {
  // src is a writable alias; we make a copy of that instead
  int32_t srcLength = src.length();
  if(allocate(srcLength)) {
    u_memcpyu_memcpy_71(getArrayStart(), src.getArrayStart(), srcLength);
    setLength(srcLength);
    break;
  }
  // if there is not enough memory, then fall through to setting to bogus
  U_FALLTHROUGH[[clang::fallthrough]];
}
default:
  // if src is bogus, set ourselves to bogus
  // do not call setToBogus() here because fArray and flags are not consistent here
  fUnion.fFields.fLengthAndFlags = kIsBogus;
  fUnion.fFields.fArray = 0;
  fUnion.fFields.fCapacity = 0;
  break;
}

return *this;
573}

575UnicodeString &UnicodeString::operator=(UnicodeString &&src) U_NOEXCEPTnoexcept {
// No explicit check for self move assignment, consistent with standard library.
// Self move assignment causes no crash nor leak but might make the object bogus.
releaseArray();
copyFieldsFrom(src, TRUE1);
return *this;
581}

583// Same as move assignment except without memory management.
584void UnicodeString::copyFieldsFrom(UnicodeString &src, UBool setSrcToBogus) U_NOEXCEPTnoexcept {
int16_t lengthAndFlags = fUnion.fFields.fLengthAndFlags = src.fUnion.fFields.fLengthAndFlags;
if(lengthAndFlags & kUsingStackBuffer) {
  // Short string using the stack buffer, copy the contents.
  // Check for self assignment to prevent "overlap in memcpy" warnings,
  // although it should be harmless to copy a buffer to itself exactly.
  if(this != &src) {
    uprv_memcpy(fUnion.fStackFields.fBuffer, src.fUnion.fStackFields.fBuffer,do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false)
                getShortLength() * U_SIZEOF_UCHAR)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (void)0; (void)0; clang diagnostic pop
 :: memcpy(fUnion.fStackFields
.fBuffer, src.fUnion.fStackFields.fBuffer, getShortLength() *
 2); } while (false);
  }
} else {
  // In all other cases, copy all fields.
  fUnion.fFields.fArray = src.fUnion.fFields.fArray;
  fUnion.fFields.fCapacity = src.fUnion.fFields.fCapacity;
  if(!hasShortLength()) {
    fUnion.fFields.fLength = src.fUnion.fFields.fLength;
  }
  if(setSrcToBogus) {
    // Set src to bogus without releasing any memory.
    src.fUnion.fFields.fLengthAndFlags = kIsBogus;
    src.fUnion.fFields.fArray = NULL__null;
    src.fUnion.fFields.fCapacity = 0;
  }
}
608}

610void UnicodeString::swap(UnicodeString &other) U_NOEXCEPTnoexcept {
UnicodeString temp;  // Empty short string: Known not to need releaseArray().
// Copy fields without resetting source values in between.
temp.copyFieldsFrom(*this, FALSE0);
this->copyFieldsFrom(other, FALSE0);
other.copyFieldsFrom(temp, FALSE0);
// Set temp to an empty string so that other's memory is not released twice.
temp.fUnion.fFields.fLengthAndFlags = kShortString;
618}

620//========================================
621// Miscellaneous operations
622//========================================

624UnicodeString UnicodeString::unescape() const {
  UnicodeString result(length(), (UChar32)0, (int32_t)0); // construct with capacity
  if (result.isBogus()) {
      return result;
  }
  const UChar *array = getBuffer();
  int32_t len = length();
  int32_t prev = 0;
  for (int32_t i=0;;) {
      if (i == len) {
          result.append(array, prev, len - prev);
          break;
      }
      if (array[i++] == 0x5C /*'\\'*/) {
          result.append(array, prev, (i - 1) - prev);
          UChar32 c = unescapeAt(i); // advances i
          if (c < 0) {
              result.remove(); // return empty string
              break; // invalid escape sequence
          }
          result.append(c);
          prev = i;
      }
  }
  return result;
649}

651UChar32 UnicodeString::unescapeAt(int32_t &offset) const {
  return u_unescapeAtu_unescapeAt_71(UnicodeString_charAt, &offset, length(), (void*)this);
653}

655//========================================
656// Read-only implementation
657//========================================
658UBool
659UnicodeString::doEquals(const UnicodeString &text, int32_t len) const {
// Requires: this & text not bogus and have same lengths.
// Byte-wise comparison works for equality regardless of endianness.
return uprv_memcmp(getArrayStart(), text.getArrayStart(), len * U_SIZEOF_UCHAR):: memcmp(getArrayStart(), text.getArrayStart(),len * 2) == 0;
663}

665int8_t
666UnicodeString::doCompare( int32_t start,
            int32_t length,
            const UChar *srcChars,
            int32_t srcStart,
            int32_t srcLength) const
671{
// compare illegal string values
if(isBogus()) {
  return -1;
}

// pin indices to legal values
pinIndices(start, length);

if(srcChars == NULL__null) {
  // treat const UChar *srcChars==NULL as an empty string
  return length == 0 ? 0 : 1;
}

// get the correct pointer
const UChar *chars = getArrayStart();

chars += start;
srcChars += srcStart;

int32_t minLength;
int8_t lengthResult;

// get the srcLength if necessary
if(srcLength < 0) {
  srcLength = u_strlenu_strlen_71(srcChars + srcStart);
}

// are we comparing different lengths?
if(length != srcLength) {
  if(length < srcLength) {
    minLength = length;
    lengthResult = -1;
  } else {
    minLength = srcLength;
    lengthResult = 1;
  }
} else {
  minLength = length;
  lengthResult = 0;
}

/*
 * note that uprv_memcmp() returns an int but we return an int8_t;
 * we need to take care not to truncate the result -
 * one way to do this is to right-shift the value to
 * move the sign bit into the lower 8 bits and making sure that this
 * does not become 0 itself
 */

if(minLength > 0 && chars != srcChars) {
  int32_t result;

724#   if U_IS_BIG_ENDIAN(1234 == 4321) 
    // big-endian: byte comparison works
    result = uprv_memcmp(chars, srcChars, minLength * sizeof(UChar)):: memcmp(chars, srcChars,minLength * sizeof(UChar));
    if(result != 0) {
      return (int8_t)(result >> 15 | 1);
    }
730#   else
    // little-endian: compare UChar units
    do {
      result = ((int32_t)*(chars++) - (int32_t)*(srcChars++));
      if(result != 0) {
        return (int8_t)(result >> 15 | 1);
      }
    } while(--minLength > 0);
738#   endif
}
return lengthResult;
741}

743/* String compare in code point order - doCompare() compares in code unit order. */
744int8_t
745UnicodeString::doCompareCodePointOrder(int32_t start,
                                     int32_t length,
                                     const UChar *srcChars,
                                     int32_t srcStart,
                                     int32_t srcLength) const
750{
// compare illegal string values
// treat const UChar *srcChars==NULL as an empty string
if(isBogus()) {
  return -1;
}

// pin indices to legal values
pinIndices(start, length);

if(srcChars == NULL__null) {
  srcStart = srcLength = 0;
}

int32_t diff = uprv_strCompareuprv_strCompare_71(getArrayStart() + start, length, (srcChars!=NULL__null)?(srcChars + srcStart):NULL__null, srcLength, FALSE0, TRUE1);
/* translate the 32-bit result into an 8-bit one */
if(diff!=0) {
  return (int8_t)(diff >> 15 | 1);
} else {
  return 0;
}
771}

773int32_t
774UnicodeString::getLength() const {
  return length();
776}

778UChar
779UnicodeString::getCharAt(int32_t offset) const {
return charAt(offset);
781}

783UChar32
784UnicodeString::getChar32At(int32_t offset) const {
return char32At(offset);
786}

788UChar32
789UnicodeString::char32At(int32_t offset) const
790{
int32_t len = length();
if((uint32_t)offset < (uint32_t)len) {
  const UChar *array = getArrayStart();
  UChar32 c;
  U16_GET(array, 0, offset, len, c)do { (c)=(array)[offset]; if((((c)&0xfffff800)==0xd800)) {
 uint16_t __c2; if((((c)&0x400)==0)) { if((offset)+1!=(len
) && (((__c2=(array)[(offset)+1])&0xfffffc00)==0xdc00
)) { (c)=(((UChar32)((c))<<10UL)+(UChar32)(__c2)-((0xd800
<<10UL)+0xdc00-0x10000)); } } else { if((offset)>(0)
 && (((__c2=(array)[(offset)-1])&0xfffffc00)==0xd800
)) { (c)=(((UChar32)(__c2)<<10UL)+(UChar32)((c))-((0xd800
<<10UL)+0xdc00-0x10000)); } } } } while (false);
  return c;
} else {
  return kInvalidUChar;
}
800}

802int32_t
803UnicodeString::getChar32Start(int32_t offset) const {
if((uint32_t)offset < (uint32_t)length()) {
  const UChar *array = getArrayStart();
  U16_SET_CP_START(array, 0, offset)do { if(((((array)[offset])&0xfffffc00)==0xdc00) &&
 (offset)>(0) && ((((array)[(offset)-1])&0xfffffc00
)==0xd800)) { --(offset); } } while (false);
  return offset;
} else {
  return 0;
}
811}

813int32_t
814UnicodeString::getChar32Limit(int32_t offset) const {
int32_t len = length();
if((uint32_t)offset < (uint32_t)len) {
  const UChar *array = getArrayStart();
  U16_SET_CP_LIMIT(array, 0, offset, len)do { if((0)<(offset) && ((offset)<(len) || (len
)<0) && ((((array)[(offset)-1])&0xfffffc00)==0xd800
) && ((((array)[offset])&0xfffffc00)==0xdc00)) { ++
(offset); } } while (false);
  return offset;
} else {
  return len;
}
823}

825int32_t
826UnicodeString::countChar32(int32_t start, int32_t length) const {
pinIndices(start, length);
// if(isBogus()) then fArray==0 and start==0 - u_countChar32() checks for NULL
return u_countChar32u_countChar32_71(getArrayStart()+start, length);
830}

832UBool
833UnicodeString::hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const {
pinIndices(start, length);
// if(isBogus()) then fArray==0 and start==0 - u_strHasMoreChar32Than() checks for NULL
return u_strHasMoreChar32Thanu_strHasMoreChar32Than_71(getArrayStart()+start, length, number);
837}

839int32_t
840UnicodeString::moveIndex32(int32_t index, int32_t delta) const {
// pin index
int32_t len = length();
if(index<0) {
  index=0;
} else if(index>len) {
  index=len;
}

const UChar *array = getArrayStart();
if(delta>0) {
  U16_FWD_N(array, index, len, delta)do { int32_t __N=(delta); while(__N>0 && ((index)<
(len) || ((len)<0 && (array)[index]!=0))) { do { if
(((((array)[(index)++])&0xfffffc00)==0xd800) && (
index)!=(len) && ((((array)[index])&0xfffffc00)==
0xdc00)) { ++(index); } } while (false); --__N; } } while (false
);
} else {
  U16_BACK_N(array, 0, index, -delta)do { int32_t __N=(-delta); while(__N>0 && (index)>
(0)) { do { if(((((array)[--(index)])&0xfffffc00)==0xdc00
) && (index)>(0) && ((((array)[(index)-1])
&0xfffffc00)==0xd800)) { --(index); } } while (false); --
__N; } } while (false);
}

return index;
857}

859void
860UnicodeString::doExtract(int32_t start,
           int32_t length,
           UChar *dst,
           int32_t dstStart) const
864{
// pin indices to legal values
pinIndices(start, length);

// do not copy anything if we alias dst itself
const UChar *array = getArrayStart();
if(array + start != dst + dstStart) {
  us_arrayCopy(array, start, dst, dstStart, length);
}
873}

875int32_t
876UnicodeString::extract(Char16Ptr dest, int32_t destCapacity,
                     UErrorCode &errorCode) const {
int32_t len = length();
if(U_SUCCESS(errorCode)) {
  if(isBogus() || destCapacity<0 || (destCapacity>0 && dest==0)) {
    errorCode=U_ILLEGAL_ARGUMENT_ERROR;
  } else {
    const UChar *array = getArrayStart();
    if(len>0 && len<=destCapacity && array!=dest) {
      u_memcpyu_memcpy_71(dest, array, len);
    }
    return u_terminateUCharsu_terminateUChars_71(dest, destCapacity, len, &errorCode);
  }
}

return len;
892}

894int32_t
895UnicodeString::extract(int32_t start,
                     int32_t length,
                     char *target,
                     int32_t targetCapacity,
                     enum EInvariant) const
900{
// if the arguments are illegal, then do nothing
if(targetCapacity < 0 || (targetCapacity > 0 && target == NULL__null)) {
  return 0;
}

// pin the indices to legal values
pinIndices(start, length);

if(length <= targetCapacity) {
  u_UCharsToCharsu_UCharsToChars_71(getArrayStart() + start, target, length);
}
UErrorCode status = U_ZERO_ERROR;
return u_terminateCharsu_terminateChars_71(target, targetCapacity, length, &status);
914}

916UnicodeString
917UnicodeString::tempSubString(int32_t start, int32_t len) const {
pinIndices(start, len);
const UChar *array = getBuffer();  // not getArrayStart() to check kIsBogus & kOpenGetBuffer
if(array==NULL__null) {
  array=fUnion.fStackFields.fBuffer;  // anything not NULL because that would make an empty string
  len=-2;  // bogus result string
}
return UnicodeString(FALSE0, array + start, len);
925}

927int32_t
928UnicodeString::toUTF8(int32_t start, int32_t len,
                    char *target, int32_t capacity) const {
pinIndices(start, len);
int32_t length8;
UErrorCode errorCode = U_ZERO_ERROR;
u_strToUTF8WithSubu_strToUTF8WithSub_71(target, capacity, &length8,
                   getBuffer() + start, len,
                   0xFFFD,  // Standard substitution character.
                   NULL__null,    // Don't care about number of substitutions.
                   &errorCode);
return length8;
939}

941#if U_CHARSET_IS_UTF81

943int32_t
944UnicodeString::extract(int32_t start, int32_t len,
                     char *target, uint32_t dstSize) const {
// if the arguments are illegal, then do nothing
if(/*dstSize < 0 || */(dstSize > 0 && target == 0)) {
  return 0;
}
return toUTF8(start, len, target, dstSize <= 0x7fffffff ? (int32_t)dstSize : 0x7fffffff);
951}

953// else see unistr_cnv.cpp
954#endif

956void 
957UnicodeString::extractBetween(int32_t start,
                int32_t limit,
                UnicodeString& target) const {
pinIndex(start);
pinIndex(limit);
doExtract(start, limit - start, target);
963}

965// When converting from UTF-16 to UTF-8, the result will have at most 3 times
966// as many bytes as the source has UChars.
967// The "worst cases" are writing systems like Indic, Thai and CJK with
968// 3:1 bytes:UChars.
969void
970UnicodeString::toUTF8(ByteSink &sink) const {
int32_t length16 = length();
if(length16 != 0) {
  char stackBuffer[1024];
  int32_t capacity = (int32_t)sizeof(stackBuffer);
  UBool utf8IsOwned = FALSE0;
  char *utf8 = sink.GetAppendBuffer(length16 < capacity ? length16 : capacity,
                                    3*length16,
                                    stackBuffer, capacity,
                                    &capacity);
  int32_t length8 = 0;
  UErrorCode errorCode = U_ZERO_ERROR;
  u_strToUTF8WithSubu_strToUTF8WithSub_71(utf8, capacity, &length8,
                     getBuffer(), length16,
                     0xFFFD,  // Standard substitution character.
                     NULL__null,    // Don't care about number of substitutions.
                     &errorCode);
  if(errorCode == U_BUFFER_OVERFLOW_ERROR) {
    utf8 = (char *)uprv_mallocuprv_malloc_71(length8);
    if(utf8 != NULL__null) {
      utf8IsOwned = TRUE1;
      errorCode = U_ZERO_ERROR;
      u_strToUTF8WithSubu_strToUTF8WithSub_71(utf8, length8, &length8,
                         getBuffer(), length16,
                         0xFFFD,  // Standard substitution character.
                         NULL__null,    // Don't care about number of substitutions.
                         &errorCode);
    } else {
      errorCode = U_MEMORY_ALLOCATION_ERROR;
    }
  }
  if(U_SUCCESS(errorCode)) {
    sink.Append(utf8, length8);
    sink.Flush();
  }
  if(utf8IsOwned) {
    uprv_freeuprv_free_71(utf8);
  }
}
1009}

1011int32_t
1012UnicodeString::toUTF32(UChar32 *utf32, int32_t capacity, UErrorCode &errorCode) const {
int32_t length32=0;
if(U_SUCCESS(errorCode)) {
  // getBuffer() and u_strToUTF32WithSub() check for illegal arguments.
  u_strToUTF32WithSubu_strToUTF32WithSub_71(utf32, capacity, &length32,
      getBuffer(), length(),
      0xfffd,  // Substitution character.
      NULL__null,    // Don't care about number of substitutions.
      &errorCode);
}
return length32;
1023}

1025int32_t 
1026UnicodeString::indexOf(const UChar *srcChars,
             int32_t srcStart,
             int32_t srcLength,
             int32_t start,
             int32_t length) const
1031{
if(isBogus() || srcChars == 0 || srcStart < 0 || srcLength == 0) {
  return -1;
}

// UnicodeString does not find empty substrings
if(srcLength < 0 && srcChars[srcStart] == 0) {
  return -1;
}

// get the indices within bounds
pinIndices(start, length);

// find the first occurrence of the substring
const UChar *array = getArrayStart();
const UChar *match = u_strFindFirstu_strFindFirst_71(array + start, length, srcChars + srcStart, srcLength);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1052}

1054int32_t
1055UnicodeString::doIndexOf(UChar c,
           int32_t start,
           int32_t length) const
1058{
// pin indices
pinIndices(start, length);

// find the first occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memchru_memchr_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1070}

1072int32_t
1073UnicodeString::doIndexOf(UChar32 c,
                       int32_t start,
                       int32_t length) const {
// pin indices
pinIndices(start, length);

// find the first occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memchr32u_memchr32_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1087}

1089int32_t 
1090UnicodeString::lastIndexOf(const UChar *srcChars,
             int32_t srcStart,
             int32_t srcLength,
             int32_t start,
             int32_t length) const
1095{
if(isBogus() || srcChars == 0 || srcStart < 0 || srcLength == 0) {
  return -1;
}

// UnicodeString does not find empty substrings
if(srcLength < 0 && srcChars[srcStart] == 0) {
  return -1;
}

// get the indices within bounds
pinIndices(start, length);

// find the last occurrence of the substring
const UChar *array = getArrayStart();
const UChar *match = u_strFindLastu_strFindLast_71(array + start, length, srcChars + srcStart, srcLength);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1116}

1118int32_t
1119UnicodeString::doLastIndexOf(UChar c,
               int32_t start,
               int32_t length) const
1122{
if(isBogus()) {
  return -1;
}

// pin indices
pinIndices(start, length);

// find the last occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memrchru_memrchr_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1138}

1140int32_t
1141UnicodeString::doLastIndexOf(UChar32 c,
                           int32_t start,
                           int32_t length) const {
// pin indices
pinIndices(start, length);

// find the last occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memrchr32u_memrchr32_71(array + start, c, length);
if(match == NULL__null) {
  return -1;
} else {
  return (int32_t)(match - array);
}
1155}

1157//========================================
1158// Write implementation
1159//========================================

1161UnicodeString& 
1162UnicodeString::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)
1170{
if(isBogus() || oldText.isBogus() || newText.isBogus()) {
  return *this;
}

pinIndices(start, length);
oldText.pinIndices(oldStart, oldLength);
newText.pinIndices(newStart, newLength);

if(oldLength == 0) {
  return *this;
}

while(length > 0 && length >= oldLength) {
  int32_t pos = indexOf(oldText, oldStart, oldLength, start, length);
  if(pos < 0) {
    // no more oldText's here: done
    break;
  } else {
    // we found oldText, replace it by newText and go beyond it
    replace(pos, oldLength, newText, newStart, newLength);
    length -= pos + oldLength - start;
    start = pos + newLength;
  }
}

return *this;
1197}


1200void
1201UnicodeString::setToBogus()
1202{
releaseArray();

fUnion.fFields.fLengthAndFlags = kIsBogus;
fUnion.fFields.fArray = 0;
fUnion.fFields.fCapacity = 0;
1208}

1210// turn a bogus string into an empty one
1211void
1212UnicodeString::unBogus() {
if(fUnion.fFields.fLengthAndFlags & kIsBogus) {
  setToEmpty();
}
1216}

1218const char16_t *
1219UnicodeString::getTerminatedBuffer() {
if(!isWritable()) {
  return nullptr;
}
UChar *array = getArrayStart();
int32_t len = length();
if(len < getCapacity()) {
  if(fUnion.fFields.fLengthAndFlags & kBufferIsReadonly) {
    // If len<capacity on a read-only alias, then array[len] is
    // either the original NUL (if constructed with (TRUE, s, length))
    // or one of the original string contents characters (if later truncated),
    // therefore we can assume that array[len] is initialized memory.
    if(array[len] == 0) {
      return array;
    }
  } else if(((fUnion.fFields.fLengthAndFlags & kRefCounted) == 0 || refCount() == 1)) {
    // kRefCounted: Do not write the NUL if the buffer is shared.
    // That is mostly safe, except when the length of one copy was modified
    // without copy-on-write, e.g., via truncate(newLength) or remove(void).
    // Then the NUL would be written into the middle of another copy's string.

    // Otherwise, the buffer is fully writable and it is anyway safe to write the NUL.
    // Do not test if there is a NUL already because it might be uninitialized memory.
    // (That would be safe, but tools like valgrind & Purify would complain.)
    array[len] = 0;
    return array;
  }
}
if(len<INT32_MAX(2147483647) && cloneArrayIfNeeded(len+1)) {
  array = getArrayStart();
  array[len] = 0;
  return array;
} else {
  return nullptr;
}
1254}

1256// setTo() analogous to the readonly-aliasing constructor with the same signature
1257UnicodeString &
1258UnicodeString::setTo(UBool isTerminated,
                   ConstChar16Ptr textPtr,
                   int32_t textLength)
1261{
if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {
  // do not modify a string that has an "open" getBuffer(minCapacity)
  return *this;
}

const UChar *text = textPtr;
if(text == NULL__null) {
  // treat as an empty string, do not alias
  releaseArray();
  setToEmpty();
  return *this;
}

if( textLength < -1 ||
    (textLength == -1 && !isTerminated) ||
    (textLength >= 0 && isTerminated && text[textLength] != 0)
) {
  setToBogus();
  return *this;
}

releaseArray();

if(textLength == -1) {
  // text is terminated, or else it would have failed the above test
  textLength = u_strlenu_strlen_71(text);
}
fUnion.fFields.fLengthAndFlags = kReadonlyAlias;
setArray((UChar *)text, textLength, isTerminated ? textLength + 1 : textLength);
return *this;
1292}

1294// setTo() analogous to the writable-aliasing constructor with the same signature
1295UnicodeString &
1296UnicodeString::setTo(UChar *buffer,
                   int32_t buffLength,
                   int32_t buffCapacity) {
if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {
  // do not modify a string that has an "open" getBuffer(minCapacity)
  return *this;
}

if(buffer == NULL__null) {
  // treat as an empty string, do not alias
  releaseArray();
  setToEmpty();
  return *this;
}

if(buffLength < -1 || buffCapacity < 0 || buffLength > buffCapacity) {
  setToBogus();
  return *this;
} else if(buffLength == -1) {
  // buffLength = u_strlen(buff); but do not look beyond buffCapacity
  const UChar *p = buffer, *limit = buffer + buffCapacity;
  while(p != limit && *p != 0) {
    ++p;
  }
  buffLength = (int32_t)(p - buffer);
}

releaseArray();

fUnion.fFields.fLengthAndFlags = kWritableAlias;
setArray(buffer, buffLength, buffCapacity);
return *this;
1328}

1330UnicodeString &UnicodeString::setToUTF8(StringPiece utf8) {
unBogus();
int32_t length = utf8.length();
int32_t capacity;
// The UTF-16 string will be at most as long as the UTF-8 string.
if(length <= US_STACKBUF_SIZE) {
  capacity = US_STACKBUF_SIZE;
} else {
  capacity = length + 1;  // +1 for the terminating NUL.
}
UChar *utf16 = getBuffer(capacity);
int32_t length16;
UErrorCode errorCode = U_ZERO_ERROR;
u_strFromUTF8WithSubu_strFromUTF8WithSub_71(utf16, getCapacity(), &length16,
    utf8.data(), length,
    0xfffd,  // Substitution character.
    NULL__null,    // Don't care about number of substitutions.
    &errorCode);
releaseBuffer(length16);
if(U_FAILURE(errorCode)) {
  setToBogus();
}
return *this;
1353}

1355UnicodeString&
1356UnicodeString::setCharAt(int32_t offset,
           UChar c)
1358{
int32_t len = length();
if(cloneArrayIfNeeded() && len > 0) {
  if(offset < 0) {
    offset = 0;
  } else if(offset >= len) {
    offset = len - 1;
  }

  getArrayStart()[offset] = c;
}
return *this;
1370}

1372UnicodeString&
1373UnicodeString::replace(int32_t start,
             int32_t _length,
             UChar32 srcChar) {
UChar buffer[U16_MAX_LENGTH2];
int32_t count = 0;
UBool isError = FALSE0;
U16_APPEND(buffer, count, U16_MAX_LENGTH, srcChar, isError)do { if((uint32_t)(srcChar)<=0xffff) { (buffer)[(count)++]
=(uint16_t)(srcChar); } else if((uint32_t)(srcChar)<=0x10ffff
 && (count)+1<(2)) { (buffer)[(count)++]=(uint16_t
)(((srcChar)>>10)+0xd7c0); (buffer)[(count)++]=(uint16_t
)(((srcChar)&0x3ff)|0xdc00); } else { (isError)=true; } }
 while (false);
// We test isError so that the compiler does not complain that we don't.
// If isError (srcChar is not a valid code point) then count==0 which means
// we remove the source segment rather than replacing it with srcChar.
return doReplace(start, _length, buffer, 0, isError ? 0 : count);
1384}

1386UnicodeString&
1387UnicodeString::append(UChar32 srcChar) {
UChar buffer[U16_MAX_LENGTH2];
int32_t _length = 0;
UBool isError = FALSE0;
U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError)do { if((uint32_t)(srcChar)<=0xffff) { (buffer)[(_length)++
]=(uint16_t)(srcChar); } else if((uint32_t)(srcChar)<=0x10ffff
 && (_length)+1<(2)) { (buffer)[(_length)++]=(uint16_t
)(((srcChar)>>10)+0xd7c0); (buffer)[(_length)++]=(uint16_t
)(((srcChar)&0x3ff)|0xdc00); } else { (isError)=true; } }
 while (false);
// We test isError so that the compiler does not complain that we don't.
// If isError then _length==0 which turns the doAppend() into a no-op anyway.
return isError ? *this : doAppend(buffer, 0, _length);
1395}

1397UnicodeString&
1398UnicodeString::doReplace( int32_t start,
            int32_t length,
            const UnicodeString& src,
            int32_t srcStart,
            int32_t srcLength)
1403{
// pin the indices to legal values
src.pinIndices(srcStart, srcLength);

// get the characters from src
// and replace the range in ourselves with them
return doReplace(start, length, src.getArrayStart(), srcStart, srcLength);
1410}

1412UnicodeString&
1413UnicodeString::doReplace(int32_t start,
           int32_t length,
           const UChar *srcChars,
           int32_t srcStart,
           int32_t srcLength)
1418{
if(!isWritable()) {
  return *this;
}

int32_t oldLength = this->length();

// optimize (read-only alias).remove(0, start) and .remove(start, end)
if((fUnion.fFields.fLengthAndFlags&kBufferIsReadonly) && srcLength == 0) {
  if(start == 0) {
    // remove prefix by adjusting the array pointer
    pinIndex(length);
    fUnion.fFields.fArray += length;
    fUnion.fFields.fCapacity -= length;
    setLength(oldLength - length);
    return *this;
  } else {
    pinIndex(start);
    if(length >= (oldLength - start)) {
      // remove suffix by reducing the length (like truncate())
      setLength(start);
      fUnion.fFields.fCapacity = start;  // not NUL-terminated any more
      return *this;
    }
  }
}

if(start == oldLength) {
  return doAppend(srcChars, srcStart, srcLength);
}

if(srcChars == 0) {
  srcLength = 0;
} else {
  // Perform all remaining operations relative to srcChars + srcStart.
  // From this point forward, do not use srcStart.
  srcChars += srcStart;
  if (srcLength < 0) {
    // get the srcLength if necessary
    srcLength = u_strlenu_strlen_71(srcChars);
  }
}

// pin the indices to legal values
pinIndices(start, length);

// Calculate the size of the string after the replace.
// Avoid int32_t overflow.
int32_t newLength = oldLength - length;
if(srcLength > (INT32_MAX(2147483647) - newLength)) {
  setToBogus();
  return *this;
}
newLength += srcLength;

// Check for insertion into ourself
const UChar *oldArray = getArrayStart();
if (isBufferWritable() &&
    oldArray < srcChars + srcLength &&
    srcChars < oldArray + oldLength) {
  // Copy into a new UnicodeString and start over
  UnicodeString copy(srcChars, srcLength);
  if (copy.isBogus()) {
    setToBogus();
    return *this;
  }
  return doReplace(start, length, copy.getArrayStart(), 0, srcLength);
}

// cloneArrayIfNeeded(doCopyArray=FALSE) may change fArray but will not copy the current contents;
// therefore we need to keep the current fArray
UChar oldStackBuffer[US_STACKBUF_SIZE];
if((fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) && (newLength > US_STACKBUF_SIZE)) {
  // copy the stack buffer contents because it will be overwritten with
  // fUnion.fFields values
  u_memcpyu_memcpy_71(oldStackBuffer, oldArray, oldLength);
  oldArray = oldStackBuffer;
}

// clone our array and allocate a bigger array if needed
int32_t *bufferToDelete = 0;
if(!cloneArrayIfNeeded(newLength, getGrowCapacity(newLength),
                       FALSE0, &bufferToDelete)
) {
  return *this;
}

// now do the replace

UChar *newArray = getArrayStart();
if(newArray != oldArray) {
  // if fArray changed, then we need to copy everything except what will change
  us_arrayCopy(oldArray, 0, newArray, 0, start);
  us_arrayCopy(oldArray, start + length,
               newArray, start + srcLength,
               oldLength - (start + length));
} else if(length != srcLength) {
  // fArray did not change; copy only the portion that isn't changing, leaving a hole
  us_arrayCopy(oldArray, start + length,
               newArray, start + srcLength,
               oldLength - (start + length));
}

// now fill in the hole with the new string
us_arrayCopy(srcChars, 0, newArray, start, srcLength);

setLength(newLength);

// delayed delete in case srcChars == fArray when we started, and
// to keep oldArray alive for the above operations
if (bufferToDelete) {
  uprv_freeuprv_free_71(bufferToDelete);
}

return *this;
1533}

1535// Versions of doReplace() only for append() variants.
1536// doReplace() and doAppend() optimize for different cases.

1538UnicodeString&
1539UnicodeString::doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcLength) {
if(srcLength == 0) {
  return *this;
}

// pin the indices to legal values
src.pinIndices(srcStart, srcLength);
return doAppend(src.getArrayStart(), srcStart, srcLength);
1547}

1549UnicodeString&
1550UnicodeString::doAppend(const UChar *srcChars, int32_t srcStart, int32_t srcLength) {
if(!isWritable() || srcLength == 0 || srcChars == NULL__null) {
2
←
Assuming 'srcLength' is not equal to 0→
3
←
Assuming 'srcChars' is not equal to NULL→
4
←
Taking false branch→
  return *this;
}

// Perform all remaining operations relative to srcChars + srcStart.
// From this point forward, do not use srcStart.
srcChars += srcStart;

if(srcLength < 0) {
5
←
Assuming 'srcLength' is >= 0→
6
←
Taking false branch→
  // get the srcLength if necessary
  if((srcLength = u_strlenu_strlen_71(srcChars)) == 0) {
    return *this;
  }
}

int32_t oldLength = length();
int32_t newLength;
if (uprv_add32_overflowuprv_add32_overflow_71(oldLength, srcLength, &newLength)) {
7
←
Value assigned to 'newLength'→
8
←
Assuming the condition is false→
9
←
Taking false branch→
  setToBogus();
  return *this;
}

// Check for append onto ourself
const UChar* oldArray = getArrayStart();
if (isBufferWritable() &&
    oldArray < srcChars + srcLength &&
    srcChars < oldArray + oldLength) {
  // Copy into a new UnicodeString and start over
  UnicodeString copy(srcChars, srcLength);
  if (copy.isBogus()) {
    setToBogus();
    return *this;
  }
  return doAppend(copy.getArrayStart(), 0, srcLength);
}

// optimize append() onto a large-enough, owned string
if((newLength <= getCapacity() && isBufferWritable()) ||
10
←
Assuming the condition is false→
11
←
Taking true branch→
    cloneArrayIfNeeded(newLength, getGrowCapacity(newLength))) {
  UChar *newArray = getArrayStart();
  // Do not copy characters when
  //   UChar *buffer=str.getAppendBuffer(...);
  // is followed by
  //   str.append(buffer, length);
  // or
  //   str.appendString(buffer, length)
  // or similar.
  if(srcChars != newArray + oldLength) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
    us_arrayCopy(srcChars, 0, newArray, oldLength, srcLength);
  }
  setLength(newLength);
14
←
Passing the value -1 via 1st parameter 'len'→
15
←
Calling 'UnicodeString::setLength'→
}
return *this;
1604}

1606/**
* Replaceable API
*/
1609void
1610UnicodeString::handleReplaceBetween(int32_t start,
                                  int32_t limit,
                                  const UnicodeString& text) {
  replaceBetween(start, limit, text);
1614}

1616/**
* Replaceable API
*/
1619void 
1620UnicodeString::copy(int32_t start, int32_t limit, int32_t dest) {
  if (limit <= start) {
      return; // Nothing to do; avoid bogus malloc call
  }
  UChar* text = (UChar*) uprv_mallocuprv_malloc_71( sizeof(UChar) * (limit - start) );
  // Check to make sure text is not null.
  if (text != NULL__null) {
   extractBetween(start, limit, text, 0);
   insert(dest, text, 0, limit - start);    
   uprv_freeuprv_free_71(text);
  }
1631}

1633/**
* Replaceable API
*
* NOTE: This is for the Replaceable class.  There is no rep.cpp,
* so we implement this function here.
*/
1639UBool Replaceable::hasMetaData() const {
  return TRUE1;
1641}

1643/**
* Replaceable API
*/
1646UBool UnicodeString::hasMetaData() const {
  return FALSE0;
1648}

1650UnicodeString&
1651UnicodeString::doReverse(int32_t start, int32_t length) {
if(length <= 1 || !cloneArrayIfNeeded()) {
  return *this;
}

// pin the indices to legal values
pinIndices(start, length);
if(length <= 1) {  // pinIndices() might have shrunk the length
  return *this;
}

UChar *left = getArrayStart() + start;
UChar *right = left + length - 1;  // -1 for inclusive boundary (length>=2)
UChar swap;
UBool hasSupplementary = FALSE0;

// Before the loop we know left<right because length>=2.
do {
  hasSupplementary |= (UBool)U16_IS_LEAD(swap = *left)(((swap = *left)&0xfffffc00)==0xd800);
  hasSupplementary |= (UBool)U16_IS_LEAD(*left++ = *right)(((*left++ = *right)&0xfffffc00)==0xd800);
  *right-- = swap;
} while(left < right);
// Make sure to test the middle code unit of an odd-length string.
// Redundant if the length is even.
hasSupplementary |= (UBool)U16_IS_LEAD(*left)(((*left)&0xfffffc00)==0xd800);

/* if there are supplementary code points in the reversed range, then re-swap their surrogates */
if(hasSupplementary) {
  UChar swap2;

  left = getArrayStart() + start;
  right = left + length - 1; // -1 so that we can look at *(left+1) if left<right
  while(left < right) {
    if(U16_IS_TRAIL(swap = *left)(((swap = *left)&0xfffffc00)==0xdc00) && U16_IS_LEAD(swap2 = *(left + 1))(((swap2 = *(left + 1))&0xfffffc00)==0xd800)) {
      *left++ = swap2;
      *left++ = swap;
    } else {
      ++left;
    }
  }
}

return *this;
1694}

1696UBool 
1697UnicodeString::padLeading(int32_t targetLength,
                        UChar padChar)
1699{
int32_t oldLength = length();
if(oldLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
  return FALSE0;
} else {
  // move contents up by padding width
  UChar *array = getArrayStart();
  int32_t start = targetLength - oldLength;
  us_arrayCopy(array, 0, array, start, oldLength);

  // fill in padding character
  while(--start >= 0) {
    array[start] = padChar;
  }
  setLength(targetLength);
  return TRUE1;
}
1716}

1718UBool 
1719UnicodeString::padTrailing(int32_t targetLength,
                         UChar padChar)
1721{
int32_t oldLength = length();
if(oldLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
  return FALSE0;
} else {
  // fill in padding character
  UChar *array = getArrayStart();
  int32_t length = targetLength;
  while(--length >= oldLength) {
    array[length] = padChar;
  }
  setLength(targetLength);
  return TRUE1;
}
1735}

1737//========================================
1738// Hashing
1739//========================================
1740int32_t
1741UnicodeString::doHashCode() const
1742{
  /* Delegate hash computation to uhash.  This makes UnicodeString
   * hashing consistent with UChar* hashing.  */
  int32_t hashCode = ustr_hashUCharsNustr_hashUCharsN_71(getArrayStart(), length());
  if (hashCode == kInvalidHashCode) {
      hashCode = kEmptyHashCode;
  }
  return hashCode;
1750}

1752//========================================
1753// External Buffer
1754//========================================

1756char16_t *
1757UnicodeString::getBuffer(int32_t minCapacity) {
if(minCapacity>=-1 && cloneArrayIfNeeded(minCapacity)) {
  fUnion.fFields.fLengthAndFlags|=kOpenGetBuffer;
  setZeroLength();
  return getArrayStart();
} else {
  return nullptr;
}
1765}

1767void
1768UnicodeString::releaseBuffer(int32_t newLength) {
if(fUnion.fFields.fLengthAndFlags&kOpenGetBuffer && newLength>=-1) {
  // set the new fLength
  int32_t capacity=getCapacity();
  if(newLength==-1) {
    // the new length is the string length, capped by fCapacity
    const UChar *array=getArrayStart(), *p=array, *limit=array+capacity;
    while(p<limit && *p!=0) {
      ++p;
    }
    newLength=(int32_t)(p-array);
  } else if(newLength>capacity) {
    newLength=capacity;
  }
  setLength(newLength);
  fUnion.fFields.fLengthAndFlags&=~kOpenGetBuffer;
}
1785}

1787//========================================
1788// Miscellaneous
1789//========================================
1790UBool
1791UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
                                int32_t growCapacity,
                                UBool doCopyArray,
                                int32_t **pBufferToDelete,
                                UBool forceClone) {
// default parameters need to be static, therefore
// the defaults are -1 to have convenience defaults
if(newCapacity == -1) {
  newCapacity = getCapacity();
}

// while a getBuffer(minCapacity) is "open",
// prevent any modifications of the string by returning FALSE here
// if the string is bogus, then only an assignment or similar can revive it
if(!isWritable()) {
  return FALSE0;
}

/*
 * We need to make a copy of the array if
 * the buffer is read-only, or
 * the buffer is refCounted (shared), and refCount>1, or
 * the buffer is too small.
 * Return FALSE if memory could not be allocated.
 */
if(forceClone ||
   fUnion.fFields.fLengthAndFlags & kBufferIsReadonly ||
   (fUnion.fFields.fLengthAndFlags & kRefCounted && refCount() > 1) ||
   newCapacity > getCapacity()
) {
  // check growCapacity for default value and use of the stack buffer
  if(growCapacity < 0) {
    growCapacity = newCapacity;
  } else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) {
    growCapacity = US_STACKBUF_SIZE;
  }

  // save old values
  UChar oldStackBuffer[US_STACKBUF_SIZE];
  UChar *oldArray;
  int32_t oldLength = length();
  int16_t flags = fUnion.fFields.fLengthAndFlags;

  if(flags&kUsingStackBuffer) {
    U_ASSERT(!(flags&kRefCounted))(void)0; /* kRefCounted and kUsingStackBuffer are mutally exclusive */
    if(doCopyArray && growCapacity > US_STACKBUF_SIZE) {
      // copy the stack buffer contents because it will be overwritten with
      // fUnion.fFields values
      us_arrayCopy(fUnion.fStackFields.fBuffer, 0, oldStackBuffer, 0, oldLength);
      oldArray = oldStackBuffer;
    } else {
      oldArray = NULL__null; // no need to copy from the stack buffer to itself
    }
  } else {
    oldArray = fUnion.fFields.fArray;
    U_ASSERT(oldArray!=NULL)(void)0; /* when stack buffer is not used, oldArray must have a non-NULL reference */
  }

  // allocate a new array
  if(allocate(growCapacity) ||
     (newCapacity < growCapacity && allocate(newCapacity))
  ) {
    if(doCopyArray) {
      // copy the contents
      // do not copy more than what fits - it may be smaller than before
      int32_t minLength = oldLength;
      newCapacity = getCapacity();
      if(newCapacity < minLength) {
        minLength = newCapacity;
      }
      if(oldArray != NULL__null) {
        us_arrayCopy(oldArray, 0, getArrayStart(), 0, minLength);
      }
      setLength(minLength);
    } else {
      setZeroLength();
    }

    // release the old array
    if(flags & kRefCounted) {
      // the array is refCounted; decrement and release if 0
      u_atomic_int32_t *pRefCount = ((u_atomic_int32_t *)oldArray - 1);
      if(umtx_atomic_dec(pRefCount) == 0) {
        if(pBufferToDelete == 0) {
            // Note: cast to (void *) is needed with MSVC, where u_atomic_int32_t
            // is defined as volatile. (Volatile has useful non-standard behavior
            //   with this compiler.)
          uprv_freeuprv_free_71((void *)pRefCount);
        } else {
          // the caller requested to delete it himself
          *pBufferToDelete = (int32_t *)pRefCount;
        }
      }
    }
  } else {
    // not enough memory for growCapacity and not even for the smaller newCapacity
    // reset the old values for setToBogus() to release the array
    if(!(flags&kUsingStackBuffer)) {
      fUnion.fFields.fArray = oldArray;
    }
    fUnion.fFields.fLengthAndFlags = flags;
    setToBogus();
    return FALSE0;
  }
}
return TRUE1;
1897}

1899// UnicodeStringAppendable ------------------------------------------------- ***

1901UnicodeStringAppendable::~UnicodeStringAppendable() {}

1903UBool
1904UnicodeStringAppendable::appendCodeUnit(UChar c) {
return str.doAppend(&c, 0, 1).isWritable();
1906}

1908UBool
1909UnicodeStringAppendable::appendCodePoint(UChar32 c) {
UChar buffer[U16_MAX_LENGTH2];
int32_t cLength = 0;
UBool isError = FALSE0;
U16_APPEND(buffer, cLength, U16_MAX_LENGTH, c, isError)do { if((uint32_t)(c)<=0xffff) { (buffer)[(cLength)++]=(uint16_t
)(c); } else if((uint32_t)(c)<=0x10ffff && (cLength
)+1<(2)) { (buffer)[(cLength)++]=(uint16_t)(((c)>>10
)+0xd7c0); (buffer)[(cLength)++]=(uint16_t)(((c)&0x3ff)|0xdc00
); } else { (isError)=true; } } while (false);
return !isError && str.doAppend(buffer, 0, cLength).isWritable();
1915}

1917UBool
1918UnicodeStringAppendable::appendString(const UChar *s, int32_t length) {
return str.doAppend(s, 0, length).isWritable();
1
Calling 'UnicodeString::doAppend'→
1920}

1922UBool
1923UnicodeStringAppendable::reserveAppendCapacity(int32_t appendCapacity) {
return str.cloneArrayIfNeeded(str.length() + appendCapacity);
1925}

1927UChar *
1928UnicodeStringAppendable::getAppendBuffer(int32_t minCapacity,
                                       int32_t desiredCapacityHint,
                                       UChar *scratch, int32_t scratchCapacity,
                                       int32_t *resultCapacity) {
if(minCapacity < 1 || scratchCapacity < minCapacity) {
  *resultCapacity = 0;
  return NULL__null;
}
int32_t oldLength = str.length();
if(minCapacity <= (kMaxCapacity - oldLength) &&
    desiredCapacityHint <= (kMaxCapacity - oldLength) &&
    str.cloneArrayIfNeeded(oldLength + minCapacity, oldLength + desiredCapacityHint)) {
  *resultCapacity = str.getCapacity() - oldLength;
  return str.getArrayStart() + oldLength;
}
*resultCapacity = scratchCapacity;
return scratch;
1945}

1947U_NAMESPACE_END}

1949U_NAMESPACE_USEusing namespace icu_71;

1951U_CAPIextern "C" int32_t U_EXPORT2
1952uhash_hashUnicodeStringuhash_hashUnicodeString_71(const UElement key) {
  const UnicodeString *str = (const UnicodeString*) key.pointer;
  return (str == NULL__null) ? 0 : str->hashCode();
1955}

1957// Moved here from uhash_us.cpp so that using a UVector of UnicodeString*
1958// does not depend on hashtable code.
1959U_CAPIextern "C" UBool U_EXPORT2
1960uhash_compareUnicodeStringuhash_compareUnicodeString_71(const UElement key1, const UElement key2) {
  const UnicodeString *str1 = (const UnicodeString*) key1.pointer;
  const UnicodeString *str2 = (const UnicodeString*) key2.pointer;
  if (str1 == str2) {
      return TRUE1;
  }
  if (str1 == NULL__null || str2 == NULL__null) {
      return FALSE0;
  }
  return *str1 == *str2;
1970}

1972#ifdef U_STATIC_IMPLEMENTATION1
1973/*
1974This should never be called. It is defined here to make sure that the
1975virtual vector deleting destructor is defined within unistr.cpp.
1976The vector deleting destructor is already a part of UObject,
1977but defining it here makes sure that it is included with this object file.
1978This makes sure that static library dependencies are kept to a minimum.
1979*/
1980#if defined(__clang__1) || U_GCC_MAJOR_MINOR(4 * 100 + 2) >= 1100
1981#pragma GCC diagnostic push
1982#pragma GCC diagnostic ignored "-Wunused-function"
1983static void uprv_UnicodeStringDummy(void) {
  delete [] (new UnicodeString[2]);
1985}
1986#pragma GCC diagnostic pop
1987#endif
1988#endif

←

../deps/icu-small/source/common/unicode/unistr.h

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*/

23#ifndef UNISTR_H
24#define UNISTR_H

26/**
* \file
* \brief C++ API: Unicode String
*/

31#include "unicode/utypes.h"

33#if U_SHOW_CPLUSPLUS_API1

35#include <cstddef>
36#include "unicode/char16ptr.h"
37#include "unicode/rep.h"
38#include "unicode/std_string.h"
39#include "unicode/stringpiece.h"
40#include "unicode/bytestream.h"

42struct UConverter;          // unicode/ucnv.h

44#ifndef USTRING_H
45/**
* \ingroup ustring_ustrlen
* @param s Pointer to sequence of UChars.
* @return Length of sequence.
*/
50U_CAPIextern "C" int32_t U_EXPORT2 u_strlenu_strlen_71(const UChar *s);
51#endif

53U_NAMESPACE_BEGINnamespace icu_71 {

55#if !UCONFIG_NO_BREAK_ITERATION0
56class BreakIterator;        // unicode/brkiter.h
57#endif
58class Edits;

60U_NAMESPACE_END}

62// Not #ifndef U_HIDE_INTERNAL_API because UnicodeString needs the UStringCaseMapper.
63/**
* Internal string case mapping function type.
* All error checking must be done.
* src and dest must not overlap.
* @internal
*/
69typedef int32_t U_CALLCONV
70UStringCaseMapper(int32_t caseLocale, uint32_t options,
71#if !UCONFIG_NO_BREAK_ITERATION0
                icu::BreakIterator *iter,
73#endif
                char16_t *dest, int32_t destCapacity,
                const char16_t *src, int32_t srcLength,
                icu::Edits *edits,
                UErrorCode &errorCode);

79U_NAMESPACE_BEGINnamespace icu_71 {

81class Locale;               // unicode/locid.h
82class StringCharacterIterator;
83class UnicodeStringAppendable;  // unicode/appendable.h

85/* The <iostream> include has been moved to unicode/ustream.h */

87/**
* Constant to be used in the UnicodeString(char *, int32_t, EInvariant) constructor
* which constructs a Unicode string from an invariant-character char * string.
* About invariant characters see utypes.h.
* This constructor has no runtime dependency on conversion code and is
* therefore recommended over ones taking a charset name string
* (where the empty string "" indicates invariant-character conversion).
*
* @stable ICU 3.2
*/
97#define US_INVicu::UnicodeString::kInvariant icu::UnicodeString::kInvariant

99/**
* Unicode String literals in C++.
*
* Note: these macros are not recommended for new code.
* Prior to the availability of C++11 and u"unicode string literals",
* these macros were provided for portability and efficiency when
* initializing UnicodeStrings from literals.
*
* They work only for strings that contain "invariant characters", i.e.,
* only latin letters, digits, and some punctuation.
* See utypes.h for details.
*
* The string parameter must be a C string literal.
* The length of the string, not including the terminating
* `NUL`, must be specified as a constant.
* @stable ICU 2.0
*/
116#if !U_CHAR16_IS_TYPEDEF0
117# define UNICODE_STRING(cs, _length)icu::UnicodeString(true, ucs, _length) icu::UnicodeString(true, u ## cs, _length)
118#else
119# define UNICODE_STRING(cs, _length)icu::UnicodeString(true, ucs, _length) icu::UnicodeString(true, (const char16_t*)u ## cs, _length)
120#endif

122/**
* Unicode String literals in C++.
* Dependent on the platform properties, different UnicodeString
* constructors should be used to create a UnicodeString object from
* a string literal.
* The macros are defined for improved performance.
* They work only for strings that contain "invariant characters", i.e.,
* only latin letters, digits, and some punctuation.
* See utypes.h for details.
*
* The string parameter must be a C string literal.
* @stable ICU 2.0
*/
135#define UNICODE_STRING_SIMPLE(cs)icu::UnicodeString(true, ucs, -1) UNICODE_STRING(cs, -1)icu::UnicodeString(true, ucs, -1)

137/**
* \def UNISTR_FROM_CHAR_EXPLICIT
* This can be defined to be empty or "explicit".
* If explicit, then the UnicodeString(char16_t) and UnicodeString(UChar32)
* constructors are marked as explicit, preventing their inadvertent use.
* @stable ICU 49
*/
144#ifndef UNISTR_FROM_CHAR_EXPLICITexplicit
145# if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION1) || defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION)
  // Auto-"explicit" in ICU library code.
147#   define UNISTR_FROM_CHAR_EXPLICITexplicit explicit
148# else
  // Empty by default for source code compatibility.
150#   define UNISTR_FROM_CHAR_EXPLICITexplicit
151# endif
152#endif

154/**
* \def UNISTR_FROM_STRING_EXPLICIT
* This can be defined to be empty or "explicit".
* If explicit, then the UnicodeString(const char *) and UnicodeString(const char16_t *)
* constructors are marked as explicit, preventing their inadvertent use.
*
* In particular, this helps prevent accidentally depending on ICU conversion code
* by passing a string literal into an API with a const UnicodeString & parameter.
* @stable ICU 49
*/
164#ifndef UNISTR_FROM_STRING_EXPLICITexplicit
165# if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION1) || defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION)
  // Auto-"explicit" in ICU library code.
167#   define UNISTR_FROM_STRING_EXPLICITexplicit explicit
168# else
  // Empty by default for source code compatibility.
170#   define UNISTR_FROM_STRING_EXPLICITexplicit
171# endif
172#endif

174/**
* \def UNISTR_OBJECT_SIZE
* Desired sizeof(UnicodeString) in bytes.
* It should be a multiple of sizeof(pointer) to avoid unusable space for padding.
* The object size may want to be a multiple of 16 bytes,
* which is a common granularity for heap allocation.
*
* Any space inside the object beyond sizeof(vtable pointer) + 2
* is available for storing short strings inside the object.
* The bigger the object, the longer a string that can be stored inside the object,
* without additional heap allocation.
*
* Depending on a platform's pointer size, pointer alignment requirements,
* and struct padding, the compiler will usually round up sizeof(UnicodeString)
* to 4 * sizeof(pointer) (or 3 * sizeof(pointer) for P128 data models),
* to hold the fields for heap-allocated strings.
* Such a minimum size also ensures that the object is easily large enough
* to hold at least 2 char16_ts, for one supplementary code point (U16_MAX_LENGTH).
*
* sizeof(UnicodeString) >= 48 should work for all known platforms.
*
* For example, on a 64-bit machine where sizeof(vtable pointer) is 8,
* sizeof(UnicodeString) = 64 would leave space for
* (64 - sizeof(vtable pointer) - 2) / U_SIZEOF_UCHAR = (64 - 8 - 2) / 2 = 27
* char16_ts stored inside the object.
*
* The minimum object size on a 64-bit machine would be
* 4 * sizeof(pointer) = 4 * 8 = 32 bytes,
* and the internal buffer would hold up to 11 char16_ts in that case.
*
* @see U16_MAX_LENGTH
* @stable ICU 56
*/
207#ifndef UNISTR_OBJECT_SIZE64
208# define UNISTR_OBJECT_SIZE64 64
209#endif

211/**
* UnicodeString is a string class that stores Unicode characters directly and provides
* similar functionality as the Java String and StringBuffer/StringBuilder classes.
* It is a concrete implementation of the abstract class Replaceable (for transliteration).
*
* The UnicodeString equivalent of std::string’s clear() is remove().
*
* A UnicodeString may "alias" an external array of characters
* (that is, point to it, rather than own the array)
* whose lifetime must then at least match the lifetime of the aliasing object.
* This aliasing may be preserved when returning a UnicodeString by value,
* depending on the compiler and the function implementation,
* via Return Value Optimization (RVO) or the move assignment operator.
* (However, the copy assignment operator does not preserve aliasing.)
* For details see the description of storage models at the end of the class API docs
* and in the User Guide chapter linked from there.
*
* The UnicodeString class is not suitable for subclassing.
*
* For an overview of Unicode strings in C and C++ see the
* [User Guide Strings chapter](https://unicode-org.github.io/icu/userguide/strings#strings-in-cc).
*
* In ICU, a Unicode string consists of 16-bit Unicode *code units*.
* A Unicode character may be stored with either one code unit
* (the most common case) or with a matched pair of special code units
* ("surrogates"). The data type for code units is char16_t.
* For single-character handling, a Unicode character code *point* is a value
* in the range 0..0x10ffff. ICU uses the UChar32 type for code points.
*
* Indexes and offsets into and lengths of strings always count code units, not code points.
* This is the same as with multi-byte char* strings in traditional string handling.
* Operations on partial strings typically do not test for code point boundaries.
* If necessary, the user needs to take care of such boundaries by testing for the code unit
* values or by using functions like
* UnicodeString::getChar32Start() and UnicodeString::getChar32Limit()
* (or, in C, the equivalent macros U16_SET_CP_START() and U16_SET_CP_LIMIT(), see utf.h).
*
* UnicodeString methods are more lenient with regard to input parameter values
* than other ICU APIs. In particular:
* - If indexes are out of bounds for a UnicodeString object
*   (< 0 or > length()) then they are "pinned" to the nearest boundary.
* - If the buffer passed to an insert/append/replace operation is owned by the
*   target object, e.g., calling str.append(str), an extra copy may take place
*   to ensure safety.
* - If primitive string pointer values (e.g., const char16_t * or char *)
*   for input strings are NULL, then those input string parameters are treated
*   as if they pointed to an empty string.
*   However, this is *not* the case for char * parameters for charset names
*   or other IDs.
* - Most UnicodeString methods do not take a UErrorCode parameter because
*   there are usually very few opportunities for failure other than a shortage
*   of memory, error codes in low-level C++ string methods would be inconvenient,
*   and the error code as the last parameter (ICU convention) would prevent
*   the use of default parameter values.
*   Instead, such methods set the UnicodeString into a "bogus" state
*   (see isBogus()) if an error occurs.
*
* In string comparisons, two UnicodeString objects that are both "bogus"
* compare equal (to be transitive and prevent endless loops in sorting),
* and a "bogus" string compares less than any non-"bogus" one.
*
* Const UnicodeString methods are thread-safe. Multiple threads can use
* const methods on the same UnicodeString object simultaneously,
* but non-const methods must not be called concurrently (in multiple threads)
* with any other (const or non-const) methods.
*
* Similarly, const UnicodeString & parameters are thread-safe.
* One object may be passed in as such a parameter concurrently in multiple threads.
* This includes the const UnicodeString & parameters for
* copy construction, assignment, and cloning.
*
* UnicodeString uses several storage methods.
* String contents can be stored inside the UnicodeString object itself,
* in an allocated and shared buffer, or in an outside buffer that is "aliased".
* Most of this is done transparently, but careful aliasing in particular provides
* significant performance improvements.
* Also, the internal buffer is accessible via special functions.
* For details see the
* [User Guide Strings chapter](https://unicode-org.github.io/icu/userguide/strings#maximizing-performance-with-the-unicodestring-storage-model).
*
* @see utf.h
* @see CharacterIterator
* @stable ICU 2.0
*/
295class U_COMMON_API UnicodeString : public Replaceable
296{
297public:

/**
 * Constant to be used in the UnicodeString(char *, int32_t, EInvariant) constructor
 * which constructs a Unicode string from an invariant-character char * string.
 * Use the macro US_INV instead of the full qualification for this value.
 *
 * @see US_INV
 * @stable ICU 3.2
 */
enum EInvariant {
  /**
   * @see EInvariant
   * @stable ICU 3.2
   */
  kInvariant
};

//========================================
// Read-only operations
//========================================

/* Comparison - bitwise only - for international comparison use collation */

/**
 * Equality operator. Performs only bitwise comparison.
 * @param text The UnicodeString to compare to this one.
 * @return true if `text` contains the same characters as this one,
 * false otherwise.
 * @stable ICU 2.0
 */
inline bool operator== (const UnicodeString& text) const;

/**
 * Inequality operator. Performs only bitwise comparison.
 * @param text The UnicodeString to compare to this one.
 * @return false if `text` contains the same characters as this one,
 * true otherwise.
 * @stable ICU 2.0
 */
inline bool operator!= (const UnicodeString& text) const;

/**
 * Greater than operator. Performs only bitwise comparison.
 * @param text The UnicodeString to compare to this one.
 * @return true if the characters in this are bitwise
 * greater than the characters in `text`, false otherwise
 * @stable ICU 2.0
 */
inline UBool operator> (const UnicodeString& text) const;

/**
 * Less than operator. Performs only bitwise comparison.
 * @param text The UnicodeString to compare to this one.
 * @return true if the characters in this are bitwise
 * less than the characters in `text`, false otherwise
 * @stable ICU 2.0
 */
inline UBool operator< (const UnicodeString& text) const;

/**
 * Greater than or equal operator. Performs only bitwise comparison.
 * @param text The UnicodeString to compare to this one.
 * @return true if the characters in this are bitwise
 * greater than or equal to the characters in `text`, false otherwise
 * @stable ICU 2.0
 */
inline UBool operator>= (const UnicodeString& text) const;

/**
 * Less than or equal operator. Performs only bitwise comparison.
 * @param text The UnicodeString to compare to this one.
 * @return true if the characters in this are bitwise
 * less than or equal to the characters in `text`, false otherwise
 * @stable ICU 2.0
 */
inline UBool operator<= (const UnicodeString& text) const;

/**
 * Compare the characters bitwise in this UnicodeString to
 * the characters in `text`.
 * @param text The UnicodeString to compare to this one.
 * @return The result of bitwise character comparison: 0 if this
 * contains the same characters as `text`, -1 if the characters in
 * this are bitwise less than the characters in `text`, +1 if the
 * characters in this are bitwise greater than the characters
 * in `text`.
 * @stable ICU 2.0
 */
inline int8_t compare(const UnicodeString& text) const;

/**
 * Compare the characters bitwise in the range
 * [`start`, `start + length`) with the characters
 * in the **entire string** `text`.
 * (The parameters "start" and "length" are not applied to the other text "text".)
 * @param start the offset at which the compare operation begins
 * @param length the number of characters of text to compare.
 * @param text the other text to be compared against this string.
 * @return The result of bitwise character comparison: 0 if this
 * contains the same characters as `text`, -1 if the characters in
 * this are bitwise less than the characters in `text`, +1 if the
 * characters in this are bitwise greater than the characters
 * in `text`.
 * @stable ICU 2.0
 */
inline int8_t compare(int32_t start,
       int32_t length,
       const UnicodeString& text) const;

/**
 * Compare the characters bitwise in the range
 * [`start`, `start + length`) with the characters
 * in `srcText` in the range
 * [`srcStart`, `srcStart + srcLength`).
 * @param start the offset at which the compare operation begins
 * @param length the number of characters in this to compare.
 * @param srcText the text to be compared
 * @param srcStart the offset into `srcText` to start comparison
 * @param srcLength the number of characters in `src` to compare
 * @return The result of bitwise character comparison: 0 if this
 * contains the same characters as `srcText`, -1 if the characters in
 * this are bitwise less than the characters in `srcText`, +1 if the
 * characters in this are bitwise greater than the characters
 * in `srcText`.
 * @stable ICU 2.0
 */
 inline int8_t compare(int32_t start,
       int32_t length,
       const UnicodeString& srcText,
       int32_t srcStart,
       int32_t srcLength) const;

/**
 * Compare the characters bitwise in this UnicodeString with the first
 * `srcLength` characters in `srcChars`.
 * @param srcChars The characters to compare to this UnicodeString.
 * @param srcLength the number of characters in `srcChars` to compare
 * @return The result of bitwise character comparison: 0 if this
 * contains the same characters as `srcChars`, -1 if the characters in
 * this are bitwise less than the characters in `srcChars`, +1 if the
 * characters in this are bitwise greater than the characters
 * in `srcChars`.
 * @stable ICU 2.0
 */
inline int8_t compare(ConstChar16Ptr srcChars,
       int32_t srcLength) const;

/**
 * Compare the characters bitwise in the range
 * [`start`, `start + length`) with the first
 * `length` characters in `srcChars`
 * @param start the offset at which the compare operation begins
 * @param length the number of characters to compare.
 * @param srcChars the characters to be compared
 * @return The result of bitwise character comparison: 0 if this
 * contains the same characters as `srcChars`, -1 if the characters in
 * this are bitwise less than the characters in `srcChars`, +1 if the
 * characters in this are bitwise greater than the characters
 * in `srcChars`.
 * @stable ICU 2.0
 */
inline int8_t compare(int32_t start,
       int32_t length,
       const char16_t *srcChars) const;

/**
 * Compare the characters bitwise in the range
 * [`start`, `start + length`) with the characters
 * in `srcChars` in the range
 * [`srcStart`, `srcStart + srcLength`).
 * @param start the offset at which the compare operation begins
 * @param length the number of characters in this to compare
 * @param srcChars the characters to be compared
 * @param srcStart the offset into `srcChars` to start comparison
 * @param srcLength the number of characters in `srcChars` to compare
 * @return The result of bitwise character comparison: 0 if this
 * contains the same characters as `srcChars`, -1 if the characters in
 * this are bitwise less than the characters in `srcChars`, +1 if the
 * characters in this are bitwise greater than the characters
 * in `srcChars`.
 * @stable ICU 2.0
 */
inline int8_t compare(int32_t start,
       int32_t length,
       const char16_t *srcChars,
       int32_t srcStart,
       int32_t srcLength) const;

/**
 * Compare the characters bitwise in the range
 * [`start`, `limit`) with the characters
 * in `srcText` in the range
 * [`srcStart`, `srcLimit`).
 * @param start the offset at which the compare operation begins
 * @param limit the offset immediately following the compare operation
 * @param srcText the text to be compared
 * @param srcStart the offset into `srcText` to start comparison
 * @param srcLimit the offset into `srcText` to limit comparison
 * @return The result of bitwise character comparison: 0 if this
 * contains the same characters as `srcText`, -1 if the characters in
 * this are bitwise less than the characters in `srcText`, +1 if the
 * characters in this are bitwise greater than the characters
 * in `srcText`.
 * @stable ICU 2.0
 */
inline int8_t compareBetween(int32_t start,
          int32_t limit,
          const UnicodeString& srcText,
          int32_t srcStart,
          int32_t srcLimit) const;

/**
 * Compare two Unicode strings in code point order.
 * The result may be different from the results of compare(), operator<, etc.
 * if supplementary characters are present:
 *
 * In UTF-16, supplementary characters (with code points U+10000 and above) are
 * stored with pairs of surrogate code units. These have values from 0xd800 to 0xdfff,
 * which means that they compare as less than some other BMP characters like U+feff.
 * This function compares Unicode strings in code point order.
 * If either of the UTF-16 strings is malformed (i.e., it contains unpaired surrogates), then the result is not defined.
 *
 * @param text Another string to compare this one to.
 * @return a negative/zero/positive integer corresponding to whether
 * this string is less than/equal to/greater than the second one
 * in code point order
 * @stable ICU 2.0
 */
inline int8_t compareCodePointOrder(const UnicodeString& text) const;

/**
 * Compare two Unicode strings in code point order.
 * The result may be different from the results of compare(), operator<, etc.
 * if supplementary characters are present:
 *
 * In UTF-16, supplementary characters (with code points U+10000 and above) are
 * stored with pairs of surrogate code units. These have values from 0xd800 to 0xdfff,
 * which means that they compare as less than some other BMP characters like U+feff.
 * This function compares Unicode strings in code point order.
 * If either of the UTF-16 strings is malformed (i.e., it contains unpaired surrogates), then the result is not defined.
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcText Another string to compare this one to.
 * @return a negative/zero/positive integer corresponding to whether
 * this string is less than/equal to/greater than the second one
 * in code point order
 * @stable ICU 2.0
 */
inline int8_t compareCodePointOrder(int32_t start,
                                    int32_t length,
                                    const UnicodeString& srcText) const;

/**
 * Compare two Unicode strings in code point order.
 * The result may be different from the results of compare(), operator<, etc.
 * if supplementary characters are present:
 *
 * In UTF-16, supplementary characters (with code points U+10000 and above) are
 * stored with pairs of surrogate code units. These have values from 0xd800 to 0xdfff,
 * which means that they compare as less than some other BMP characters like U+feff.
 * This function compares Unicode strings in code point order.
 * If either of the UTF-16 strings is malformed (i.e., it contains unpaired surrogates), then the result is not defined.
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcText Another string to compare this one to.
 * @param srcStart The start offset in that string at which the compare operation begins.
 * @param srcLength The number of code units from that string to compare.
 * @return a negative/zero/positive integer corresponding to whether
 * this string is less than/equal to/greater than the second one
 * in code point order
 * @stable ICU 2.0
 */
 inline int8_t compareCodePointOrder(int32_t start,
                                     int32_t length,
                                     const UnicodeString& srcText,
                                     int32_t srcStart,
                                     int32_t srcLength) const;

/**
 * Compare two Unicode strings in code point order.
 * The result may be different from the results of compare(), operator<, etc.
 * if supplementary characters are present:
 *
 * In UTF-16, supplementary characters (with code points U+10000 and above) are
 * stored with pairs of surrogate code units. These have values from 0xd800 to 0xdfff,
 * which means that they compare as less than some other BMP characters like U+feff.
 * This function compares Unicode strings in code point order.
 * If either of the UTF-16 strings is malformed (i.e., it contains unpaired surrogates), then the result is not defined.
 *
 * @param srcChars A pointer to another string to compare this one to.
 * @param srcLength The number of code units from that string to compare.
 * @return a negative/zero/positive integer corresponding to whether
 * this string is less than/equal to/greater than the second one
 * in code point order
 * @stable ICU 2.0
 */
inline int8_t compareCodePointOrder(ConstChar16Ptr srcChars,
                                    int32_t srcLength) const;

/**
 * Compare two Unicode strings in code point order.
 * The result may be different from the results of compare(), operator<, etc.
 * if supplementary characters are present:
 *
 * In UTF-16, supplementary characters (with code points U+10000 and above) are
 * stored with pairs of surrogate code units. These have values from 0xd800 to 0xdfff,
 * which means that they compare as less than some other BMP characters like U+feff.
 * This function compares Unicode strings in code point order.
 * If either of the UTF-16 strings is malformed (i.e., it contains unpaired surrogates), then the result is not defined.
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcChars A pointer to another string to compare this one to.
 * @return a negative/zero/positive integer corresponding to whether
 * this string is less than/equal to/greater than the second one
 * in code point order
 * @stable ICU 2.0
 */
inline int8_t compareCodePointOrder(int32_t start,
                                    int32_t length,
                                    const char16_t *srcChars) const;

/**
 * Compare two Unicode strings in code point order.
 * The result may be different from the results of compare(), operator<, etc.
 * if supplementary characters are present:
 *
 * In UTF-16, supplementary characters (with code points U+10000 and above) are
 * stored with pairs of surrogate code units. These have values from 0xd800 to 0xdfff,
 * which means that they compare as less than some other BMP characters like U+feff.
 * This function compares Unicode strings in code point order.
 * If either of the UTF-16 strings is malformed (i.e., it contains unpaired surrogates), then the result is not defined.
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcChars A pointer to another string to compare this one to.
 * @param srcStart The start offset in that string at which the compare operation begins.
 * @param srcLength The number of code units from that string to compare.
 * @return a negative/zero/positive integer corresponding to whether
 * this string is less than/equal to/greater than the second one
 * in code point order
 * @stable ICU 2.0
 */
inline int8_t compareCodePointOrder(int32_t start,
                                    int32_t length,
                                    const char16_t *srcChars,
                                    int32_t srcStart,
                                    int32_t srcLength) const;

/**
 * Compare two Unicode strings in code point order.
 * The result may be different from the results of compare(), operator<, etc.
 * if supplementary characters are present:
 *
 * In UTF-16, supplementary characters (with code points U+10000 and above) are
 * stored with pairs of surrogate code units. These have values from 0xd800 to 0xdfff,
 * which means that they compare as less than some other BMP characters like U+feff.
 * This function compares Unicode strings in code point order.
 * If either of the UTF-16 strings is malformed (i.e., it contains unpaired surrogates), then the result is not defined.
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param limit The offset after the last code unit from this string to compare.
 * @param srcText Another string to compare this one to.
 * @param srcStart The start offset in that string at which the compare operation begins.
 * @param srcLimit The offset after the last code unit from that string to compare.
 * @return a negative/zero/positive integer corresponding to whether
 * this string is less than/equal to/greater than the second one
 * in code point order
 * @stable ICU 2.0
 */
inline int8_t compareCodePointOrderBetween(int32_t start,
                                           int32_t limit,
                                           const UnicodeString& srcText,
                                           int32_t srcStart,
                                           int32_t srcLimit) const;

/**
 * Compare two strings case-insensitively using full case folding.
 * This is equivalent to this->foldCase(options).compare(text.foldCase(options)).
 *
 * @param text Another string to compare this one to.
 * @param options A bit set of options:
 *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
 *     Comparison in code unit order with default case folding.
 *
 *   - U_COMPARE_CODE_POINT_ORDER
 *     Set to choose code point order instead of code unit order
 *     (see u_strCompare for details).
 *
 *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
 *
 * @return A negative, zero, or positive integer indicating the comparison result.
 * @stable ICU 2.0
 */
inline int8_t caseCompare(const UnicodeString& text, uint32_t options) const;

/**
 * Compare two strings case-insensitively using full case folding.
 * This is equivalent to this->foldCase(options).compare(srcText.foldCase(options)).
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcText Another string to compare this one to.
 * @param options A bit set of options:
 *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
 *     Comparison in code unit order with default case folding.
 *
 *   - U_COMPARE_CODE_POINT_ORDER
 *     Set to choose code point order instead of code unit order
 *     (see u_strCompare for details).
 *
 *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
 *
 * @return A negative, zero, or positive integer indicating the comparison result.
 * @stable ICU 2.0
 */
inline int8_t caseCompare(int32_t start,
       int32_t length,
       const UnicodeString& srcText,
       uint32_t options) const;

/**
 * Compare two strings case-insensitively using full case folding.
 * This is equivalent to this->foldCase(options).compare(srcText.foldCase(options)).
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcText Another string to compare this one to.
 * @param srcStart The start offset in that string at which the compare operation begins.
 * @param srcLength The number of code units from that string to compare.
 * @param options A bit set of options:
 *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
 *     Comparison in code unit order with default case folding.
 *
 *   - U_COMPARE_CODE_POINT_ORDER
 *     Set to choose code point order instead of code unit order
 *     (see u_strCompare for details).
 *
 *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
 *
 * @return A negative, zero, or positive integer indicating the comparison result.
 * @stable ICU 2.0
 */
inline int8_t caseCompare(int32_t start,
       int32_t length,
       const UnicodeString& srcText,
       int32_t srcStart,
       int32_t srcLength,
       uint32_t options) const;

/**
 * Compare two strings case-insensitively using full case folding.
 * This is equivalent to this->foldCase(options).compare(srcChars.foldCase(options)).
 *
 * @param srcChars A pointer to another string to compare this one to.
 * @param srcLength The number of code units from that string to compare.
 * @param options A bit set of options:
 *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
 *     Comparison in code unit order with default case folding.
 *
 *   - U_COMPARE_CODE_POINT_ORDER
 *     Set to choose code point order instead of code unit order
 *     (see u_strCompare for details).
 *
 *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
 *
 * @return A negative, zero, or positive integer indicating the comparison result.
 * @stable ICU 2.0
 */
inline int8_t caseCompare(ConstChar16Ptr srcChars,
       int32_t srcLength,
       uint32_t options) const;

/**
 * Compare two strings case-insensitively using full case folding.
 * This is equivalent to this->foldCase(options).compare(srcChars.foldCase(options)).
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcChars A pointer to another string to compare this one to.
 * @param options A bit set of options:
 *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
 *     Comparison in code unit order with default case folding.
 *
 *   - U_COMPARE_CODE_POINT_ORDER
 *     Set to choose code point order instead of code unit order
 *     (see u_strCompare for details).
 *
 *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
 *
 * @return A negative, zero, or positive integer indicating the comparison result.
 * @stable ICU 2.0
 */
inline int8_t caseCompare(int32_t start,
       int32_t length,
       const char16_t *srcChars,
       uint32_t options) const;

/**
 * Compare two strings case-insensitively using full case folding.
 * This is equivalent to this->foldCase(options).compare(srcChars.foldCase(options)).
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param length The number of code units from this string to compare.
 * @param srcChars A pointer to another string to compare this one to.
 * @param srcStart The start offset in that string at which the compare operation begins.
 * @param srcLength The number of code units from that string to compare.
 * @param options A bit set of options:
 *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
 *     Comparison in code unit order with default case folding.
 *
 *   - U_COMPARE_CODE_POINT_ORDER
 *     Set to choose code point order instead of code unit order
 *     (see u_strCompare for details).
 *
 *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
 *
 * @return A negative, zero, or positive integer indicating the comparison result.
 * @stable ICU 2.0
 */
inline int8_t caseCompare(int32_t start,
       int32_t length,
       const char16_t *srcChars,
       int32_t srcStart,
       int32_t srcLength,
       uint32_t options) const;

/**
 * Compare two strings case-insensitively using full case folding.
 * This is equivalent to this->foldCase(options).compareBetween(text.foldCase(options)).
 *
 * @param start The start offset in this string at which the compare operation begins.
 * @param limit The offset after the last code unit from this string to compare.
 * @param srcText Another string to compare this one to.
 * @param srcStart The start offset in that string at which the compare operation begins.
 * @param srcLimit The offset after the last code unit from that string to compare.
 * @param options A bit set of options:
 *   - U_FOLD_CASE_DEFAULT or 0 is used for default options:
 *     Comparison in code unit order with default case folding.
 *
 *   - U_COMPARE_CODE_POINT_ORDER
 *     Set to choose code point order instead of code unit order
 *     (see u_strCompare for details).
 *
 *   - U_FOLD_CASE_EXCLUDE_SPECIAL_I
 *
 * @return A negative, zero, or positive integer indicating the comparison result.
 * @stable ICU 2.0
 */
inline int8_t caseCompareBetween(int32_t start,
          int32_t limit,
          const UnicodeString& srcText,
          int32_t srcStart,
          int32_t srcLimit,
          uint32_t options) const;

/**
 * Determine if this starts with the characters in `text`
 * @param text The text to match.
 * @return true if this starts with the characters in `text`,
 * false otherwise
 * @stable ICU 2.0
 */
inline UBool startsWith(const UnicodeString& text) const;

/**
 * Determine if this starts with the characters in `srcText`
 * in the range [`srcStart`, `srcStart + srcLength`).
 * @param srcText The text to match.
 * @param srcStart the offset into `srcText` to start matching
 * @param srcLength the number of characters in `srcText` to match
 * @return true if this starts with the characters in `text`,
 * false otherwise
 * @stable ICU 2.0
 */
inline UBool startsWith(const UnicodeString& srcText,
          int32_t srcStart,
          int32_t srcLength) const;

/**
 * Determine if this starts with the characters in `srcChars`
 * @param srcChars The characters to match.
 * @param srcLength the number of characters in `srcChars`
 * @return true if this starts with the characters in `srcChars`,
 * false otherwise
 * @stable ICU 2.0
 */
inline UBool startsWith(ConstChar16Ptr srcChars,
          int32_t srcLength) const;

/**
 * Determine if this ends with the characters in `srcChars`
 * in the range  [`srcStart`, `srcStart + srcLength`).
 * @param srcChars The characters to match.
 * @param srcStart the offset into `srcText` to start matching
 * @param srcLength the number of characters in `srcChars` to match
 * @return true if this ends with the characters in `srcChars`, false otherwise
 * @stable ICU 2.0
 */
inline UBool startsWith(const char16_t *srcChars,
          int32_t srcStart,
          int32_t srcLength) const;

/**
 * Determine if this ends with the characters in `text`
 * @param text The text to match.
 * @return true if this ends with the characters in `text`,
 * false otherwise
 * @stable ICU 2.0
 */
inline UBool endsWith(const UnicodeString& text) const;

/**
 * Determine if this ends with the characters in `srcText`
 * in the range [`srcStart`, `srcStart + srcLength`).
 * @param srcText The text to match.
 * @param srcStart the offset into `srcText` to start matching
 * @param srcLength the number of characters in `srcText` to match
 * @return true if this ends with the characters in `text`,
 * false otherwise
 * @stable ICU 2.0
 */
inline UBool endsWith(const UnicodeString& srcText,
        int32_t srcStart,
        int32_t srcLength) const;

/**
 * Determine if this ends with the characters in `srcChars`
 * @param srcChars The characters to match.
 * @param srcLength the number of characters in `srcChars`
 * @return true if this ends with the characters in `srcChars`,
 * false otherwise
 * @stable ICU 2.0
 */
inline UBool endsWith(ConstChar16Ptr srcChars,
        int32_t srcLength) const;

/**
 * Determine if this ends with the characters in `srcChars`
 * in the range  [`srcStart`, `srcStart + srcLength`).
 * @param srcChars The characters to match.
 * @param srcStart the offset into `srcText` to start matching
 * @param srcLength the number of characters in `srcChars` to match
 * @return true if this ends with the characters in `srcChars`,
 * false otherwise
 * @stable ICU 2.0
 */
inline UBool endsWith(const char16_t *srcChars,
        int32_t srcStart,
        int32_t srcLength) const;


/* Searching - bitwise only */

/**
 * Locate in this the first occurrence of the characters in `text`,
 * using bitwise comparison.
 * @param text The text to search for.
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(const UnicodeString& text) const;

/**
 * Locate in this the first occurrence of the characters in `text`
 * starting at offset `start`, using bitwise comparison.
 * @param text The text to search for.
 * @param start The offset at which searching will start.
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(const UnicodeString& text,
            int32_t start) const;

/**
 * Locate in this the first occurrence in the range
 * [`start`, `start + length`) of the characters
 * in `text`, using bitwise comparison.
 * @param text The text to search for.
 * @param start The offset at which searching will start.
 * @param length The number of characters to search
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(const UnicodeString& text,
            int32_t start,
            int32_t length) const;

/**
 * Locate in this the first occurrence in the range
 * [`start`, `start + length`) of the characters
 *  in `srcText` in the range
 * [`srcStart`, `srcStart + srcLength`),
 * using bitwise comparison.
 * @param srcText The text to search for.
 * @param srcStart the offset into `srcText` at which
 * to start matching
 * @param srcLength the number of characters in `srcText` to match
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(const UnicodeString& srcText,
            int32_t srcStart,
            int32_t srcLength,
            int32_t start,
            int32_t length) const;

/**
 * Locate in this the first occurrence of the characters in
 * `srcChars`
 * starting at offset `start`, using bitwise comparison.
 * @param srcChars The text to search for.
 * @param srcLength the number of characters in `srcChars` to match
 * @param start the offset into this at which to start matching
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(const char16_t *srcChars,
            int32_t srcLength,
            int32_t start) const;

/**
 * Locate in this the first occurrence in the range
 * [`start`, `start + length`) of the characters
 * in `srcChars`, using bitwise comparison.
 * @param srcChars The text to search for.
 * @param srcLength the number of characters in `srcChars`
 * @param start The offset at which searching will start.
 * @param length The number of characters to search
 * @return The offset into this of the start of `srcChars`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(ConstChar16Ptr srcChars,
            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 `srcChars` in the range
 * [`srcStart`, `srcStart + srcLength`),
 * using bitwise comparison.
 * @param srcChars The text to search for.
 * @param srcStart the offset into `srcChars` at which
 * to start matching
 * @param srcLength the number of characters in `srcChars` to match
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
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 of the BMP code point `c`,
 * using bitwise comparison.
 * @param c The code unit to search for.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(char16_t c) const;

/**
 * Locate in this the first occurrence of the code point `c`,
 * using bitwise comparison.
 *
 * @param c The code point to search for.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(UChar32 c) const;

/**
 * Locate in this the first occurrence of the BMP code point `c`,
 * starting at offset `start`, using bitwise comparison.
 * @param c The code unit to search for.
 * @param start The offset at which searching will start.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(char16_t c,
            int32_t start) const;

/**
 * Locate in this the first occurrence of the code point `c`
 * starting at offset `start`, using bitwise comparison.
 *
 * @param c The code point to search for.
 * @param start The offset at which searching will start.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(UChar32 c,
            int32_t start) const;

/**
 * Locate in this the first occurrence of the BMP code point `c`
 * in the range [`start`, `start + length`),
 * using bitwise comparison.
 * @param c The code unit to search for.
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(char16_t c,
            int32_t start,
            int32_t length) const;

/**
 * Locate in this the first occurrence of the code point `c`
 * in the range [`start`, `start + length`),
 * using bitwise comparison.
 *
 * @param c The code point to search for.
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t indexOf(UChar32 c,
            int32_t start,
            int32_t length) const;

/**
 * Locate in this the last occurrence of the characters in `text`,
 * using bitwise comparison.
 * @param text The text to search for.
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(const UnicodeString& text) const;

/**
 * Locate in this the last occurrence of the characters in `text`
 * starting at offset `start`, using bitwise comparison.
 * @param text The text to search for.
 * @param start The offset at which searching will start.
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(const UnicodeString& text,
            int32_t start) const;

/**
 * Locate in this the last occurrence in the range
 * [`start`, `start + length`) of the characters
 * in `text`, using bitwise comparison.
 * @param text The text to search for.
 * @param start The offset at which searching will start.
 * @param length The number of characters to search
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(const UnicodeString& text,
            int32_t start,
            int32_t length) const;

/**
 * Locate in this the last occurrence in the range
 * [`start`, `start + length`) of the characters
 * in `srcText` in the range
 * [`srcStart`, `srcStart + srcLength`),
 * using bitwise comparison.
 * @param srcText The text to search for.
 * @param srcStart the offset into `srcText` at which
 * to start matching
 * @param srcLength the number of characters in `srcText` to match
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(const UnicodeString& srcText,
            int32_t srcStart,
            int32_t srcLength,
            int32_t start,
            int32_t length) const;

/**
 * Locate in this the last occurrence of the characters in `srcChars`
 * starting at offset `start`, using bitwise comparison.
 * @param srcChars The text to search for.
 * @param srcLength the number of characters in `srcChars` to match
 * @param start the offset into this at which to start matching
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(const char16_t *srcChars,
            int32_t srcLength,
            int32_t start) const;

/**
 * Locate in this the last occurrence in the range
 * [`start`, `start + length`) of the characters
 * in `srcChars`, using bitwise comparison.
 * @param srcChars The text to search for.
 * @param srcLength the number of characters in `srcChars`
 * @param start The offset at which searching will start.
 * @param length The number of characters to search
 * @return The offset into this of the start of `srcChars`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(ConstChar16Ptr srcChars,
            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` in the range
 * [`srcStart`, `srcStart + srcLength`),
 * using bitwise comparison.
 * @param srcChars The text to search for.
 * @param srcStart the offset into `srcChars` at which
 * to start matching
 * @param srcLength the number of characters in `srcChars` to match
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of the start of `text`,
 * or -1 if not found.
 * @stable ICU 2.0
 */
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 of the BMP code point `c`,
 * using bitwise comparison.
 * @param c The code unit to search for.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(char16_t c) const;

/**
 * Locate in this the last occurrence of the code point `c`,
 * using bitwise comparison.
 *
 * @param c The code point to search for.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(UChar32 c) const;

/**
 * Locate in this the last occurrence of the BMP code point `c`
 * starting at offset `start`, using bitwise comparison.
 * @param c The code unit to search for.
 * @param start The offset at which searching will start.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(char16_t c,
            int32_t start) const;

/**
 * Locate in this the last occurrence of the code point `c`
 * starting at offset `start`, using bitwise comparison.
 *
 * @param c The code point to search for.
 * @param start The offset at which searching will start.
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(UChar32 c,
            int32_t start) const;

/**
 * Locate in this the last occurrence of the BMP code point `c`
 * in the range [`start`, `start + length`),
 * using bitwise comparison.
 * @param c The code unit to search for.
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(char16_t c,
            int32_t start,
            int32_t length) const;

/**
 * Locate in this the last occurrence of the code point `c`
 * in the range [`start`, `start + length`),
 * using bitwise comparison.
 *
 * @param c The code point to search for.
 * @param start the offset into this at which to start matching
 * @param length the number of characters in this to search
 * @return The offset into this of `c`, or -1 if not found.
 * @stable ICU 2.0
 */
inline int32_t lastIndexOf(UChar32 c,
            int32_t start,
            int32_t length) const;


/* Character access */

/**
 * Return the code unit at offset `offset`.
 * If the offset is not valid (0..length()-1) then U+ffff is returned.
 * @param offset a valid offset into the text
 * @return the code unit at offset `offset`
 *         or 0xffff if the offset is not valid for this string
 * @stable ICU 2.0
 */
inline char16_t charAt(int32_t offset) const;

/**
 * Return the code unit at offset `offset`.
 * If the offset is not valid (0..length()-1) then U+ffff is returned.
 * @param offset a valid offset into the text
 * @return the code unit at offset `offset`
 * @stable ICU 2.0
 */
inline char16_t operator[] (int32_t offset) const;

/**
 * Return the code point that contains the code unit
 * at offset `offset`.
 * If the offset is not valid (0..length()-1) then U+ffff is returned.
 * @param offset a valid offset into the text
 * that indicates the text offset of any of the code units
 * that will be assembled into a code point (21-bit value) and returned
 * @return the code point of text at `offset`
 *         or 0xffff if the offset is not valid for this string
 * @stable ICU 2.0
 */
UChar32 char32At(int32_t offset) const;

/**
 * Adjust a random-access offset so that
 * it points to the beginning of a Unicode character.
 * The offset that is passed in points to
 * any code unit of a code point,
 * while the returned offset will point to the first code unit
 * of the same code point.
 * In UTF-16, if the input offset points to a second surrogate
 * of a surrogate pair, then the returned offset will point
 * to the first surrogate.
 * @param offset a valid offset into one code point of the text
 * @return offset of the first code unit of the same code point
 * @see U16_SET_CP_START
 * @stable ICU 2.0
 */
int32_t getChar32Start(int32_t offset) const;

/**
 * Adjust a random-access offset so that
 * it points behind a Unicode character.
 * The offset that is passed in points behind
 * any code unit of a code point,
 * while the returned offset will point behind the last code unit
 * of the same code point.
 * In UTF-16, if the input offset points behind the first surrogate
 * (i.e., to the second surrogate)
 * of a surrogate pair, then the returned offset will point
 * behind the second surrogate (i.e., to the first surrogate).
 * @param offset a valid offset after any code unit of a code point of the text
 * @return offset of the first code unit after the same code point
 * @see U16_SET_CP_LIMIT
 * @stable ICU 2.0
 */
int32_t getChar32Limit(int32_t offset) const;

/**
 * Move the code unit index along the string by delta code points.
 * Interpret the input index as a code unit-based offset into the string,
 * move the index forward or backward by delta code points, and
 * return the resulting index.
 * The input index should point to the first code unit of a code point,
 * if there is more than one.
 *
 * Both input and output indexes are code unit-based as for all
 * string indexes/offsets in ICU (and other libraries, like MBCS char*).
 * If delta<0 then the index is moved backward (toward the start of the string).
 * If delta>0 then the index is moved forward (toward the end of the string).
 *
 * This behaves like CharacterIterator::move32(delta, kCurrent).
 *
 * Behavior for out-of-bounds indexes:
 * `moveIndex32` pins the input index to 0..length(), i.e.,
 * if the input index<0 then it is pinned to 0;
 * if it is index>length() then it is pinned to length().
 * Afterwards, the index is moved by `delta` code points
 * forward or backward,
 * but no further backward than to 0 and no further forward than to length().
 * The resulting index return value will be in between 0 and length(), inclusively.
 *
 * Examples:
 * \code
 *     // s has code points 'a' U+10000 'b' U+10ffff U+2029
 *     UnicodeString s(u"a\U00010000b\U0010ffff\u2029");
 *
 *     // initial index: position of U+10000
 *     int32_t index=1;
 *
 *     // the following examples will all result in index==4, position of U+10ffff
 *
 *     // skip 2 code points from some position in the string
 *     index=s.moveIndex32(index, 2); // skips U+10000 and 'b'
 *
 *     // go to the 3rd code point from the start of s (0-based)
 *     index=s.moveIndex32(0, 3); // skips 'a', U+10000, and 'b'
 *
 *     // go to the next-to-last code point of s
 *     index=s.moveIndex32(s.length(), -2); // backward-skips U+2029 and U+10ffff
 * \endcode
 *
 * @param index input code unit index
 * @param delta (signed) code point count to move the index forward or backward
 *        in the string
 * @return the resulting code unit index
 * @stable ICU 2.0
 */
int32_t moveIndex32(int32_t index, int32_t delta) const;

/* Substring extraction */

/**
 * Copy the characters in the range
 * [`start`, `start + length`) into the array `dst`,
 * beginning at `dstStart`.
 * If the string aliases to `dst` itself as an external buffer,
 * then extract() will not copy the contents.
 *
 * @param start offset of first character which will be copied into the array
 * @param length the number of characters to extract
 * @param dst array in which to copy characters.  The length of `dst`
 * must be at least (`dstStart + length`).
 * @param dstStart the offset in `dst` where the first character
 * will be extracted
 * @stable ICU 2.0
 */
inline void extract(int32_t start,
         int32_t length,
         Char16Ptr dst,
         int32_t dstStart = 0) const;

/**
 * Copy the contents of the string into dest.
 * This is a convenience function that
 * checks if there is enough space in dest,
 * extracts the entire string if possible,
 * and NUL-terminates dest if possible.
 *
 * If the string fits into dest but cannot be NUL-terminated
 * (length()==destCapacity) then the error code is set to U_STRING_NOT_TERMINATED_WARNING.
 * If the string itself does not fit into dest
 * (length()>destCapacity) then the error code is set to U_BUFFER_OVERFLOW_ERROR.
 *
 * If the string aliases to `dest` itself as an external buffer,
 * then extract() will not copy the contents.
 *
 * @param dest Destination string buffer.
 * @param destCapacity Number of char16_ts available at dest.
 * @param errorCode ICU error code.
 * @return length()
 * @stable ICU 2.0
 */
int32_t
extract(Char16Ptr dest, int32_t destCapacity,
        UErrorCode &errorCode) const;

/**
 * Copy the characters in the range
 * [`start`, `start + length`) into the  UnicodeString
 * `target`.
 * @param start offset of first character which will be copied
 * @param length the number of characters to extract
 * @param target UnicodeString into which to copy characters.
 * @stable ICU 2.0
 */
inline void extract(int32_t start,
         int32_t length,
         UnicodeString& target) const;

/**
 * Copy the characters in the range [`start`, `limit`)
 * into the array `dst`, beginning at `dstStart`.
 * @param start offset of first character which will be copied into the array
 * @param limit offset immediately following the last character to be copied
 * @param dst array in which to copy characters.  The length of `dst`
 * must be at least (`dstStart + (limit - start)`).
 * @param dstStart the offset in `dst` where the first character
 * will be extracted
 * @stable ICU 2.0
 */
inline void extractBetween(int32_t start,
            int32_t limit,
            char16_t *dst,
            int32_t dstStart = 0) const;

/**
 * Copy the characters in the range [`start`, `limit`)
 * into the UnicodeString `target`.  Replaceable API.
 * @param start offset of first character which will be copied
 * @param limit offset immediately following the last character to be copied
 * @param target UnicodeString into which to copy characters.
 * @stable ICU 2.0
 */
virtual void extractBetween(int32_t start,
            int32_t limit,
            UnicodeString& target) const override;

/**
 * Copy the characters in the range
 * [`start`, `start + startLength`) into an array of characters.
 * All characters must be invariant (see utypes.h).
 * Use US_INV as the last, signature-distinguishing parameter.
 *
 * This function does not write any more than `targetCapacity`
 * characters but returns the length of the entire output string
 * so that one can allocate a larger buffer and call the function again
 * if necessary.
 * The output string is NUL-terminated if possible.
 *
 * @param start offset of first character which will be copied
 * @param startLength the number of characters to extract
 * @param target the target buffer for extraction, can be NULL
 *               if targetLength is 0
 * @param targetCapacity the length of the target buffer
 * @param inv Signature-distinguishing parameter, use US_INV.
 * @return the output string length, not including the terminating NUL
 * @stable ICU 3.2
 */
int32_t extract(int32_t start,
         int32_t startLength,
         char *target,
         int32_t targetCapacity,
         enum EInvariant inv) const;

1558#if U_CHARSET_IS_UTF81 || !UCONFIG_NO_CONVERSION0

/**
 * Copy the characters in the range
 * [`start`, `start + length`) into an array of characters
 * in the platform's default codepage.
 * This function does not write any more than `targetLength`
 * characters but returns the length of the entire output string
 * so that one can allocate a larger buffer and call the function again
 * if necessary.
 * The output string is NUL-terminated if possible.
 *
 * @param start offset of first character which will be copied
 * @param startLength the number of characters to extract
 * @param target the target buffer for extraction
 * @param targetLength the length of the target buffer
 * If `target` is NULL, then the number of bytes required for
 * `target` is returned.
 * @return the output string length, not including the terminating NUL
 * @stable ICU 2.0
 */
int32_t extract(int32_t start,
         int32_t startLength,
         char *target,
         uint32_t targetLength) const;

1584#endif

1586#if !UCONFIG_NO_CONVERSION0

/**
 * Copy the characters in the range
 * [`start`, `start + length`) into an array of characters
 * in a specified codepage.
 * The output string is NUL-terminated.
 *
 * Recommendation: For invariant-character strings use
 * extract(int32_t start, int32_t length, char *target, int32_t targetCapacity, enum EInvariant inv) const
 * because it avoids object code dependencies of UnicodeString on
 * the conversion code.
 *
 * @param start offset of first character which will be copied
 * @param startLength the number of characters to extract
 * @param target the target buffer for extraction
 * @param codepage the desired codepage for the characters.  0 has
 * the special meaning of the default codepage
 * If `codepage` is an empty string (`""`),
 * then a simple conversion is performed on the codepage-invariant
 * subset ("invariant characters") of the platform encoding. See utypes.h.
 * If `target` is NULL, then the number of bytes required for
 * `target` is returned. It is assumed that the target is big enough
 * to fit all of the characters.
 * @return the output string length, not including the terminating NUL
 * @stable ICU 2.0
 */
inline int32_t extract(int32_t start,
               int32_t startLength,
               char *target,
               const char *codepage = 0) const;

/**
 * Copy the characters in the range
 * [`start`, `start + length`) into an array of characters
 * in a specified codepage.
 * This function does not write any more than `targetLength`
 * characters but returns the length of the entire output string
 * so that one can allocate a larger buffer and call the function again
 * if necessary.
 * The output string is NUL-terminated if possible.
 *
 * Recommendation: For invariant-character strings use
 * extract(int32_t start, int32_t length, char *target, int32_t targetCapacity, enum EInvariant inv) const
 * because it avoids object code dependencies of UnicodeString on
 * the conversion code.
 *
 * @param start offset of first character which will be copied
 * @param startLength the number of characters to extract
 * @param target the target buffer for extraction
 * @param targetLength the length of the target buffer
 * @param codepage the desired codepage for the characters.  0 has
 * the special meaning of the default codepage
 * If `codepage` is an empty string (`""`),
 * then a simple conversion is performed on the codepage-invariant
 * subset ("invariant characters") of the platform encoding. See utypes.h.
 * If `target` is NULL, then the number of bytes required for
 * `target` is returned.
 * @return the output string length, not including the terminating NUL
 * @stable ICU 2.0
 */
int32_t extract(int32_t start,
         int32_t startLength,
         char *target,
         uint32_t targetLength,
         const char *codepage) const;

/**
 * Convert the UnicodeString into a codepage string using an existing UConverter.
 * The output string is NUL-terminated if possible.
 *
 * This function avoids the overhead of opening and closing a converter if
 * multiple strings are extracted.
 *
 * @param dest destination string buffer, can be NULL if destCapacity==0
 * @param destCapacity the number of chars available at dest
 * @param cnv the converter object to be used (ucnv_resetFromUnicode() will be called),
 *        or NULL for the default converter
 * @param errorCode normal ICU error code
 * @return the length of the output string, not counting the terminating NUL;
 *         if the length is greater than destCapacity, then the string will not fit
 *         and a buffer of the indicated length would need to be passed in
 * @stable ICU 2.0
 */
int32_t extract(char *dest, int32_t destCapacity,
                UConverter *cnv,
                UErrorCode &errorCode) const;

1674#endif

/**
 * Create a temporary substring for the specified range.
 * Unlike the substring constructor and setTo() functions,
 * the object returned here will be a read-only alias (using getBuffer())
 * rather than copying the text.
 * As a result, this substring operation is much faster but requires
 * that the original string not be modified or deleted during the lifetime
 * of the returned substring object.
 * @param start offset of the first character visible in the substring
 * @param length length of the substring
 * @return a read-only alias UnicodeString object for the substring
 * @stable ICU 4.4
 */
UnicodeString tempSubString(int32_t start=0, int32_t length=INT32_MAX(2147483647)) const;

/**
 * Create a temporary substring for the specified range.
 * Same as tempSubString(start, length) except that the substring range
 * is specified as a (start, limit) pair (with an exclusive limit index)
 * rather than a (start, length) pair.
 * @param start offset of the first character visible in the substring
 * @param limit offset immediately following the last character visible in the substring
 * @return a read-only alias UnicodeString object for the substring
 * @stable ICU 4.4
 */
inline UnicodeString tempSubStringBetween(int32_t start, int32_t limit=INT32_MAX(2147483647)) const;

/**
 * Convert the UnicodeString to UTF-8 and write the result
 * to a ByteSink. This is called by toUTF8String().
 * Unpaired surrogates are replaced with U+FFFD.
 * Calls u_strToUTF8WithSub().
 *
 * @param sink A ByteSink to which the UTF-8 version of the string is written.
 *             sink.Flush() is called at the end.
 * @stable ICU 4.2
 * @see toUTF8String
 */
void toUTF8(ByteSink &sink) const;

/**
 * Convert the UnicodeString to UTF-8 and append the result
 * to a standard string.
 * Unpaired surrogates are replaced with U+FFFD.
 * Calls toUTF8().
 *
 * @param result A standard string (or a compatible object)
 *        to which the UTF-8 version of the string is appended.
 * @return The string object.
 * @stable ICU 4.2
 * @see toUTF8
 */
template<typename StringClass>
StringClass &toUTF8String(StringClass &result) const {
  StringByteSink<StringClass> sbs(&result, length());
  toUTF8(sbs);
  return result;
}

/**
 * Convert the UnicodeString to UTF-32.
 * Unpaired surrogates are replaced with U+FFFD.
 * Calls u_strToUTF32WithSub().
 *
 * @param utf32 destination string buffer, can be NULL if capacity==0
 * @param capacity the number of UChar32s available at utf32
 * @param errorCode Standard ICU error code. Its input value must
 *                  pass the U_SUCCESS() test, or else the function returns
 *                  immediately. Check for U_FAILURE() on output or use with
 *                  function chaining. (See User Guide for details.)
 * @return The length of the UTF-32 string.
 * @see fromUTF32
 * @stable ICU 4.2
 */
int32_t toUTF32(UChar32 *utf32, int32_t capacity, UErrorCode &errorCode) const;

/* Length operations */

/**
 * Return the length of the UnicodeString object.
 * The length is the number of char16_t code units are in the UnicodeString.
 * If you want the number of code points, please use countChar32().
 * @return the length of the UnicodeString object
 * @see countChar32
 * @stable ICU 2.0
 */
inline int32_t length(void) const;

/**
 * Count Unicode code points in the length char16_t code units of the string.
 * A code point may occupy either one or two char16_t code units.
 * Counting code points involves reading all code units.
 *
 * This functions is basically the inverse of moveIndex32().
 *
 * @param start the index of the first code unit to check
 * @param length the number of char16_t code units to check
 * @return the number of code points in the specified code units
 * @see length
 * @stable ICU 2.0
 */
int32_t
countChar32(int32_t start=0, int32_t length=INT32_MAX(2147483647)) const;

/**
 * Check if the length char16_t code units of the string
 * contain more Unicode code points than a certain number.
 * This is more efficient than counting all code points in this part of the string
 * and comparing that number with a threshold.
 * This function may not need to scan the string at all if the length
 * falls within a certain range, and
 * never needs to count more than 'number+1' code points.
 * Logically equivalent to (countChar32(start, length)>number).
 * A Unicode code point may occupy either one or two char16_t code units.
 *
 * @param start the index of the first code unit to check (0 for the entire string)
 * @param length the number of char16_t code units to check
 *               (use INT32_MAX for the entire string; remember that start/length
 *                values are pinned)
 * @param number The number of code points in the (sub)string is compared against
 *               the 'number' parameter.
 * @return Boolean value for whether the string contains more Unicode code points
 *         than 'number'. Same as (u_countChar32(s, length)>number).
 * @see countChar32
 * @see u_strHasMoreChar32Than
 * @stable ICU 2.4
 */
UBool
hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const;

/**
 * Determine if this string is empty.
 * @return true if this string contains 0 characters, false otherwise.
 * @stable ICU 2.0
 */
inline UBool isEmpty(void) const;

/**
 * Return the capacity of the internal buffer of the UnicodeString object.
 * This is useful together with the getBuffer functions.
 * See there for details.
 *
 * @return the number of char16_ts available in the internal buffer
 * @see getBuffer
 * @stable ICU 2.0
 */
inline int32_t getCapacity(void) const;

/* Other operations */

/**
 * Generate a hash code for this object.
 * @return The hash code of this UnicodeString.
 * @stable ICU 2.0
 */
inline int32_t hashCode(void) const;

/**
 * Determine if this object contains a valid string.
 * A bogus string has no value. It is different from an empty string,
 * although in both cases isEmpty() returns true and length() returns 0.
 * setToBogus() and isBogus() can be used to indicate that no string value is available.
 * For a bogus string, getBuffer() and getTerminatedBuffer() return NULL, and
 * length() returns 0.
 *
 * @return true if the string is bogus/invalid, false otherwise
 * @see setToBogus()
 * @stable ICU 2.0
 */
inline UBool isBogus(void) const;


//========================================
// Write operations
//========================================

/* Assignment operations */

/**
 * Assignment operator.  Replace the characters in this UnicodeString
 * with the characters from `srcText`.
 *
 * Starting with ICU 2.4, the assignment operator and the copy constructor
 * allocate a new buffer and copy the buffer contents even for readonly aliases.
 * By contrast, the fastCopyFrom() function implements the old,
 * more efficient but less safe behavior
 * of making this string also a readonly alias to the same buffer.
 *
 * If the source object has an "open" buffer from getBuffer(minCapacity),
 * then the copy is an empty string.
 *
 * @param srcText The text containing the characters to replace
 * @return a reference to this
 * @stable ICU 2.0
 * @see fastCopyFrom
 */
UnicodeString &operator=(const UnicodeString &srcText);

/**
 * Almost the same as the assignment operator.
 * Replace the characters in this UnicodeString
 * with the characters from `srcText`.
 *
 * This function works the same as the assignment operator
 * for all strings except for ones that are readonly aliases.
 *
 * Starting with ICU 2.4, the assignment operator and the copy constructor
 * allocate a new buffer and copy the buffer contents even for readonly aliases.
 * This function implements the old, more efficient but less safe behavior
 * of making this string also a readonly alias to the same buffer.
 *
 * The fastCopyFrom function must be used only if it is known that the lifetime of
 * this UnicodeString does not exceed the lifetime of the aliased buffer
 * including its contents, for example for strings from resource bundles
 * or aliases to string constants.
 *
 * If the source object has an "open" buffer from getBuffer(minCapacity),
 * then the copy is an empty string.
 *
 * @param src The text containing the characters to replace.
 * @return a reference to this
 * @stable ICU 2.4
 */
UnicodeString &fastCopyFrom(const UnicodeString &src);

/**
 * Move assignment operator; might leave src in bogus state.
 * This string will have the same contents and state that the source string had.
 * The behavior is undefined if *this and src are the same object.
 * @param src source string
 * @return *this
 * @stable ICU 56
 */
UnicodeString &operator=(UnicodeString &&src) U_NOEXCEPTnoexcept;

/**
 * Swap strings.
 * @param other other string
 * @stable ICU 56
 */
void swap(UnicodeString &other) U_NOEXCEPTnoexcept;

/**
 * Non-member UnicodeString swap function.
 * @param s1 will get s2's contents and state
 * @param s2 will get s1's contents and state
 * @stable ICU 56
 */
friend inline void U_EXPORT2
swap(UnicodeString &s1, UnicodeString &s2) U_NOEXCEPTnoexcept {
  s1.swap(s2);
}

/**
 * Assignment operator.  Replace the characters in this UnicodeString
 * with the code unit `ch`.
 * @param ch the code unit to replace
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& operator= (char16_t ch);

/**
 * Assignment operator.  Replace the characters in this UnicodeString
 * with the code point `ch`.
 * @param ch the code point to replace
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& operator= (UChar32 ch);

/**
 * Set the text in the UnicodeString object to the characters
 * in `srcText` in the range
 * [`srcStart`, `srcText.length()`).
 * `srcText` is not modified.
 * @param srcText the source for the new characters
 * @param srcStart the offset into `srcText` where new characters
 * will be obtained
 * @return a reference to this
 * @stable ICU 2.2
 */
inline UnicodeString& setTo(const UnicodeString& srcText,
             int32_t srcStart);

/**
 * Set the text in the UnicodeString object to the characters
 * in `srcText` in the range
 * [`srcStart`, `srcStart + srcLength`).
 * `srcText` is not modified.
 * @param srcText the source for the new characters
 * @param srcStart the offset into `srcText` where new characters
 * will be obtained
 * @param srcLength the number of characters in `srcText` in the
 * replace string.
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& setTo(const UnicodeString& srcText,
             int32_t srcStart,
             int32_t srcLength);

/**
 * Set the text in the UnicodeString object to the characters in
 * `srcText`.
 * `srcText` is not modified.
 * @param srcText the source for the new characters
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& setTo(const UnicodeString& srcText);

/**
 * Set the characters in the UnicodeString object to the characters
 * in `srcChars`. `srcChars` is not modified.
 * @param srcChars the source for the new characters
 * @param srcLength the number of Unicode characters in srcChars.
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& setTo(const char16_t *srcChars,
             int32_t srcLength);

/**
 * Set the characters in the UnicodeString object to the code unit
 * `srcChar`.
 * @param srcChar the code unit which becomes the UnicodeString's character
 * content
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& setTo(char16_t srcChar);

/**
 * Set the characters in the UnicodeString object to the code point
 * `srcChar`.
 * @param srcChar the code point which becomes the UnicodeString's character
 * content
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& setTo(UChar32 srcChar);

/**
 * Aliasing setTo() function, analogous to the readonly-aliasing char16_t* constructor.
 * The text will be used for the UnicodeString object, but
 * it will not be released when the UnicodeString is destroyed.
 * This has copy-on-write semantics:
 * When the string is modified, then the buffer is first copied into
 * newly allocated memory.
 * The aliased buffer is never modified.
 *
 * In an assignment to another UnicodeString, when using the copy constructor
 * or the assignment operator, the text will be copied.
 * When using fastCopyFrom(), the text will be aliased again,
 * so that both strings then alias the same readonly-text.
 *
 * @param isTerminated specifies if `text` is `NUL`-terminated.
 *                     This must be true if `textLength==-1`.
 * @param text The characters to alias for the UnicodeString.
 * @param textLength The number of Unicode characters in `text` to alias.
 *                   If -1, then this constructor will determine the length
 *                   by calling `u_strlen()`.
 * @return a reference to this
 * @stable ICU 2.0
 */
UnicodeString &setTo(UBool isTerminated,
                     ConstChar16Ptr text,
                     int32_t textLength);

/**
 * Aliasing setTo() function, analogous to the writable-aliasing char16_t* constructor.
 * The text will be used for the UnicodeString object, but
 * it will not be released when the UnicodeString is destroyed.
 * This has write-through semantics:
 * For as long as the capacity of the buffer is sufficient, write operations
 * will directly affect the buffer. When more capacity is necessary, then
 * a new buffer will be allocated and the contents copied as with regularly
 * constructed strings.
 * In an assignment to another UnicodeString, the buffer will be copied.
 * The extract(Char16Ptr dst) function detects whether the dst pointer is the same
 * as the string buffer itself and will in this case not copy the contents.
 *
 * @param buffer The characters to alias for the UnicodeString.
 * @param buffLength The number of Unicode characters in `buffer` to alias.
 * @param buffCapacity The size of `buffer` in char16_ts.
 * @return a reference to this
 * @stable ICU 2.0
 */
UnicodeString &setTo(char16_t *buffer,
                     int32_t buffLength,
                     int32_t buffCapacity);

/**
 * Make this UnicodeString object invalid.
 * The string will test true with isBogus().
 *
 * A bogus string has no value. It is different from an empty string.
 * It can be used to indicate that no string value is available.
 * getBuffer() and getTerminatedBuffer() return NULL, and
 * length() returns 0.
 *
 * This utility function is used throughout the UnicodeString
 * implementation to indicate that a UnicodeString operation failed,
 * and may be used in other functions,
 * especially but not exclusively when such functions do not
 * take a UErrorCode for simplicity.
 *
 * The following methods, and no others, will clear a string object's bogus flag:
 * - remove()
 * - remove(0, INT32_MAX)
 * - truncate(0)
 * - operator=() (assignment operator)
 * - setTo(...)
 *
 * The simplest ways to turn a bogus string into an empty one
 * is to use the remove() function.
 * Examples for other functions that are equivalent to "set to empty string":
 * \code
 * if(s.isBogus()) {
 *   s.remove();           // set to an empty string (remove all), or
 *   s.remove(0, INT32_MAX); // set to an empty string (remove all), or
 *   s.truncate(0);        // set to an empty string (complete truncation), or
 *   s=UnicodeString();    // assign an empty string, or
 *   s.setTo((UChar32)-1); // set to a pseudo code point that is out of range, or
 *   s.setTo(u"", 0);      // set to an empty C Unicode string
 * }
 * \endcode
 *
 * @see isBogus()
 * @stable ICU 2.0
 */
void setToBogus();

/**
 * Set the character at the specified offset to the specified character.
 * @param offset A valid offset into the text of the character to set
 * @param ch The new character
 * @return A reference to this
 * @stable ICU 2.0
 */
UnicodeString& setCharAt(int32_t offset,
             char16_t ch);


/* Append operations */

/**
 * Append operator. Append the code unit `ch` to the UnicodeString
 * object.
 * @param ch the code unit to be appended
 * @return a reference to this
 * @stable ICU 2.0
 */
inline  UnicodeString& operator+= (char16_t ch);

/**
 * Append operator. Append the code point `ch` to the UnicodeString
 * object.
 * @param ch the code point to be appended
 * @return a reference to this
 * @stable ICU 2.0
 */
inline  UnicodeString& operator+= (UChar32 ch);

/**
 * Append operator. Append the characters in `srcText` to the
 * UnicodeString object. `srcText` is not modified.
 * @param srcText the source for the new characters
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& operator+= (const UnicodeString& srcText);

/**
 * Append the characters
 * in `srcText` in the range
 * [`srcStart`, `srcStart + srcLength`) to the
 * UnicodeString object at offset `start`. `srcText`
 * is not modified.
 * @param srcText the source for the new characters
 * @param srcStart the offset into `srcText` where new characters
 * will be obtained
 * @param srcLength the number of characters in `srcText` in
 * the append string
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& append(const UnicodeString& srcText,
          int32_t srcStart,
          int32_t srcLength);

/**
 * Append the characters in `srcText` to the UnicodeString object.
 * `srcText` is not modified.
 * @param srcText the source for the new characters
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& append(const UnicodeString& srcText);

/**
 * Append the characters in `srcChars` in the range
 * [`srcStart`, `srcStart + srcLength`) to the UnicodeString
 * object at offset
 * `start`. `srcChars` is not modified.
 * @param srcChars the source for the new characters
 * @param srcStart the offset into `srcChars` where new characters
 * will be obtained
 * @param srcLength the number of characters in `srcChars` in
 *                  the append string; can be -1 if `srcChars` is NUL-terminated
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& append(const char16_t *srcChars,
          int32_t srcStart,
          int32_t srcLength);

/**
 * Append the characters in `srcChars` to the UnicodeString object
 * at offset `start`. `srcChars` is not modified.
 * @param srcChars the source for the new characters
 * @param srcLength the number of Unicode characters in `srcChars`;
 *                  can be -1 if `srcChars` is NUL-terminated
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& append(ConstChar16Ptr srcChars,
          int32_t srcLength);

/**
 * Append the code unit `srcChar` to the UnicodeString object.
 * @param srcChar the code unit to append
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& append(char16_t srcChar);

/**
 * Append the code point `srcChar` to the UnicodeString object.
 * @param srcChar the code point to append
 * @return a reference to this
 * @stable ICU 2.0
 */
UnicodeString& append(UChar32 srcChar);


/* Insert operations */

/**
 * Insert the characters in `srcText` in the range
 * [`srcStart`, `srcStart + srcLength`) into the UnicodeString
 * object at offset `start`. `srcText` is not modified.
 * @param start the offset where the insertion begins
 * @param srcText the source for the new characters
 * @param srcStart the offset into `srcText` where new characters
 * will be obtained
 * @param srcLength the number of characters in `srcText` in
 * the insert string
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& insert(int32_t start,
          const UnicodeString& srcText,
          int32_t srcStart,
          int32_t srcLength);

/**
 * Insert the characters in `srcText` into the UnicodeString object
 * at offset `start`. `srcText` is not modified.
 * @param start the offset where the insertion begins
 * @param srcText the source for the new characters
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& insert(int32_t start,
          const UnicodeString& srcText);

/**
 * Insert the characters in `srcChars` in the range
 * [`srcStart`, `srcStart + srcLength`) into the UnicodeString
 *  object at offset `start`. `srcChars` is not modified.
 * @param start the offset at which the insertion begins
 * @param srcChars the source for the new characters
 * @param srcStart the offset into `srcChars` where new characters
 * will be obtained
 * @param srcLength the number of characters in `srcChars`
 * in the insert string
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& insert(int32_t start,
          const char16_t *srcChars,
          int32_t srcStart,
          int32_t srcLength);

/**
 * Insert the characters in `srcChars` into the UnicodeString object
 * at offset `start`. `srcChars` is not modified.
 * @param start the offset where the insertion begins
 * @param srcChars the source for the new characters
 * @param srcLength the number of Unicode characters in srcChars.
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& insert(int32_t start,
          ConstChar16Ptr srcChars,
          int32_t srcLength);

/**
 * Insert the code unit `srcChar` into the UnicodeString object at
 * offset `start`.
 * @param start the offset at which the insertion occurs
 * @param srcChar the code unit to insert
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& insert(int32_t start,
          char16_t srcChar);

/**
 * Insert the code point `srcChar` into the UnicodeString object at
 * offset `start`.
 * @param start the offset at which the insertion occurs
 * @param srcChar the code point to insert
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& insert(int32_t start,
          UChar32 srcChar);


/* Replace operations */

/**
 * Replace the characters in the range
 * [`start`, `start + length`) with the characters in
 * `srcText` in the range
 * [`srcStart`, `srcStart + srcLength`).
 * `srcText` is not modified.
 * @param start the offset at which the replace operation begins
 * @param length the number of characters to replace. The character at
 * `start + length` is not modified.
 * @param srcText the source for the new characters
 * @param srcStart the offset into `srcText` where new characters
 * will be obtained
 * @param srcLength the number of characters in `srcText` in
 * the replace string
 * @return a reference to this
 * @stable ICU 2.0
 */
inline 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`.  `srcText` is
 *  not modified.
 * @param start the offset at which the replace operation begins
 * @param length the number of characters to replace. The character at
 * `start + length` is not modified.
 * @param srcText the source for the new characters
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& replace(int32_t start,
           int32_t length,
           const UnicodeString& srcText);

/**
 * Replace the characters in the range
 * [`start`, `start + length`) with the characters in
 * `srcChars` in the range
 * [`srcStart`, `srcStart + srcLength`). `srcChars`
 * is not modified.
 * @param start the offset at which the replace operation begins
 * @param length the number of characters to replace.  The character at
 * `start + length` is not modified.
 * @param srcChars the source for the new characters
 * @param srcStart the offset into `srcChars` where new characters
 * will be obtained
 * @param srcLength the number of characters in `srcChars`
 * in the replace string
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& replace(int32_t start,
           int32_t length,
           const char16_t *srcChars,
           int32_t srcStart,
           int32_t srcLength);

/**
 * Replace the characters in the range
 * [`start`, `start + length`) with the characters in
 * `srcChars`.  `srcChars` is not modified.
 * @param start the offset at which the replace operation begins
 * @param length number of characters to replace.  The character at
 * `start + length` is not modified.
 * @param srcChars the source for the new characters
 * @param srcLength the number of Unicode characters in srcChars
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& replace(int32_t start,
           int32_t length,
           ConstChar16Ptr srcChars,
           int32_t srcLength);

/**
 * Replace the characters in the range
 * [`start`, `start + length`) with the code unit
 * `srcChar`.
 * @param start the offset at which the replace operation begins
 * @param length the number of characters to replace.  The character at
 * `start + length` is not modified.
 * @param srcChar the new code unit
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& replace(int32_t start,
           int32_t length,
           char16_t srcChar);

/**
 * Replace the characters in the range
 * [`start`, `start + length`) with the code point
 * `srcChar`.
 * @param start the offset at which the replace operation begins
 * @param length the number of characters to replace.  The character at
 * `start + length` is not modified.
 * @param srcChar the new code point
 * @return a reference to this
 * @stable ICU 2.0
 */
UnicodeString& replace(int32_t start, int32_t length, UChar32 srcChar);

/**
 * Replace the characters in the range [`start`, `limit`)
 * with the characters in `srcText`. `srcText` is not modified.
 * @param start the offset at which the replace operation begins
 * @param limit the offset immediately following the replace range
 * @param srcText the source for the new characters
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& replaceBetween(int32_t start,
              int32_t limit,
              const UnicodeString& srcText);

/**
 * Replace the characters in the range [`start`, `limit`)
 * with the characters in `srcText` in the range
 * [`srcStart`, `srcLimit`). `srcText` is not modified.
 * @param start the offset at which the replace operation begins
 * @param limit the offset immediately following the replace range
 * @param srcText the source for the new characters
 * @param srcStart the offset into `srcChars` where new characters
 * will be obtained
 * @param srcLimit the offset immediately following the range to copy
 * in `srcText`
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& replaceBetween(int32_t start,
              int32_t limit,
              const UnicodeString& srcText,
              int32_t srcStart,
              int32_t srcLimit);

/**
 * Replace a substring of this object with the given text.
 * @param start the beginning index, inclusive; `0 <= start <= limit`.
 * @param limit the ending index, exclusive; `start <= limit <= length()`.
 * @param text the text to replace characters `start` to `limit - 1`
 * @stable ICU 2.0
 */
virtual void handleReplaceBetween(int32_t start,
                                  int32_t limit,
                                  const UnicodeString& text) override;

/**
 * Replaceable API
 * @return true if it has MetaData
 * @stable ICU 2.4
 */
virtual UBool hasMetaData() const override;

/**
 * Copy a substring of this object, retaining attribute (out-of-band)
 * information.  This method is used to duplicate or reorder substrings.
 * The destination index must not overlap the source range.
 *
 * @param start the beginning index, inclusive; `0 <= start <= limit`.
 * @param limit the ending index, exclusive; `start <= limit <= length()`.
 * @param dest the destination index.  The characters from
 *             `start..limit-1` will be copied to `dest`.
 * Implementations of this method may assume that `dest <= start ||
 * dest >= limit`.
 * @stable ICU 2.0
 */
virtual void copy(int32_t start, int32_t limit, int32_t dest) override;

/* Search and replace operations */

/**
 * Replace all occurrences of characters in oldText with the characters
 * in newText
 * @param oldText the text containing the search text
 * @param newText the text containing the replacement text
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& findAndReplace(const UnicodeString& oldText,
              const UnicodeString& newText);

/**
 * Replace all occurrences of characters in oldText with characters
 * in newText
 * in the range [`start`, `start + length`).
 * @param start the start of the range in which replace will performed
 * @param length the length of the range in which replace will be performed
 * @param oldText the text containing the search text
 * @param newText the text containing the replacement text
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& findAndReplace(int32_t start,
              int32_t length,
              const UnicodeString& oldText,
              const UnicodeString& newText);

/**
 * Replace all occurrences of characters in oldText in the range
 * [`oldStart`, `oldStart + oldLength`) with the characters
 * in newText in the range
 * [`newStart`, `newStart + newLength`)
 * in the range [`start`, `start + length`).
 * @param start the start of the range in which replace will performed
 * @param length the length of the range in which replace will be performed
 * @param oldText the text containing the search text
 * @param oldStart the start of the search range in `oldText`
 * @param oldLength the length of the search range in `oldText`
 * @param newText the text containing the replacement text
 * @param newStart the start of the replacement range in `newText`
 * @param newLength the length of the replacement range in `newText`
 * @return a reference to this
 * @stable ICU 2.0
 */
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);


/* Remove operations */

/**
 * Removes all characters from the UnicodeString object and clears the bogus flag.
 * This is the UnicodeString equivalent of std::string’s clear().
 *
 * @return a reference to this
 * @see setToBogus
 * @stable ICU 2.0
 */
inline UnicodeString& remove();

/**
 * Remove the characters in the range
 * [`start`, `start + length`) from the UnicodeString object.
 * @param start the offset of the first character to remove
 * @param length the number of characters to remove
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& remove(int32_t start,
                             int32_t length = (int32_t)INT32_MAX(2147483647));

/**
 * Remove the characters in the range
 * [`start`, `limit`) from the UnicodeString object.
 * @param start the offset of the first character to remove
 * @param limit the offset immediately following the range to remove
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& removeBetween(int32_t start,
                                    int32_t limit = (int32_t)INT32_MAX(2147483647));

/**
 * Retain only the characters in the range
 * [`start`, `limit`) from the UnicodeString object.
 * Removes characters before `start` and at and after `limit`.
 * @param start the offset of the first character to retain
 * @param limit the offset immediately following the range to retain
 * @return a reference to this
 * @stable ICU 4.4
 */
inline UnicodeString &retainBetween(int32_t start, int32_t limit = INT32_MAX(2147483647));

/* Length operations */

/**
 * Pad the start of this UnicodeString with the character `padChar`.
 * If the length of this UnicodeString is less than targetLength,
 * length() - targetLength copies of padChar will be added to the
 * beginning of this UnicodeString.
 * @param targetLength the desired length of the string
 * @param padChar the character to use for padding. Defaults to
 * space (U+0020)
 * @return true if the text was padded, false otherwise.
 * @stable ICU 2.0
 */
UBool padLeading(int32_t targetLength,
                  char16_t padChar = 0x0020);

/**
 * Pad the end of this UnicodeString with the character `padChar`.
 * If the length of this UnicodeString is less than targetLength,
 * length() - targetLength copies of padChar will be added to the
 * end of this UnicodeString.
 * @param targetLength the desired length of the string
 * @param padChar the character to use for padding. Defaults to
 * space (U+0020)
 * @return true if the text was padded, false otherwise.
 * @stable ICU 2.0
 */
UBool padTrailing(int32_t targetLength,
                   char16_t padChar = 0x0020);

/**
 * Truncate this UnicodeString to the `targetLength`.
 * @param targetLength the desired length of this UnicodeString.
 * @return true if the text was truncated, false otherwise
 * @stable ICU 2.0
 */
inline UBool truncate(int32_t targetLength);

/**
 * Trims leading and trailing whitespace from this UnicodeString.
 * @return a reference to this
 * @stable ICU 2.0
 */
UnicodeString& trim(void);


/* Miscellaneous operations */

/**
 * Reverse this UnicodeString in place.
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& reverse(void);

/**
 * Reverse the range [`start`, `start + length`) in
 * this UnicodeString.
 * @param start the start of the range to reverse
 * @param length the number of characters to to reverse
 * @return a reference to this
 * @stable ICU 2.0
 */
inline UnicodeString& reverse(int32_t start,
           int32_t length);

/**
 * Convert the characters in this to UPPER CASE following the conventions of
 * the default locale.
 * @return A reference to this.
 * @stable ICU 2.0
 */
UnicodeString& toUpper(void);

/**
 * Convert the characters in this to UPPER CASE following the conventions of
 * a specific locale.
 * @param locale The locale containing the conventions to use.
 * @return A reference to this.
 * @stable ICU 2.0
 */
UnicodeString& toUpper(const Locale& locale);

/**
 * Convert the characters in this to lower case following the conventions of
 * the default locale.
 * @return A reference to this.
 * @stable ICU 2.0
 */
UnicodeString& toLower(void);

/**
 * Convert the characters in this to lower case following the conventions of
 * a specific locale.
 * @param locale The locale containing the conventions to use.
 * @return A reference to this.
 * @stable ICU 2.0
 */
UnicodeString& toLower(const Locale& locale);

2684#if !UCONFIG_NO_BREAK_ITERATION0

/**
 * Titlecase this string, convenience function using the default locale.
 *
 * Casing is locale-dependent and context-sensitive.
 * Titlecasing uses a break iterator to find the first characters of words
 * that are to be titlecased. It titlecases those characters and lowercases
 * all others.
 *
 * The titlecase break iterator can be provided to customize for arbitrary
 * styles, using rules and dictionaries beyond the standard iterators.
 * It may be more efficient to always provide an iterator to avoid
 * opening and closing one for each string.
 * The standard titlecase iterator for the root locale implements the
 * algorithm of Unicode TR 21.
 *
 * This function uses only the setText(), first() and next() methods of the
 * provided break iterator.
 *
 * @param titleIter A break iterator to find the first characters of words
 *                  that are to be titlecased.
 *                  If none is provided (0), then a standard titlecase
 *                  break iterator is opened.
 *                  Otherwise the provided iterator is set to the string's text.
 * @return A reference to this.
 * @stable ICU 2.1
 */
UnicodeString &toTitle(BreakIterator *titleIter);

/**
 * Titlecase this string.
 *
 * Casing is locale-dependent and context-sensitive.
 * Titlecasing uses a break iterator to find the first characters of words
 * that are to be titlecased. It titlecases those characters and lowercases
 * all others.
 *
 * The titlecase break iterator can be provided to customize for arbitrary
 * styles, using rules and dictionaries beyond the standard iterators.
 * It may be more efficient to always provide an iterator to avoid
 * opening and closing one for each string.
 * The standard titlecase iterator for the root locale implements the
 * algorithm of Unicode TR 21.
 *
 * This function uses only the setText(), first() and next() methods of the
 * provided break iterator.
 *
 * @param titleIter A break iterator to find the first characters of words
 *                  that are to be titlecased.
 *                  If none is provided (0), then a standard titlecase
 *                  break iterator is opened.
 *                  Otherwise the provided iterator is set to the string's text.
 * @param locale    The locale to consider.
 * @return A reference to this.
 * @stable ICU 2.1
 */
UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale);

/**
 * Titlecase this string, with options.
 *
 * Casing is locale-dependent and context-sensitive.
 * Titlecasing uses a break iterator to find the first characters of words
 * that are to be titlecased. It titlecases those characters and lowercases
 * all others. (This can be modified with options.)
 *
 * The titlecase break iterator can be provided to customize for arbitrary
 * styles, using rules and dictionaries beyond the standard iterators.
 * It may be more efficient to always provide an iterator to avoid
 * opening and closing one for each string.
 * The standard titlecase iterator for the root locale implements the
 * algorithm of Unicode TR 21.
 *
 * This function uses only the setText(), first() and next() methods of the
 * provided break iterator.
 *
 * @param titleIter A break iterator to find the first characters of words
 *                  that are to be titlecased.
 *                  If none is provided (0), then a standard titlecase
 *                  break iterator is opened.
 *                  Otherwise the provided iterator is set to the string's text.
 * @param locale    The locale to consider.
 * @param options   Options bit set, usually 0. See U_TITLECASE_NO_LOWERCASE,
 *                  U_TITLECASE_NO_BREAK_ADJUSTMENT, U_TITLECASE_ADJUST_TO_CASED,
 *                  U_TITLECASE_WHOLE_STRING, U_TITLECASE_SENTENCES.
 * @return A reference to this.
 * @stable ICU 3.8
 */
UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale, uint32_t options);

2775#endif

/**
 * Case-folds the characters in this string.
 *
 * Case-folding is locale-independent and not context-sensitive,
 * but there is an option for whether to include or exclude mappings for dotted I
 * and dotless i that are marked with 'T' in CaseFolding.txt.
 *
 * The result may be longer or shorter than the original.
 *
 * @param options Either U_FOLD_CASE_DEFAULT or U_FOLD_CASE_EXCLUDE_SPECIAL_I
 * @return A reference to this.
 * @stable ICU 2.0
 */
UnicodeString &foldCase(uint32_t options=0 /*U_FOLD_CASE_DEFAULT*/);

//========================================
// Access to the internal buffer
//========================================

/**
 * Get a read/write pointer to the internal buffer.
 * The buffer is guaranteed to be large enough for at least minCapacity char16_ts,
 * writable, and is still owned by the UnicodeString object.
 * Calls to getBuffer(minCapacity) must not be nested, and
 * must be matched with calls to releaseBuffer(newLength).
 * If the string buffer was read-only or shared,
 * then it will be reallocated and copied.
 *
 * An attempted nested call will return 0, and will not further modify the
 * state of the UnicodeString object.
 * It also returns 0 if the string is bogus.
 *
 * The actual capacity of the string buffer may be larger than minCapacity.
 * getCapacity() returns the actual capacity.
 * For many operations, the full capacity should be used to avoid reallocations.
 *
 * While the buffer is "open" between getBuffer(minCapacity)
 * and releaseBuffer(newLength), the following applies:
 * - The string length is set to 0.
 * - Any read API call on the UnicodeString object will behave like on a 0-length string.
 * - Any write API call on the UnicodeString object is disallowed and will have no effect.
 * - You can read from and write to the returned buffer.
 * - The previous string contents will still be in the buffer;
 *   if you want to use it, then you need to call length() before getBuffer(minCapacity).
 *   If the length() was greater than minCapacity, then any contents after minCapacity
 *   may be lost.
 *   The buffer contents is not NUL-terminated by getBuffer().
 *   If length() < getCapacity() then you can terminate it by writing a NUL
 *   at index length().
 * - You must call releaseBuffer(newLength) before and in order to
 *   return to normal UnicodeString operation.
 *
 * @param minCapacity the minimum number of char16_ts that are to be available
 *        in the buffer, starting at the returned pointer;
 *        default to the current string capacity if minCapacity==-1
 * @return a writable pointer to the internal string buffer,
 *         or nullptr if an error occurs (nested calls, out of memory)
 *
 * @see releaseBuffer
 * @see getTerminatedBuffer()
 * @stable ICU 2.0
 */
char16_t *getBuffer(int32_t minCapacity);

/**
 * Release a read/write buffer on a UnicodeString object with an
 * "open" getBuffer(minCapacity).
 * This function must be called in a matched pair with getBuffer(minCapacity).
 * releaseBuffer(newLength) must be called if and only if a getBuffer(minCapacity) is "open".
 *
 * It will set the string length to newLength, at most to the current capacity.
 * If newLength==-1 then it will set the length according to the
 * first NUL in the buffer, or to the capacity if there is no NUL.
 *
 * After calling releaseBuffer(newLength) the UnicodeString is back to normal operation.
 *
 * @param newLength the new length of the UnicodeString object;
 *        defaults to the current capacity if newLength is greater than that;
 *        if newLength==-1, it defaults to u_strlen(buffer) but not more than
 *        the current capacity of the string
 *
 * @see getBuffer(int32_t minCapacity)
 * @stable ICU 2.0
 */
void releaseBuffer(int32_t newLength=-1);

/**
 * Get a read-only pointer to the internal buffer.
 * This can be called at any time on a valid UnicodeString.
 *
 * It returns 0 if the string is bogus, or
 * during an "open" getBuffer(minCapacity).
 *
 * It can be called as many times as desired.
 * The pointer that it returns will remain valid until the UnicodeString object is modified,
 * at which time the pointer is semantically invalidated and must not be used any more.
 *
 * The capacity of the buffer can be determined with getCapacity().
 * The part after length() may or may not be initialized and valid,
 * depending on the history of the UnicodeString object.
 *
 * The buffer contents is (probably) not NUL-terminated.
 * You can check if it is with
 * `(s.length() < s.getCapacity() && buffer[s.length()]==0)`.
 * (See getTerminatedBuffer().)
 *
 * The buffer may reside in read-only memory. Its contents must not
 * be modified.
 *
 * @return a read-only pointer to the internal string buffer,
 *         or nullptr if the string is empty or bogus
 *
 * @see getBuffer(int32_t minCapacity)
 * @see getTerminatedBuffer()
 * @stable ICU 2.0
 */
inline const char16_t *getBuffer() const;

/**
 * Get a read-only pointer to the internal buffer,
 * making sure that it is NUL-terminated.
 * This can be called at any time on a valid UnicodeString.
 *
 * It returns 0 if the string is bogus, or
 * during an "open" getBuffer(minCapacity), or if the buffer cannot
 * be NUL-terminated (because memory allocation failed).
 *
 * It can be called as many times as desired.
 * The pointer that it returns will remain valid until the UnicodeString object is modified,
 * at which time the pointer is semantically invalidated and must not be used any more.
 *
 * The capacity of the buffer can be determined with getCapacity().
 * The part after length()+1 may or may not be initialized and valid,
 * depending on the history of the UnicodeString object.
 *
 * The buffer contents is guaranteed to be NUL-terminated.
 * getTerminatedBuffer() may reallocate the buffer if a terminating NUL
 * is written.
 * For this reason, this function is not const, unlike getBuffer().
 * Note that a UnicodeString may also contain NUL characters as part of its contents.
 *
 * The buffer may reside in read-only memory. Its contents must not
 * be modified.
 *
 * @return a read-only pointer to the internal string buffer,
 *         or 0 if the string is empty or bogus
 *
 * @see getBuffer(int32_t minCapacity)
 * @see getBuffer()
 * @stable ICU 2.2
 */
const char16_t *getTerminatedBuffer();

//========================================
// Constructors
//========================================

/** Construct an empty UnicodeString.
 * @stable ICU 2.0
 */
inline UnicodeString();

/**
 * Construct a UnicodeString with capacity to hold `capacity` char16_ts
 * @param capacity the number of char16_ts this UnicodeString should hold
 * before a resize is necessary; if count is greater than 0 and count
 * code points c take up more space than capacity, then capacity is adjusted
 * accordingly.
 * @param c is used to initially fill the string
 * @param count specifies how many code points c are to be written in the
 *              string
 * @stable ICU 2.0
 */
UnicodeString(int32_t capacity, UChar32 c, int32_t count);

/**
 * Single char16_t (code unit) constructor.
 *
 * It is recommended to mark this constructor "explicit" by
 * `-DUNISTR_FROM_CHAR_EXPLICIT=explicit`
 * on the compiler command line or similar.
 * @param ch the character to place in the UnicodeString
 * @stable ICU 2.0
 */
UNISTR_FROM_CHAR_EXPLICITexplicit UnicodeString(char16_t ch);

/**
 * Single UChar32 (code point) constructor.
 *
 * It is recommended to mark this constructor "explicit" by
 * `-DUNISTR_FROM_CHAR_EXPLICIT=explicit`
 * on the compiler command line or similar.
 * @param ch the character to place in the UnicodeString
 * @stable ICU 2.0
 */
UNISTR_FROM_CHAR_EXPLICITexplicit UnicodeString(UChar32 ch);

/**
 * char16_t* constructor.
 *
 * It is recommended to mark this constructor "explicit" by
 * `-DUNISTR_FROM_STRING_EXPLICIT=explicit`
 * on the compiler command line or similar.
 * @param text The characters to place in the UnicodeString.  `text`
 * must be NULL (U+0000) terminated.
 * @stable ICU 2.0
 */
UNISTR_FROM_STRING_EXPLICITexplicit UnicodeString(const char16_t *text);

2986#if !U_CHAR16_IS_TYPEDEF0
/**
 * uint16_t * constructor.
 * Delegates to UnicodeString(const char16_t *).
 *
 * It is recommended to mark this constructor "explicit" by
 * `-DUNISTR_FROM_STRING_EXPLICIT=explicit`
 * on the compiler command line or similar.
 * @param text NUL-terminated UTF-16 string
 * @stable ICU 59
 */
UNISTR_FROM_STRING_EXPLICITexplicit UnicodeString(const uint16_t *text) :
    UnicodeString(ConstChar16Ptr(text)) {}
2999#endif

3001#if U_SIZEOF_WCHAR_T4==2 || defined(U_IN_DOXYGEN)
/**
 * wchar_t * constructor.
 * (Only defined if U_SIZEOF_WCHAR_T==2.)
 * Delegates to UnicodeString(const char16_t *).
 *
 * It is recommended to mark this constructor "explicit" by
 * `-DUNISTR_FROM_STRING_EXPLICIT=explicit`
 * on the compiler command line or similar.
 * @param text NUL-terminated UTF-16 string
 * @stable ICU 59
 */
UNISTR_FROM_STRING_EXPLICITexplicit UnicodeString(const wchar_t *text) :
    UnicodeString(ConstChar16Ptr(text)) {}
3015#endif

/**
 * nullptr_t constructor.
 * Effectively the same as the default constructor, makes an empty string object.
 *
 * It is recommended to mark this constructor "explicit" by
 * `-DUNISTR_FROM_STRING_EXPLICIT=explicit`
 * on the compiler command line or similar.
 * @param text nullptr
 * @stable ICU 59
 */
UNISTR_FROM_STRING_EXPLICITexplicit inline UnicodeString(const std::nullptr_t text);

/**
 * char16_t* constructor.
 * @param text The characters to place in the UnicodeString.
 * @param textLength The number of Unicode characters in `text`
 * to copy.
 * @stable ICU 2.0
 */
UnicodeString(const char16_t *text,
      int32_t textLength);

3039#if !U_CHAR16_IS_TYPEDEF0
/**
 * uint16_t * constructor.
 * Delegates to UnicodeString(const char16_t *, int32_t).
 * @param text UTF-16 string
 * @param textLength string length
 * @stable ICU 59
 */
UnicodeString(const uint16_t *text, int32_t textLength) :
    UnicodeString(ConstChar16Ptr(text), textLength) {}
3049#endif

3051#if U_SIZEOF_WCHAR_T4==2 || defined(U_IN_DOXYGEN)
/**
 * wchar_t * constructor.
 * (Only defined if U_SIZEOF_WCHAR_T==2.)
 * Delegates to UnicodeString(const char16_t *, int32_t).
 * @param text NUL-terminated UTF-16 string
 * @param textLength string length
 * @stable ICU 59
 */
UnicodeString(const wchar_t *text, int32_t textLength) :
    UnicodeString(ConstChar16Ptr(text), textLength) {}
3062#endif

/**
 * nullptr_t constructor.
 * Effectively the same as the default constructor, makes an empty string object.
 * @param text nullptr
 * @param textLength ignored
 * @stable ICU 59
 */
inline UnicodeString(const std::nullptr_t text, int32_t textLength);

/**
 * Readonly-aliasing char16_t* constructor.
 * The text will be used for the UnicodeString object, but
 * it will not be released when the UnicodeString is destroyed.
 * This has copy-on-write semantics:
 * When the string is modified, then the buffer is first copied into
 * newly allocated memory.
 * The aliased buffer is never modified.
 *
 * In an assignment to another UnicodeString, when using the copy constructor
 * or the assignment operator, the text will be copied.
 * When using fastCopyFrom(), the text will be aliased again,
 * so that both strings then alias the same readonly-text.
 *
 * @param isTerminated specifies if `text` is `NUL`-terminated.
 *                     This must be true if `textLength==-1`.
 * @param text The characters to alias for the UnicodeString.
 * @param textLength The number of Unicode characters in `text` to alias.
 *                   If -1, then this constructor will determine the length
 *                   by calling `u_strlen()`.
 * @stable ICU 2.0
 */
UnicodeString(UBool isTerminated,
              ConstChar16Ptr text,
              int32_t textLength);

/**
 * Writable-aliasing char16_t* constructor.
 * The text will be used for the UnicodeString object, but
 * it will not be released when the UnicodeString is destroyed.
 * This has write-through semantics:
 * For as long as the capacity of the buffer is sufficient, write operations
 * will directly affect the buffer. When more capacity is necessary, then
 * a new buffer will be allocated and the contents copied as with regularly
 * constructed strings.
 * In an assignment to another UnicodeString, the buffer will be copied.
 * The extract(Char16Ptr dst) function detects whether the dst pointer is the same
 * as the string buffer itself and will in this case not copy the contents.
 *
 * @param buffer The characters to alias for the UnicodeString.
 * @param buffLength The number of Unicode characters in `buffer` to alias.
 * @param buffCapacity The size of `buffer` in char16_ts.
 * @stable ICU 2.0
 */
UnicodeString(char16_t *buffer, int32_t buffLength, int32_t buffCapacity);

3119#if !U_CHAR16_IS_TYPEDEF0
/**
 * Writable-aliasing uint16_t * constructor.
 * Delegates to UnicodeString(const char16_t *, int32_t, int32_t).
 * @param buffer writable buffer of/for UTF-16 text
 * @param buffLength length of the current buffer contents
 * @param buffCapacity buffer capacity
 * @stable ICU 59
 */
UnicodeString(uint16_t *buffer, int32_t buffLength, int32_t buffCapacity) :
    UnicodeString(Char16Ptr(buffer), buffLength, buffCapacity) {}
3130#endif

3132#if U_SIZEOF_WCHAR_T4==2 || defined(U_IN_DOXYGEN)
/**
 * Writable-aliasing wchar_t * constructor.
 * (Only defined if U_SIZEOF_WCHAR_T==2.)
 * Delegates to UnicodeString(const char16_t *, int32_t, int32_t).
 * @param buffer writable buffer of/for UTF-16 text
 * @param buffLength length of the current buffer contents
 * @param buffCapacity buffer capacity
 * @stable ICU 59
 */
UnicodeString(wchar_t *buffer, int32_t buffLength, int32_t buffCapacity) :
    UnicodeString(Char16Ptr(buffer), buffLength, buffCapacity) {}
3144#endif

/**
 * Writable-aliasing nullptr_t constructor.
 * Effectively the same as the default constructor, makes an empty string object.
 * @param buffer nullptr
 * @param buffLength ignored
 * @param buffCapacity ignored
 * @stable ICU 59
 */
inline UnicodeString(std::nullptr_t buffer, int32_t buffLength, int32_t buffCapacity);

3156#if U_CHARSET_IS_UTF81 || !UCONFIG_NO_CONVERSION0

/**
 * char* constructor.
 * Uses the default converter (and thus depends on the ICU conversion code)
 * unless U_CHARSET_IS_UTF8 is set to 1.
 *
 * For ASCII (really "invariant character") strings it is more efficient to use
 * the constructor that takes a US_INV (for its enum EInvariant).
 * For ASCII (invariant-character) string literals, see UNICODE_STRING and
 * UNICODE_STRING_SIMPLE.
 *
 * It is recommended to mark this constructor "explicit" by
 * `-DUNISTR_FROM_STRING_EXPLICIT=explicit`
 * on the compiler command line or similar.
 * @param codepageData an array of bytes, null-terminated,
 *                     in the platform's default codepage.
 * @stable ICU 2.0
 * @see UNICODE_STRING
 * @see UNICODE_STRING_SIMPLE
 */
UNISTR_FROM_STRING_EXPLICITexplicit UnicodeString(const char *codepageData);

/**
 * char* constructor.
 * Uses the default converter (and thus depends on the ICU conversion code)
 * unless U_CHARSET_IS_UTF8 is set to 1.
 * @param codepageData an array of bytes in the platform's default codepage.
 * @param dataLength The number of bytes in `codepageData`.
 * @stable ICU 2.0
 */
UnicodeString(const char *codepageData, int32_t dataLength);

3189#endif

3191#if !UCONFIG_NO_CONVERSION0

/**
 * char* constructor.
 * @param codepageData an array of bytes, null-terminated
 * @param codepage the encoding of `codepageData`.  The special
 * value 0 for `codepage` indicates that the text is in the
 * platform's default codepage.
 *
 * If `codepage` is an empty string (`""`),
 * then a simple conversion is performed on the codepage-invariant
 * subset ("invariant characters") of the platform encoding. See utypes.h.
 * Recommendation: For invariant-character strings use the constructor
 * UnicodeString(const char *src, int32_t length, enum EInvariant inv)
 * because it avoids object code dependencies of UnicodeString on
 * the conversion code.
 *
 * @stable ICU 2.0
 */
UnicodeString(const char *codepageData, const char *codepage);

/**
 * char* constructor.
 * @param codepageData an array of bytes.
 * @param dataLength The number of bytes in `codepageData`.
 * @param codepage the encoding of `codepageData`.  The special
 * value 0 for `codepage` indicates that the text is in the
 * platform's default codepage.
 * If `codepage` is an empty string (`""`),
 * then a simple conversion is performed on the codepage-invariant
 * subset ("invariant characters") of the platform encoding. See utypes.h.
 * Recommendation: For invariant-character strings use the constructor
 * UnicodeString(const char *src, int32_t length, enum EInvariant inv)
 * because it avoids object code dependencies of UnicodeString on
 * the conversion code.
 *
 * @stable ICU 2.0
 */
UnicodeString(const char *codepageData, int32_t dataLength, const char *codepage);

/**
 * char * / UConverter constructor.
 * This constructor uses an existing UConverter object to
 * convert the codepage string to Unicode and construct a UnicodeString
 * from that.
 *
 * The converter is reset at first.
 * If the error code indicates a failure before this constructor is called,
 * or if an error occurs during conversion or construction,
 * then the string will be bogus.
 *
 * This function avoids the overhead of opening and closing a converter if
 * multiple strings are constructed.
 *
 * @param src input codepage string
 * @param srcLength length of the input string, can be -1 for NUL-terminated strings
 * @param cnv converter object (ucnv_resetToUnicode() will be called),
 *        can be NULL for the default converter
 * @param errorCode normal ICU error code
 * @stable ICU 2.0
 */
UnicodeString(
      const char *src, int32_t srcLength,
      UConverter *cnv,
      UErrorCode &errorCode);

3257#endif

/**
 * Constructs a Unicode string from an invariant-character char * string.
 * About invariant characters see utypes.h.
 * This constructor has no runtime dependency on conversion code and is
 * therefore recommended over ones taking a charset name string
 * (where the empty string "" indicates invariant-character conversion).
 *
 * Use the macro US_INV as the third, signature-distinguishing parameter.
 *
 * For example:
 * \code
 *     void fn(const char *s) {
 *       UnicodeString ustr(s, -1, US_INV);
 *       // use ustr ...
 *     }
 * \endcode
 * @param src String using only invariant characters.
 * @param textLength Length of src, or -1 if NUL-terminated.
 * @param inv Signature-distinguishing parameter, use US_INV.
 *
 * @see US_INV
 * @stable ICU 3.2
 */
UnicodeString(const char *src, int32_t textLength, enum EInvariant inv);


/**
 * Copy constructor.
 *
 * Starting with ICU 2.4, the assignment operator and the copy constructor
 * allocate a new buffer and copy the buffer contents even for readonly aliases.
 * By contrast, the fastCopyFrom() function implements the old,
 * more efficient but less safe behavior
 * of making this string also a readonly alias to the same buffer.
 *
 * If the source object has an "open" buffer from getBuffer(minCapacity),
 * then the copy is an empty string.
 *
 * @param that The UnicodeString object to copy.
 * @stable ICU 2.0
 * @see fastCopyFrom
 */
UnicodeString(const UnicodeString& that);

/**
 * Move constructor; might leave src in bogus state.
 * This string will have the same contents and state that the source string had.
 * @param src source string
 * @stable ICU 56
 */
UnicodeString(UnicodeString &&src) U_NOEXCEPTnoexcept;

/**
 * 'Substring' constructor from tail of source string.
 * @param src The UnicodeString object to copy.
 * @param srcStart The offset into `src` at which to start copying.
 * @stable ICU 2.2
 */
UnicodeString(const UnicodeString& src, int32_t srcStart);

/**
 * 'Substring' constructor from subrange of source string.
 * @param src The UnicodeString object to copy.
 * @param srcStart The offset into `src` at which to start copying.
 * @param srcLength The number of characters from `src` to copy.
 * @stable ICU 2.2
 */
UnicodeString(const UnicodeString& src, int32_t srcStart, int32_t srcLength);

/**
 * Clone this object, an instance of a subclass of Replaceable.
 * Clones can be used concurrently in multiple threads.
 * If a subclass does not implement clone(), or if an error occurs,
 * then NULL is returned.
 * The caller must delete the clone.
 *
 * @return a clone of this object
 *
 * @see Replaceable::clone
 * @see getDynamicClassID
 * @stable ICU 2.6
 */
virtual UnicodeString *clone() const override;

/** Destructor.
 * @stable ICU 2.0
 */
virtual ~UnicodeString();

/**
 * Create a UnicodeString from a UTF-8 string.
 * Illegal input is replaced with U+FFFD. Otherwise, errors result in a bogus string.
 * Calls u_strFromUTF8WithSub().
 *
 * @param utf8 UTF-8 input string.
 *             Note that a StringPiece can be implicitly constructed
 *             from a std::string or a NUL-terminated const char * string.
 * @return A UnicodeString with equivalent UTF-16 contents.
 * @see toUTF8
 * @see toUTF8String
 * @stable ICU 4.2
 */
static UnicodeString fromUTF8(StringPiece utf8);

/**
 * Create a UnicodeString from a UTF-32 string.
 * Illegal input is replaced with U+FFFD. Otherwise, errors result in a bogus string.
 * Calls u_strFromUTF32WithSub().
 *
 * @param utf32 UTF-32 input string. Must not be NULL.
 * @param length Length of the input string, or -1 if NUL-terminated.
 * @return A UnicodeString with equivalent UTF-16 contents.
 * @see toUTF32
 * @stable ICU 4.2
 */
static UnicodeString fromUTF32(const UChar32 *utf32, int32_t length);

/* Miscellaneous operations */

/**
 * Unescape a string of characters and return a string containing
 * the result.  The following escape sequences are recognized:
 *
 * \\uhhhh       4 hex digits; h in [0-9A-Fa-f]
 * \\Uhhhhhhhh   8 hex digits
 * \\xhh         1-2 hex digits
 * \\ooo         1-3 octal digits; o in [0-7]
 * \\cX          control-X; X is masked with 0x1F
 *
 * as well as the standard ANSI C escapes:
 *
 * \\a => U+0007, \\b => U+0008, \\t => U+0009, \\n => U+000A,
 * \\v => U+000B, \\f => U+000C, \\r => U+000D, \\e => U+001B,
 * \\" => U+0022, \\' => U+0027, \\? => U+003F, \\\\ => U+005C
 *
 * Anything else following a backslash is generically escaped.  For
 * example, "[a\\-z]" returns "[a-z]".
 *
 * If an escape sequence is ill-formed, this method returns an empty
 * string.  An example of an ill-formed sequence is "\\u" followed by
 * fewer than 4 hex digits.
 *
 * This function is similar to u_unescape() but not identical to it.
 * The latter takes a source char*, so it does escape recognition
 * and also invariant conversion.
 *
 * @return a string with backslash escapes interpreted, or an
 * empty string on error.
 * @see UnicodeString#unescapeAt()
 * @see u_unescape()
 * @see u_unescapeAt()
 * @stable ICU 2.0
 */
UnicodeString unescape() const;

/**
 * Unescape a single escape sequence and return the represented
 * character.  See unescape() for a listing of the recognized escape
 * sequences.  The character at offset-1 is assumed (without
 * checking) to be a backslash.  If the escape sequence is
 * ill-formed, or the offset is out of range, U_SENTINEL=-1 is
 * returned.
 *
 * @param offset an input output parameter.  On input, it is the
 * offset into this string where the escape sequence is located,
 * after the initial backslash.  On output, it is advanced after the
 * last character parsed.  On error, it is not advanced at all.
 * @return the character represented by the escape sequence at
 * offset, or U_SENTINEL=-1 on error.
 * @see UnicodeString#unescape()
 * @see u_unescape()
 * @see u_unescapeAt()
 * @stable ICU 2.0
 */
UChar32 unescapeAt(int32_t &offset) const;

/**
 * ICU "poor man's RTTI", returns a UClassID for this class.
 *
 * @stable ICU 2.2
 */
static UClassID U_EXPORT2 getStaticClassID();

/**
 * ICU "poor man's RTTI", returns a UClassID for the actual class.
 *
 * @stable ICU 2.2
 */
virtual UClassID getDynamicClassID() const override;

//========================================
// Implementation methods
//========================================

3453protected:
/**
 * Implement Replaceable::getLength() (see jitterbug 1027).
 * @stable ICU 2.4
 */
virtual int32_t getLength() const override;

/**
 * The change in Replaceable to use virtual getCharAt() allows
 * UnicodeString::charAt() to be inline again (see jitterbug 709).
 * @stable ICU 2.4
 */
virtual char16_t getCharAt(int32_t offset) const override;

/**
 * The change in Replaceable to use virtual getChar32At() allows
 * UnicodeString::char32At() to be inline again (see jitterbug 709).
 * @stable ICU 2.4
 */
virtual UChar32 getChar32At(int32_t offset) const override;

3474private:
// For char* constructors. Could be made public.
UnicodeString &setToUTF8(StringPiece utf8);
// For extract(char*).
// We could make a toUTF8(target, capacity, errorCode) public but not
// this version: New API will be cleaner if we make callers create substrings
// rather than having start+length on every method,
// and it should take a UErrorCode&.
int32_t
toUTF8(int32_t start, int32_t len,
       char *target, int32_t capacity) const;

/**
 * Internal string contents comparison, called by operator==.
 * Requires: this & text not bogus and have same lengths.
 */
UBool doEquals(const UnicodeString &text, int32_t len) const;

inline int8_t
doCompare(int32_t start,
         int32_t length,
         const UnicodeString& srcText,
         int32_t srcStart,
         int32_t srcLength) const;

int8_t doCompare(int32_t start,
         int32_t length,
         const char16_t *srcChars,
         int32_t srcStart,
         int32_t srcLength) const;

inline int8_t
doCompareCodePointOrder(int32_t start,
                        int32_t length,
                        const UnicodeString& srcText,
                        int32_t srcStart,
                        int32_t srcLength) const;

int8_t doCompareCodePointOrder(int32_t start,
                               int32_t length,
                               const char16_t *srcChars,
                               int32_t srcStart,
                               int32_t srcLength) const;

inline int8_t
doCaseCompare(int32_t start,
              int32_t length,
              const UnicodeString &srcText,
              int32_t srcStart,
              int32_t srcLength,
              uint32_t options) const;

int8_t
doCaseCompare(int32_t start,
              int32_t length,
              const char16_t *srcChars,
              int32_t srcStart,
              int32_t srcLength,
              uint32_t options) const;

int32_t doIndexOf(char16_t c,
          int32_t start,
          int32_t length) const;

int32_t doIndexOf(UChar32 c,
                      int32_t start,
                      int32_t length) const;

int32_t doLastIndexOf(char16_t c,
              int32_t start,
              int32_t length) const;

int32_t doLastIndexOf(UChar32 c,
                          int32_t start,
                          int32_t length) const;

void doExtract(int32_t start,
       int32_t length,
       char16_t *dst,
       int32_t dstStart) const;

inline void doExtract(int32_t start,
       int32_t length,
       UnicodeString& target) const;

inline char16_t doCharAt(int32_t offset)  const;

UnicodeString& doReplace(int32_t start,
             int32_t length,
             const UnicodeString& srcText,
             int32_t srcStart,
             int32_t srcLength);

UnicodeString& doReplace(int32_t start,
             int32_t length,
             const char16_t *srcChars,
             int32_t srcStart,
             int32_t srcLength);

UnicodeString& doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcLength);
UnicodeString& doAppend(const char16_t *srcChars, int32_t srcStart, int32_t srcLength);

UnicodeString& doReverse(int32_t start,
             int32_t length);

// calculate hash code
int32_t doHashCode(void) const;

// get pointer to start of array
// these do not check for kOpenGetBuffer, unlike the public getBuffer() function
inline char16_t* getArrayStart(void);
inline const char16_t* getArrayStart(void) const;

inline UBool hasShortLength() const;
inline int32_t getShortLength() const;

// A UnicodeString object (not necessarily its current buffer)
// is writable unless it isBogus() or it has an "open" getBuffer(minCapacity).
inline UBool isWritable() const;

// Is the current buffer writable?
inline UBool isBufferWritable() const;

// None of the following does releaseArray().
inline void setZeroLength();
inline void setShortLength(int32_t len);
inline void setLength(int32_t len);
inline void setToEmpty();
inline void setArray(char16_t *array, int32_t len, int32_t capacity); // sets length but not flags

// allocate the array; result may be the stack buffer
// sets refCount to 1 if appropriate
// sets fArray, fCapacity, and flags
// sets length to 0
// returns boolean for success or failure
UBool allocate(int32_t capacity);

// release the array if owned
void releaseArray(void);

// turn a bogus string into an empty one
void unBogus();

// implements assignment operator, copy constructor, and fastCopyFrom()
UnicodeString &copyFrom(const UnicodeString &src, UBool fastCopy=false);

// Copies just the fields without memory management.
void copyFieldsFrom(UnicodeString &src, UBool setSrcToBogus) U_NOEXCEPTnoexcept;

// Pin start and limit to acceptable values.
inline void pinIndex(int32_t& start) const;
inline void pinIndices(int32_t& start,
                       int32_t& length) const;

3628#if !UCONFIG_NO_CONVERSION0

/* Internal extract() using UConverter. */
int32_t doExtract(int32_t start, int32_t length,
                  char *dest, int32_t destCapacity,
                  UConverter *cnv,
                  UErrorCode &errorCode) const;

/*
 * Real constructor for converting from codepage data.
 * It assumes that it is called with !fRefCounted.
 *
 * If `codepage==0`, then the default converter
 * is used for the platform encoding.
 * If `codepage` is an empty string (`""`),
 * then a simple conversion is performed on the codepage-invariant
 * subset ("invariant characters") of the platform encoding. See utypes.h.
 */
void doCodepageCreate(const char *codepageData,
                      int32_t dataLength,
                      const char *codepage);

/*
 * Worker function for creating a UnicodeString from
 * a codepage string using a UConverter.
 */
void
doCodepageCreate(const char *codepageData,
                 int32_t dataLength,
                 UConverter *converter,
                 UErrorCode &status);

3660#endif

/*
 * This function is called when write access to the array
 * is necessary.
 *
 * We need to make a copy of the array if
 * the buffer is read-only, or
 * the buffer is refCounted (shared), and refCount>1, or
 * the buffer is too small.
 *
 * Return false if memory could not be allocated.
 */
UBool cloneArrayIfNeeded(int32_t newCapacity = -1,
                          int32_t growCapacity = -1,
                          UBool doCopyArray = true,
                          int32_t **pBufferToDelete = 0,
                          UBool forceClone = false);

/**
 * Common function for UnicodeString case mappings.
 * The stringCaseMapper has the same type UStringCaseMapper
 * as in ustr_imp.h for ustrcase_map().
 */
UnicodeString &
caseMap(int32_t caseLocale, uint32_t options,
3686#if !UCONFIG_NO_BREAK_ITERATION0
        BreakIterator *iter,
3688#endif
        UStringCaseMapper *stringCaseMapper);

// ref counting
void addRef(void);
int32_t removeRef(void);
int32_t refCount(void) const;

// constants
enum {
  /**
   * Size of stack buffer for short strings.
   * Must be at least U16_MAX_LENGTH for the single-code point constructor to work.
   * @see UNISTR_OBJECT_SIZE
   */
  US_STACKBUF_SIZE=(int32_t)(UNISTR_OBJECT_SIZE64-sizeof(void *)-2)/U_SIZEOF_UCHAR2,
  kInvalidUChar=0xffff, // U+FFFF returned by charAt(invalid index)
  kInvalidHashCode=0, // invalid hash code
  kEmptyHashCode=1, // hash code for empty string

  // bit flag values for fLengthAndFlags
  kIsBogus=1,         // this string is bogus, i.e., not valid or NULL
  kUsingStackBuffer=2,// using fUnion.fStackFields instead of fUnion.fFields
  kRefCounted=4,      // there is a refCount field before the characters in fArray
  kBufferIsReadonly=8,// do not write to this buffer
  kOpenGetBuffer=16,  // getBuffer(minCapacity) was called (is "open"),
                      // and releaseBuffer(newLength) must be called
  kAllStorageFlags=0x1f,

  kLengthShift=5,     // remaining 11 bits for non-negative short length, or negative if long
  kLength1=1<<kLengthShift,
  kMaxShortLength=0x3ff,  // max non-negative short length (leaves top bit 0)
  kLengthIsLarge=0xffe0,  // short length < 0, real length is in fUnion.fFields.fLength

  // combined values for convenience
  kShortString=kUsingStackBuffer,
  kLongString=kRefCounted,
  kReadonlyAlias=kBufferIsReadonly,
  kWritableAlias=0
};

friend class UnicodeStringAppendable;

union StackBufferOrFields;        // forward declaration necessary before friend declaration
friend union StackBufferOrFields; // make US_STACKBUF_SIZE visible inside fUnion

/*
 * The following are all the class fields that are stored
 * in each UnicodeString object.
 * Note that UnicodeString has virtual functions,
 * therefore there is an implicit vtable pointer
 * as the first real field.
 * The fields should be aligned such that no padding is necessary.
 * On 32-bit machines, the size should be 32 bytes,
 * on 64-bit machines (8-byte pointers), it should be 40 bytes.
 *
 * We use a hack to achieve this.
 *
 * With at least some compilers, each of the following is forced to
 * a multiple of sizeof(pointer) [the largest field base unit here is a data pointer],
 * rounded up with additional padding if the fields do not already fit that requirement:
 * - sizeof(class UnicodeString)
 * - offsetof(UnicodeString, fUnion)
 * - sizeof(fUnion)
 * - sizeof(fStackFields)
 *
 * We optimize for the longest possible internal buffer for short strings.
 * fUnion.fStackFields begins with 2 bytes for storage flags
 * and the length of relatively short strings,
 * followed by the buffer for short string contents.
 * There is no padding inside fStackFields.
 *
 * Heap-allocated and aliased strings use fUnion.fFields.
 * Both fStackFields and fFields must begin with the same fields for flags and short length,
 * that is, those must have the same memory offsets inside the object,
 * because the flags must be inspected in order to decide which half of fUnion is being used.
 * We assume that the compiler does not reorder the fields.
 *
 * (Padding at the end of fFields is ok:
 * As long as it is no larger than fStackFields, it is not wasted space.)
 *
 * For some of the history of the UnicodeString class fields layout, see
 * - ICU ticket #11551 "longer UnicodeString contents in stack buffer"
 * - ICU ticket #11336 "UnicodeString: recombine stack buffer arrays"
 * - ICU ticket #8322 "why is sizeof(UnicodeString)==48?"
 */
// (implicit) *vtable;
union StackBufferOrFields {
  // fStackFields is used iff (fLengthAndFlags&kUsingStackBuffer) else fFields is used.
  // Each struct of the union must begin with fLengthAndFlags.
  struct {
    int16_t fLengthAndFlags;          // bit fields: see constants above
    char16_t fBuffer[US_STACKBUF_SIZE];  // buffer for short strings
  } fStackFields;
  struct {
    int16_t fLengthAndFlags;          // bit fields: see constants above
    int32_t fLength;    // number of characters in fArray if >127; else undefined
    int32_t fCapacity;  // capacity of fArray (in char16_ts)
    // array pointer last to minimize padding for machines with P128 data model
    // or pointer sizes that are not a power of 2
    char16_t   *fArray;    // the Unicode data
  } fFields;
} fUnion;
3791};

3793/**
* Create a new UnicodeString with the concatenation of two others.
*
* @param s1 The first string to be copied to the new one.
* @param s2 The second string to be copied to the new one, after s1.
* @return UnicodeString(s1).append(s2)
* @stable ICU 2.8
*/
3801U_COMMON_API UnicodeString U_EXPORT2
3802operator+ (const UnicodeString &s1, const UnicodeString &s2);

3804//========================================
3805// Inline members
3806//========================================

3808//========================================
3809// Privates
3810//========================================

3812inline void
3813UnicodeString::pinIndex(int32_t& start) const
3814{
// pin index
if(start < 0) {
  start = 0;
} else if(start > length()) {
  start = length();
}
3821}

3823inline void
3824UnicodeString::pinIndices(int32_t& start,
                        int32_t& _length) const
3826{
// pin indices
int32_t len = length();
if(start < 0) {
  start = 0;
} else if(start > len) {
  start = len;
}
if(_length < 0) {
  _length = 0;
} else if(_length > (len - start)) {
  _length = (len - start);
}
3839}

3841inline char16_t*
3842UnicodeString::getArrayStart() {
return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ?
  fUnion.fStackFields.fBuffer : fUnion.fFields.fArray;
3845}

3847inline const char16_t*
3848UnicodeString::getArrayStart() const {
return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ?
  fUnion.fStackFields.fBuffer : fUnion.fFields.fArray;
3851}

3853//========================================
3854// Default constructor
3855//========================================

3857inline
3858UnicodeString::UnicodeString() {
fUnion.fStackFields.fLengthAndFlags=kShortString;
3860}

3862inline UnicodeString::UnicodeString(const std::nullptr_t /*text*/) {
fUnion.fStackFields.fLengthAndFlags=kShortString;
3864}

3866inline UnicodeString::UnicodeString(const std::nullptr_t /*text*/, int32_t /*length*/) {
fUnion.fStackFields.fLengthAndFlags=kShortString;
3868}

3870inline UnicodeString::UnicodeString(std::nullptr_t /*buffer*/, int32_t /*buffLength*/, int32_t /*buffCapacity*/) {
fUnion.fStackFields.fLengthAndFlags=kShortString;
3872}

3874//========================================
3875// Read-only implementation methods
3876//========================================
3877inline UBool
3878UnicodeString::hasShortLength() const {
return fUnion.fFields.fLengthAndFlags>=0;
3880}

3882inline int32_t
3883UnicodeString::getShortLength() const {
// fLengthAndFlags must be non-negative -> short length >= 0
// and arithmetic or logical shift does not matter.
return fUnion.fFields.fLengthAndFlags>>kLengthShift;
3887}

3889inline int32_t
3890UnicodeString::length() const {
return hasShortLength() ? getShortLength() : fUnion.fFields.fLength;
3892}

3894inline int32_t
3895UnicodeString::getCapacity() const {
return (fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) ?
  US_STACKBUF_SIZE : fUnion.fFields.fCapacity;
3898}

3900inline int32_t
3901UnicodeString::hashCode() const
3902{ return doHashCode(); }

3904inline UBool
3905UnicodeString::isBogus() const
3906{ return (UBool)(fUnion.fFields.fLengthAndFlags & kIsBogus); }

3908inline UBool
3909UnicodeString::isWritable() const
3910{ return (UBool)!(fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kIsBogus)); }

3912inline UBool
3913UnicodeString::isBufferWritable() const
3914{
return (UBool)(
    !(fUnion.fFields.fLengthAndFlags&(kOpenGetBuffer|kIsBogus|kBufferIsReadonly)) &&
    (!(fUnion.fFields.fLengthAndFlags&kRefCounted) || refCount()==1));
3918}

3920inline const char16_t *
3921UnicodeString::getBuffer() const {
if(fUnion.fFields.fLengthAndFlags&(kIsBogus|kOpenGetBuffer)) {
  return nullptr;
} else if(fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) {
  return fUnion.fStackFields.fBuffer;
} else {
  return fUnion.fFields.fArray;
}
3929}

3931//========================================
3932// Read-only alias methods
3933//========================================
3934inline int8_t
3935UnicodeString::doCompare(int32_t start,
            int32_t thisLength,
            const UnicodeString& srcText,
            int32_t srcStart,
            int32_t srcLength) const
3940{
if(srcText.isBogus()) {
  return (int8_t)!isBogus(); // 0 if both are bogus, 1 otherwise
} else {
  srcText.pinIndices(srcStart, srcLength);
  return doCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength);
}
3947}

3949inline bool
3950UnicodeString::operator== (const UnicodeString& text) const
3951{
if(isBogus()) {
  return text.isBogus();
} else {
  int32_t len = length(), textLength = text.length();
  return !text.isBogus() && len == textLength && doEquals(text, len);
}
3958}

3960inline bool
3961UnicodeString::operator!= (const UnicodeString& text) const
3962{ return (! operator==(text)); }

3964inline UBool
3965UnicodeString::operator> (const UnicodeString& text) const
3966{ return doCompare(0, length(), text, 0, text.length()) == 1; }

3968inline UBool
3969UnicodeString::operator< (const UnicodeString& text) const
3970{ return doCompare(0, length(), text, 0, text.length()) == -1; }

3972inline UBool
3973UnicodeString::operator>= (const UnicodeString& text) const
3974{ return doCompare(0, length(), text, 0, text.length()) != -1; }

3976inline UBool
3977UnicodeString::operator<= (const UnicodeString& text) const
3978{ return doCompare(0, length(), text, 0, text.length()) != 1; }

3980inline int8_t
3981UnicodeString::compare(const UnicodeString& text) const
3982{ return doCompare(0, length(), text, 0, text.length()); }

3984inline int8_t
3985UnicodeString::compare(int32_t start,
             int32_t _length,
             const UnicodeString& srcText) const
3988{ return doCompare(start, _length, srcText, 0, srcText.length()); }

3990inline int8_t
3991UnicodeString::compare(ConstChar16Ptr srcChars,
             int32_t srcLength) const
3993{ return doCompare(0, length(), srcChars, 0, srcLength); }

3995inline int8_t
3996UnicodeString::compare(int32_t start,
             int32_t _length,
             const UnicodeString& srcText,
             int32_t srcStart,
             int32_t srcLength) const
4001{ return doCompare(start, _length, srcText, srcStart, srcLength); }

4003inline int8_t
4004UnicodeString::compare(int32_t start,
             int32_t _length,
             const char16_t *srcChars) const
4007{ return doCompare(start, _length, srcChars, 0, _length); }

4009inline int8_t
4010UnicodeString::compare(int32_t start,
             int32_t _length,
             const char16_t *srcChars,
             int32_t srcStart,
             int32_t srcLength) const
4015{ return doCompare(start, _length, srcChars, srcStart, srcLength); }

4017inline int8_t
4018UnicodeString::compareBetween(int32_t start,
                int32_t limit,
                const UnicodeString& srcText,
                int32_t srcStart,
                int32_t srcLimit) const
4023{ return doCompare(start, limit - start,
         srcText, srcStart, srcLimit - srcStart); }

4026inline int8_t
4027UnicodeString::doCompareCodePointOrder(int32_t start,
                                     int32_t thisLength,
                                     const UnicodeString& srcText,
                                     int32_t srcStart,
                                     int32_t srcLength) const
4032{
if(srcText.isBogus()) {
  return (int8_t)!isBogus(); // 0 if both are bogus, 1 otherwise
} else {
  srcText.pinIndices(srcStart, srcLength);
  return doCompareCodePointOrder(start, thisLength, srcText.getArrayStart(), srcStart, srcLength);
}
4039}

4041inline int8_t
4042UnicodeString::compareCodePointOrder(const UnicodeString& text) const
4043{ return doCompareCodePointOrder(0, length(), text, 0, text.length()); }

4045inline int8_t
4046UnicodeString::compareCodePointOrder(int32_t start,
                                   int32_t _length,
                                   const UnicodeString& srcText) const
4049{ return doCompareCodePointOrder(start, _length, srcText, 0, srcText.length()); }

4051inline int8_t
4052UnicodeString::compareCodePointOrder(ConstChar16Ptr srcChars,
                                   int32_t srcLength) const
4054{ return doCompareCodePointOrder(0, length(), srcChars, 0, srcLength); }

4056inline int8_t
4057UnicodeString::compareCodePointOrder(int32_t start,
                                   int32_t _length,
                                   const UnicodeString& srcText,
                                   int32_t srcStart,
                                   int32_t srcLength) const
4062{ return doCompareCodePointOrder(start, _length, srcText, srcStart, srcLength); }

4064inline int8_t
4065UnicodeString::compareCodePointOrder(int32_t start,
                                   int32_t _length,
                                   const char16_t *srcChars) const
4068{ return doCompareCodePointOrder(start, _length, srcChars, 0, _length); }

4070inline int8_t
4071UnicodeString::compareCodePointOrder(int32_t start,
                                   int32_t _length,
                                   const char16_t *srcChars,
                                   int32_t srcStart,
                                   int32_t srcLength) const
4076{ return doCompareCodePointOrder(start, _length, srcChars, srcStart, srcLength); }

4078inline int8_t
4079UnicodeString::compareCodePointOrderBetween(int32_t start,
                                          int32_t limit,
                                          const UnicodeString& srcText,
                                          int32_t srcStart,
                                          int32_t srcLimit) const
4084{ return doCompareCodePointOrder(start, limit - start,
         srcText, srcStart, srcLimit - srcStart); }

4087inline int8_t
4088UnicodeString::doCaseCompare(int32_t start,
                           int32_t thisLength,
                           const UnicodeString &srcText,
                           int32_t srcStart,
                           int32_t srcLength,
                           uint32_t options) const
4094{
if(srcText.isBogus()) {
  return (int8_t)!isBogus(); // 0 if both are bogus, 1 otherwise
} else {
  srcText.pinIndices(srcStart, srcLength);
  return doCaseCompare(start, thisLength, srcText.getArrayStart(), srcStart, srcLength, options);
}
4101}

4103inline int8_t
4104UnicodeString::caseCompare(const UnicodeString &text, uint32_t options) const {
return doCaseCompare(0, length(), text, 0, text.length(), options);
4106}

4108inline int8_t
4109UnicodeString::caseCompare(int32_t start,
                         int32_t _length,
                         const UnicodeString &srcText,
                         uint32_t options) const {
return doCaseCompare(start, _length, srcText, 0, srcText.length(), options);
4114}

4116inline int8_t
4117UnicodeString::caseCompare(ConstChar16Ptr srcChars,
                         int32_t srcLength,
                         uint32_t options) const {
return doCaseCompare(0, length(), srcChars, 0, srcLength, options);
4121}

4123inline int8_t
4124UnicodeString::caseCompare(int32_t start,
                         int32_t _length,
                         const UnicodeString &srcText,
                         int32_t srcStart,
                         int32_t srcLength,
                         uint32_t options) const {
return doCaseCompare(start, _length, srcText, srcStart, srcLength, options);
4131}

4133inline int8_t
4134UnicodeString::caseCompare(int32_t start,
                         int32_t _length,
                         const char16_t *srcChars,
                         uint32_t options) const {
return doCaseCompare(start, _length, srcChars, 0, _length, options);
4139}

4141inline int8_t
4142UnicodeString::caseCompare(int32_t start,
                         int32_t _length,
                         const char16_t *srcChars,
                         int32_t srcStart,
                         int32_t srcLength,
                         uint32_t options) const {
return doCaseCompare(start, _length, srcChars, srcStart, srcLength, options);
4149}

4151inline int8_t
4152UnicodeString::caseCompareBetween(int32_t start,
                                int32_t limit,
                                const UnicodeString &srcText,
                                int32_t srcStart,
                                int32_t srcLimit,
                                uint32_t options) const {
return doCaseCompare(start, limit - start, srcText, srcStart, srcLimit - srcStart, options);
4159}

4161inline int32_t
4162UnicodeString::indexOf(const UnicodeString& srcText,
             int32_t srcStart,
             int32_t srcLength,
             int32_t start,
             int32_t _length) const
4167{
if(!srcText.isBogus()) {
  srcText.pinIndices(srcStart, srcLength);
  if(srcLength > 0) {
    return indexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
  }
}
return -1;
4175}

4177inline int32_t
4178UnicodeString::indexOf(const UnicodeString& text) const
4179{ return indexOf(text, 0, text.length(), 0, length()); }

4181inline int32_t
4182UnicodeString::indexOf(const UnicodeString& text,
             int32_t start) const {
pinIndex(start);
return indexOf(text, 0, text.length(), start, length() - start);
4186}

4188inline int32_t
4189UnicodeString::indexOf(const UnicodeString& text,
             int32_t start,
             int32_t _length) const
4192{ return indexOf(text, 0, text.length(), start, _length); }

4194inline int32_t
4195UnicodeString::indexOf(const char16_t *srcChars,
             int32_t srcLength,
             int32_t start) const {
pinIndex(start);
return indexOf(srcChars, 0, srcLength, start, length() - start);
4200}

4202inline int32_t
4203UnicodeString::indexOf(ConstChar16Ptr srcChars,
             int32_t srcLength,
             int32_t start,
             int32_t _length) const
4207{ return indexOf(srcChars, 0, srcLength, start, _length); }

4209inline int32_t
4210UnicodeString::indexOf(char16_t c,
             int32_t start,
             int32_t _length) const
4213{ return doIndexOf(c, start, _length); }

4215inline int32_t
4216UnicodeString::indexOf(UChar32 c,
             int32_t start,
             int32_t _length) const
4219{ return doIndexOf(c, start, _length); }

4221inline int32_t
4222UnicodeString::indexOf(char16_t c) const
4223{ return doIndexOf(c, 0, length()); }

4225inline int32_t
4226UnicodeString::indexOf(UChar32 c) const
4227{ return indexOf(c, 0, length()); }

4229inline int32_t
4230UnicodeString::indexOf(char16_t c,
             int32_t start) const {
pinIndex(start);
return doIndexOf(c, start, length() - start);
4234}

4236inline int32_t
4237UnicodeString::indexOf(UChar32 c,
             int32_t start) const {
pinIndex(start);
return indexOf(c, start, length() - start);
4241}

4243inline int32_t
4244UnicodeString::lastIndexOf(ConstChar16Ptr srcChars,
             int32_t srcLength,
             int32_t start,
             int32_t _length) const
4248{ return lastIndexOf(srcChars, 0, srcLength, start, _length); }

4250inline int32_t
4251UnicodeString::lastIndexOf(const char16_t *srcChars,
             int32_t srcLength,
             int32_t start) const {
pinIndex(start);
return lastIndexOf(srcChars, 0, srcLength, start, length() - start);
4256}

4258inline int32_t
4259UnicodeString::lastIndexOf(const UnicodeString& srcText,
             int32_t srcStart,
             int32_t srcLength,
             int32_t start,
             int32_t _length) const
4264{
if(!srcText.isBogus()) {
  srcText.pinIndices(srcStart, srcLength);
  if(srcLength > 0) {
    return lastIndexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
  }
}
return -1;
4272}

4274inline int32_t
4275UnicodeString::lastIndexOf(const UnicodeString& text,
             int32_t start,
             int32_t _length) const
4278{ return lastIndexOf(text, 0, text.length(), start, _length); }

4280inline int32_t
4281UnicodeString::lastIndexOf(const UnicodeString& text,
             int32_t start) const {
pinIndex(start);
return lastIndexOf(text, 0, text.length(), start, length() - start);
4285}

4287inline int32_t
4288UnicodeString::lastIndexOf(const UnicodeString& text) const
4289{ return lastIndexOf(text, 0, text.length(), 0, length()); }

4291inline int32_t
4292UnicodeString::lastIndexOf(char16_t c,
             int32_t start,
             int32_t _length) const
4295{ return doLastIndexOf(c, start, _length); }

4297inline int32_t
4298UnicodeString::lastIndexOf(UChar32 c,
             int32_t start,
             int32_t _length) const {
return doLastIndexOf(c, start, _length);
4302}

4304inline int32_t
4305UnicodeString::lastIndexOf(char16_t c) const
4306{ return doLastIndexOf(c, 0, length()); }

4308inline int32_t
4309UnicodeString::lastIndexOf(UChar32 c) const {
return lastIndexOf(c, 0, length());
4311}

4313inline int32_t
4314UnicodeString::lastIndexOf(char16_t c,
             int32_t start) const {
pinIndex(start);
return doLastIndexOf(c, start, length() - start);
4318}

4320inline int32_t
4321UnicodeString::lastIndexOf(UChar32 c,
             int32_t start) const {
pinIndex(start);
return lastIndexOf(c, start, length() - start);
4325}

4327inline UBool
4328UnicodeString::startsWith(const UnicodeString& text) const
4329{ return compare(0, text.length(), text, 0, text.length()) == 0; }

4331inline UBool
4332UnicodeString::startsWith(const UnicodeString& srcText,
            int32_t srcStart,
            int32_t srcLength) const
4335{ return doCompare(0, srcLength, srcText, srcStart, srcLength) == 0; }

4337inline UBool
4338UnicodeString::startsWith(ConstChar16Ptr srcChars, int32_t srcLength) const {
if(srcLength < 0) {
  srcLength = u_strlenu_strlen_71(toUCharPtr(srcChars));
}
return doCompare(0, srcLength, srcChars, 0, srcLength) == 0;
4343}

4345inline UBool
4346UnicodeString::startsWith(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) const {
if(srcLength < 0) {
  srcLength = u_strlenu_strlen_71(toUCharPtr(srcChars));
}
return doCompare(0, srcLength, srcChars, srcStart, srcLength) == 0;
4351}

4353inline UBool
4354UnicodeString::endsWith(const UnicodeString& text) const
4355{ return doCompare(length() - text.length(), text.length(),
         text, 0, text.length()) == 0; }

4358inline UBool
4359UnicodeString::endsWith(const UnicodeString& srcText,
          int32_t srcStart,
          int32_t srcLength) const {
srcText.pinIndices(srcStart, srcLength);
return doCompare(length() - srcLength, srcLength,
                 srcText, srcStart, srcLength) == 0;
4365}

4367inline UBool
4368UnicodeString::endsWith(ConstChar16Ptr srcChars,
          int32_t srcLength) const {
if(srcLength < 0) {
  srcLength = u_strlenu_strlen_71(toUCharPtr(srcChars));
}
return doCompare(length() - srcLength, srcLength,
                 srcChars, 0, srcLength) == 0;
4375}

4377inline UBool
4378UnicodeString::endsWith(const char16_t *srcChars,
          int32_t srcStart,
          int32_t srcLength) const {
if(srcLength < 0) {
  srcLength = u_strlenu_strlen_71(toUCharPtr(srcChars + srcStart));
}
return doCompare(length() - srcLength, srcLength,
                 srcChars, srcStart, srcLength) == 0;
4386}

4388//========================================
4389// replace
4390//========================================
4391inline UnicodeString&
4392UnicodeString::replace(int32_t start,
             int32_t _length,
             const UnicodeString& srcText)
4395{ return doReplace(start, _length, srcText, 0, srcText.length()); }

4397inline UnicodeString&
4398UnicodeString::replace(int32_t start,
             int32_t _length,
             const UnicodeString& srcText,
             int32_t srcStart,
             int32_t srcLength)
4403{ return doReplace(start, _length, srcText, srcStart, srcLength); }

4405inline UnicodeString&
4406UnicodeString::replace(int32_t start,
             int32_t _length,
             ConstChar16Ptr srcChars,
             int32_t srcLength)
4410{ return doReplace(start, _length, srcChars, 0, srcLength); }

4412inline UnicodeString&
4413UnicodeString::replace(int32_t start,
             int32_t _length,
             const char16_t *srcChars,
             int32_t srcStart,
             int32_t srcLength)
4418{ return doReplace(start, _length, srcChars, srcStart, srcLength); }

4420inline UnicodeString&
4421UnicodeString::replace(int32_t start,
             int32_t _length,
             char16_t srcChar)
4424{ return doReplace(start, _length, &srcChar, 0, 1); }

4426inline UnicodeString&
4427UnicodeString::replaceBetween(int32_t start,
                int32_t limit,
                const UnicodeString& srcText)
4430{ return doReplace(start, limit - start, srcText, 0, srcText.length()); }

4432inline UnicodeString&
4433UnicodeString::replaceBetween(int32_t start,
                int32_t limit,
                const UnicodeString& srcText,
                int32_t srcStart,
                int32_t srcLimit)
4438{ return doReplace(start, limit - start, srcText, srcStart, srcLimit - srcStart); }

4440inline UnicodeString&
4441UnicodeString::findAndReplace(const UnicodeString& oldText,
                const UnicodeString& newText)
4443{ return findAndReplace(0, length(), oldText, 0, oldText.length(),
          newText, 0, newText.length()); }

4446inline UnicodeString&
4447UnicodeString::findAndReplace(int32_t start,
                int32_t _length,
                const UnicodeString& oldText,
                const UnicodeString& newText)
4451{ return findAndReplace(start, _length, oldText, 0, oldText.length(),
          newText, 0, newText.length()); }

4454// ============================
4455// extract
4456// ============================
4457inline void
4458UnicodeString::doExtract(int32_t start,
           int32_t _length,
           UnicodeString& target) const
4461{ target.replace(0, target.length(), *this, start, _length); }

4463inline void
4464UnicodeString::extract(int32_t start,
             int32_t _length,
             Char16Ptr target,
             int32_t targetStart) const
4468{ doExtract(start, _length, target, targetStart); }

4470inline void
4471UnicodeString::extract(int32_t start,
             int32_t _length,
             UnicodeString& target) const
4474{ doExtract(start, _length, target); }

4476#if !UCONFIG_NO_CONVERSION0

4478inline int32_t
4479UnicodeString::extract(int32_t start,
             int32_t _length,
             char *dst,
             const char *codepage) const

4484{
// This dstSize value will be checked explicitly
return extract(start, _length, dst, dst!=0 ? 0xffffffff : 0, codepage);
4487}

4489#endif

4491inline void
4492UnicodeString::extractBetween(int32_t start,
                int32_t limit,
                char16_t *dst,
                int32_t dstStart) const {
pinIndex(start);
pinIndex(limit);
doExtract(start, limit - start, dst, dstStart);
4499}

4501inline UnicodeString
4502UnicodeString::tempSubStringBetween(int32_t start, int32_t limit) const {
  return tempSubString(start, limit - start);
4504}

4506inline char16_t
4507UnicodeString::doCharAt(int32_t offset) const
4508{
if((uint32_t)offset < (uint32_t)length()) {
  return getArrayStart()[offset];
} else {
  return kInvalidUChar;
}
4514}

4516inline char16_t
4517UnicodeString::charAt(int32_t offset) const
4518{ return doCharAt(offset); }

4520inline char16_t
4521UnicodeString::operator[] (int32_t offset) const
4522{ return doCharAt(offset); }

4524inline UBool
4525UnicodeString::isEmpty() const {
// Arithmetic or logical right shift does not matter: only testing for 0.
return (fUnion.fFields.fLengthAndFlags>>kLengthShift) == 0;
4528}

4530//========================================
4531// Write implementation methods
4532//========================================
4533inline void
4534UnicodeString::setZeroLength() {
fUnion.fFields.fLengthAndFlags &= kAllStorageFlags;
4536}

4538inline void
4539UnicodeString::setShortLength(int32_t len) {
// requires 0 <= len <= kMaxShortLength
fUnion.fFields.fLengthAndFlags =
  (int16_t)((fUnion.fFields.fLengthAndFlags & kAllStorageFlags) | (len << kLengthShift));
19
←
The result of the left shift is undefined because the left operand is negative
4543}

4545inline void
4546UnicodeString::setLength(int32_t len) {
if(len15.1
'len' is <= kMaxShortLength
1
'len' is <= kMaxShortLength
 <= kMaxShortLength) {
16
←
Taking true branch→
  setShortLength(len);
17
←
Passing the value -1 via 1st parameter 'len'→
18
←
Calling 'UnicodeString::setShortLength'→
} else {
  fUnion.fFields.fLengthAndFlags |= kLengthIsLarge;
  fUnion.fFields.fLength = len;
}
4553}

4555inline void
4556UnicodeString::setToEmpty() {
fUnion.fFields.fLengthAndFlags = kShortString;
4558}

4560inline void
4561UnicodeString::setArray(char16_t *array, int32_t len, int32_t capacity) {
setLength(len);
fUnion.fFields.fArray = array;
fUnion.fFields.fCapacity = capacity;
4565}

4567inline UnicodeString&
4568UnicodeString::operator= (char16_t ch)
4569{ return doReplace(0, length(), &ch, 0, 1); }

4571inline UnicodeString&
4572UnicodeString::operator= (UChar32 ch)
4573{ return replace(0, length(), ch); }

4575inline UnicodeString&
4576UnicodeString::setTo(const UnicodeString& srcText,
           int32_t srcStart,
           int32_t srcLength)
4579{
unBogus();
return doReplace(0, length(), srcText, srcStart, srcLength);
4582}

4584inline UnicodeString&
4585UnicodeString::setTo(const UnicodeString& srcText,
           int32_t srcStart)
4587{
unBogus();
srcText.pinIndex(srcStart);
return doReplace(0, length(), srcText, srcStart, srcText.length() - srcStart);
4591}

4593inline UnicodeString&
4594UnicodeString::setTo(const UnicodeString& srcText)
4595{
return copyFrom(srcText);
4597}

4599inline UnicodeString&
4600UnicodeString::setTo(const char16_t *srcChars,
           int32_t srcLength)
4602{
unBogus();
return doReplace(0, length(), srcChars, 0, srcLength);
4605}

4607inline UnicodeString&
4608UnicodeString::setTo(char16_t srcChar)
4609{
unBogus();
return doReplace(0, length(), &srcChar, 0, 1);
4612}

4614inline UnicodeString&
4615UnicodeString::setTo(UChar32 srcChar)
4616{
unBogus();
return replace(0, length(), srcChar);
4619}

4621inline UnicodeString&
4622UnicodeString::append(const UnicodeString& srcText,
            int32_t srcStart,
            int32_t srcLength)
4625{ return doAppend(srcText, srcStart, srcLength); }

4627inline UnicodeString&
4628UnicodeString::append(const UnicodeString& srcText)
4629{ return doAppend(srcText, 0, srcText.length()); }

4631inline UnicodeString&
4632UnicodeString::append(const char16_t *srcChars,
            int32_t srcStart,
            int32_t srcLength)
4635{ return doAppend(srcChars, srcStart, srcLength); }

4637inline UnicodeString&
4638UnicodeString::append(ConstChar16Ptr srcChars,
            int32_t srcLength)
4640{ return doAppend(srcChars, 0, srcLength); }

4642inline UnicodeString&
4643UnicodeString::append(char16_t srcChar)
4644{ return doAppend(&srcChar, 0, 1); }

4646inline UnicodeString&
4647UnicodeString::operator+= (char16_t ch)
4648{ return doAppend(&ch, 0, 1); }

4650inline UnicodeString&
4651UnicodeString::operator+= (UChar32 ch) {
return append(ch);
4653}

4655inline UnicodeString&
4656UnicodeString::operator+= (const UnicodeString& srcText)
4657{ return doAppend(srcText, 0, srcText.length()); }

4659inline UnicodeString&
4660UnicodeString::insert(int32_t start,
            const UnicodeString& srcText,
            int32_t srcStart,
            int32_t srcLength)
4664{ return doReplace(start, 0, srcText, srcStart, srcLength); }

4666inline UnicodeString&
4667UnicodeString::insert(int32_t start,
            const UnicodeString& srcText)
4669{ return doReplace(start, 0, srcText, 0, srcText.length()); }

4671inline UnicodeString&
4672UnicodeString::insert(int32_t start,
            const char16_t *srcChars,
            int32_t srcStart,
            int32_t srcLength)
4676{ return doReplace(start, 0, srcChars, srcStart, srcLength); }

4678inline UnicodeString&
4679UnicodeString::insert(int32_t start,
            ConstChar16Ptr srcChars,
            int32_t srcLength)
4682{ return doReplace(start, 0, srcChars, 0, srcLength); }

4684inline UnicodeString&
4685UnicodeString::insert(int32_t start,
            char16_t srcChar)
4687{ return doReplace(start, 0, &srcChar, 0, 1); }

4689inline UnicodeString&
4690UnicodeString::insert(int32_t start,
            UChar32 srcChar)
4692{ return replace(start, 0, srcChar); }


4695inline UnicodeString&
4696UnicodeString::remove()
4697{
// remove() of a bogus string makes the string empty and non-bogus
if(isBogus()) {
  setToEmpty();
} else {
  setZeroLength();
}
return *this;
4705}

4707inline UnicodeString&
4708UnicodeString::remove(int32_t start,
           int32_t _length)
4710{
  if(start <= 0 && _length == INT32_MAX(2147483647)) {
      // remove(guaranteed everything) of a bogus string makes the string empty and non-bogus
      return remove();
  }
  return doReplace(start, _length, NULL__null, 0, 0);
4716}

4718inline UnicodeString&
4719UnicodeString::removeBetween(int32_t start,
              int32_t limit)
4721{ return doReplace(start, limit - start, NULL__null, 0, 0); }

4723inline UnicodeString &
4724UnicodeString::retainBetween(int32_t start, int32_t limit) {
truncate(limit);
return doReplace(0, start, NULL__null, 0, 0);
4727}

4729inline UBool
4730UnicodeString::truncate(int32_t targetLength)
4731{
if(isBogus() && targetLength == 0) {
  // truncate(0) of a bogus string makes the string empty and non-bogus
  unBogus();
  return false;
} else if((uint32_t)targetLength < (uint32_t)length()) {
  setLength(targetLength);
  return true;
} else {
  return false;
}
4742}

4744inline UnicodeString&
4745UnicodeString::reverse()
4746{ return doReverse(0, length()); }

4748inline UnicodeString&
4749UnicodeString::reverse(int32_t start,
             int32_t _length)
4751{ return doReverse(start, _length); }

4753U_NAMESPACE_END}

4755#endif /* U_SHOW_CPLUSPLUS_API */

4757#endif