00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #ifndef UNISTR_H
00022 #define UNISTR_H
00023
00024 #include "unicode/rep.h"
00025
00026 struct UConverter;
00027 class StringThreadTest;
00028
00029 #ifndef U_COMPARE_CODE_POINT_ORDER
00030
00036 #define U_COMPARE_CODE_POINT_ORDER 0x8000
00037 #endif
00038
00039 #ifndef USTRING_H
00040
00041 U_CAPI int32_t U_EXPORT2
00042 u_strlen(const UChar *s);
00043 #endif
00044
00045 U_NAMESPACE_BEGIN
00046
00047 class Locale;
00048 class StringCharacterIterator;
00049 class BreakIterator;
00050
00051
00052
00070 #if U_SIZEOF_WCHAR_T==U_SIZEOF_UCHAR && U_CHARSET_FAMILY==U_ASCII_FAMILY
00071 # define UNICODE_STRING(cs, _length) UnicodeString(TRUE, (const UChar *)L ## cs, _length)
00072 #elif U_SIZEOF_UCHAR==1 && U_CHARSET_FAMILY==U_ASCII_FAMILY
00073 # define UNICODE_STRING(cs, _length) UnicodeString(TRUE, (const UChar *)cs, _length)
00074 #else
00075 # define UNICODE_STRING(cs, _length) UnicodeString(cs, _length, "")
00076 #endif
00077
00091 #if U_SIZEOF_WCHAR_T==U_SIZEOF_UCHAR && U_CHARSET_FAMILY==U_ASCII_FAMILY
00092 # define UNICODE_STRING_SIMPLE(cs) UnicodeString(TRUE, (const UChar *)L ## cs, -1)
00093 #elif U_SIZEOF_UCHAR==1 && U_CHARSET_FAMILY==U_ASCII_FAMILY
00094 # define UNICODE_STRING_SIMPLE(cs) UnicodeString(TRUE, (const UChar *)cs, -1)
00095 #else
00096 # define UNICODE_STRING_SIMPLE(cs) UnicodeString(cs, "")
00097 #endif
00098
00169 class U_COMMON_API UnicodeString : public Replaceable
00170 {
00171 public:
00172
00173
00174
00175
00176
00177
00178
00186 inline UBool operator== (const UnicodeString& text) const;
00187
00195 inline UBool operator!= (const UnicodeString& text) const;
00196
00204 inline UBool operator> (const UnicodeString& text) const;
00205
00213 inline UBool operator< (const UnicodeString& text) const;
00214
00222 inline UBool operator>= (const UnicodeString& text) const;
00223
00231 inline UBool operator<= (const UnicodeString& text) const;
00232
00244 inline int8_t compare(const UnicodeString& text) const;
00245
00260 inline int8_t compare(int32_t start,
00261 int32_t length,
00262 const UnicodeString& srcText) const;
00263
00281 inline int8_t compare(int32_t start,
00282 int32_t length,
00283 const UnicodeString& srcText,
00284 int32_t srcStart,
00285 int32_t srcLength) const;
00286
00299 inline int8_t compare(const UChar *srcChars,
00300 int32_t srcLength) const;
00301
00316 inline int8_t compare(int32_t start,
00317 int32_t length,
00318 const UChar *srcChars) const;
00319
00337 inline int8_t compare(int32_t start,
00338 int32_t length,
00339 const UChar *srcChars,
00340 int32_t srcStart,
00341 int32_t srcLength) const;
00342
00360 inline int8_t compareBetween(int32_t start,
00361 int32_t limit,
00362 const UnicodeString& srcText,
00363 int32_t srcStart,
00364 int32_t srcLimit) const;
00365
00383 inline int8_t compareCodePointOrder(const UnicodeString& text) const;
00384
00404 inline int8_t compareCodePointOrder(int32_t start,
00405 int32_t length,
00406 const UnicodeString& srcText) const;
00407
00429 inline int8_t compareCodePointOrder(int32_t start,
00430 int32_t length,
00431 const UnicodeString& srcText,
00432 int32_t srcStart,
00433 int32_t srcLength) const;
00434
00453 inline int8_t compareCodePointOrder(const UChar *srcChars,
00454 int32_t srcLength) const;
00455
00475 inline int8_t compareCodePointOrder(int32_t start,
00476 int32_t length,
00477 const UChar *srcChars) const;
00478
00500 inline int8_t compareCodePointOrder(int32_t start,
00501 int32_t length,
00502 const UChar *srcChars,
00503 int32_t srcStart,
00504 int32_t srcLength) const;
00505
00527 inline int8_t compareCodePointOrderBetween(int32_t start,
00528 int32_t limit,
00529 const UnicodeString& srcText,
00530 int32_t srcStart,
00531 int32_t srcLimit) const;
00532
00551 inline int8_t caseCompare(const UnicodeString& text, uint32_t options) const;
00552
00573 inline int8_t caseCompare(int32_t start,
00574 int32_t length,
00575 const UnicodeString& srcText,
00576 uint32_t options) const;
00577
00600 inline int8_t caseCompare(int32_t start,
00601 int32_t length,
00602 const UnicodeString& srcText,
00603 int32_t srcStart,
00604 int32_t srcLength,
00605 uint32_t options) const;
00606
00626 inline int8_t caseCompare(const UChar *srcChars,
00627 int32_t srcLength,
00628 uint32_t options) const;
00629
00650 inline int8_t caseCompare(int32_t start,
00651 int32_t length,
00652 const UChar *srcChars,
00653 uint32_t options) const;
00654
00677 inline int8_t caseCompare(int32_t start,
00678 int32_t length,
00679 const UChar *srcChars,
00680 int32_t srcStart,
00681 int32_t srcLength,
00682 uint32_t options) const;
00683
00706 inline int8_t caseCompareBetween(int32_t start,
00707 int32_t limit,
00708 const UnicodeString& srcText,
00709 int32_t srcStart,
00710 int32_t srcLimit,
00711 uint32_t options) const;
00712
00720 inline UBool startsWith(const UnicodeString& text) const;
00721
00732 inline UBool startsWith(const UnicodeString& srcText,
00733 int32_t srcStart,
00734 int32_t srcLength) const;
00735
00744 inline UBool startsWith(const UChar *srcChars,
00745 int32_t srcLength) const;
00746
00756 inline UBool startsWith(const UChar *srcChars,
00757 int32_t srcStart,
00758 int32_t srcLength) const;
00759
00767 inline UBool endsWith(const UnicodeString& text) const;
00768
00779 inline UBool endsWith(const UnicodeString& srcText,
00780 int32_t srcStart,
00781 int32_t srcLength) const;
00782
00791 inline UBool endsWith(const UChar *srcChars,
00792 int32_t srcLength) const;
00793
00804 inline UBool endsWith(const UChar *srcChars,
00805 int32_t srcStart,
00806 int32_t srcLength) const;
00807
00808
00809
00810
00819 inline int32_t indexOf(const UnicodeString& text) const;
00820
00830 inline int32_t indexOf(const UnicodeString& text,
00831 int32_t start) const;
00832
00844 inline int32_t indexOf(const UnicodeString& text,
00845 int32_t start,
00846 int32_t length) const;
00847
00864 inline int32_t indexOf(const UnicodeString& srcText,
00865 int32_t srcStart,
00866 int32_t srcLength,
00867 int32_t start,
00868 int32_t length) const;
00869
00881 inline int32_t indexOf(const UChar *srcChars,
00882 int32_t srcLength,
00883 int32_t start) const;
00884
00897 inline int32_t indexOf(const UChar *srcChars,
00898 int32_t srcLength,
00899 int32_t start,
00900 int32_t length) const;
00901
00918 int32_t indexOf(const UChar *srcChars,
00919 int32_t srcStart,
00920 int32_t srcLength,
00921 int32_t start,
00922 int32_t length) const;
00923
00931 inline int32_t indexOf(UChar c) const;
00932
00941 inline int32_t indexOf(UChar32 c) const;
00942
00951 inline int32_t indexOf(UChar c,
00952 int32_t start) const;
00953
00963 inline int32_t indexOf(UChar32 c,
00964 int32_t start) const;
00965
00976 inline int32_t indexOf(UChar c,
00977 int32_t start,
00978 int32_t length) const;
00979
00991 inline int32_t indexOf(UChar32 c,
00992 int32_t start,
00993 int32_t length) const;
00994
01003 inline int32_t lastIndexOf(const UnicodeString& text) const;
01004
01014 inline int32_t lastIndexOf(const UnicodeString& text,
01015 int32_t start) const;
01016
01028 inline int32_t lastIndexOf(const UnicodeString& text,
01029 int32_t start,
01030 int32_t length) const;
01031
01048 inline int32_t lastIndexOf(const UnicodeString& srcText,
01049 int32_t srcStart,
01050 int32_t srcLength,
01051 int32_t start,
01052 int32_t length) const;
01053
01064 inline int32_t lastIndexOf(const UChar *srcChars,
01065 int32_t srcLength,
01066 int32_t start) const;
01067
01080 inline int32_t lastIndexOf(const UChar *srcChars,
01081 int32_t srcLength,
01082 int32_t start,
01083 int32_t length) const;
01084
01101 int32_t lastIndexOf(const UChar *srcChars,
01102 int32_t srcStart,
01103 int32_t srcLength,
01104 int32_t start,
01105 int32_t length) const;
01106
01114 inline int32_t lastIndexOf(UChar c) const;
01115
01124 inline int32_t lastIndexOf(UChar32 c) const;
01125
01134 inline int32_t lastIndexOf(UChar c,
01135 int32_t start) const;
01136
01146 inline int32_t lastIndexOf(UChar32 c,
01147 int32_t start) const;
01148
01159 inline int32_t lastIndexOf(UChar c,
01160 int32_t start,
01161 int32_t length) const;
01162
01174 inline int32_t lastIndexOf(UChar32 c,
01175 int32_t start,
01176 int32_t length) const;
01177
01178
01179
01180
01189 inline UChar charAt(int32_t offset) const;
01190
01198 inline UChar operator[] (int32_t offset) const;
01199
01211 inline UChar32 char32At(int32_t offset) const;
01212
01228 inline int32_t getChar32Start(int32_t offset) const;
01229
01246 inline int32_t getChar32Limit(int32_t offset) const;
01247
01298 int32_t moveIndex32(int32_t index, int32_t delta) const;
01299
01300
01301
01317 inline void extract(int32_t start,
01318 int32_t length,
01319 UChar *dst,
01320 int32_t dstStart = 0) const;
01321
01343 int32_t
01344 extract(UChar *dest, int32_t destCapacity,
01345 UErrorCode &errorCode) const;
01346
01357 inline void extract(int32_t start,
01358 int32_t length,
01359 UnicodeString& target) const;
01360
01372 inline void extractBetween(int32_t start,
01373 int32_t limit,
01374 UChar *dst,
01375 int32_t dstStart = 0) const;
01376
01386 virtual void extractBetween(int32_t start,
01387 int32_t limit,
01388 UnicodeString& target) const;
01389
01410 inline int32_t extract(int32_t start,
01411 int32_t startLength,
01412 char *target,
01413 const char *codepage = 0) const;
01414
01439 int32_t extract(int32_t start,
01440 int32_t startLength,
01441 char *target,
01442 uint32_t targetLength,
01443 const char *codepage = 0) const;
01444
01462 int32_t extract(char *dest, int32_t destCapacity,
01463 UConverter *cnv,
01464 UErrorCode &errorCode) const;
01465
01466
01467
01476 inline int32_t length(void) const;
01477
01491 int32_t
01492 countChar32(int32_t start=0, int32_t length=INT32_MAX) const;
01493
01517 UBool
01518 hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const;
01519
01525 inline UBool isEmpty(void) const;
01526
01536 inline int32_t getCapacity(void) const;
01537
01538
01539
01545 inline int32_t hashCode(void) const;
01546
01558 inline UBool isBogus(void) const;
01559
01560
01561
01562
01563
01564
01565
01566
01574 UnicodeString &operator=(const UnicodeString &srcText);
01575
01596 UnicodeString &fastCopyFrom(const UnicodeString &src);
01597
01605 inline UnicodeString& operator= (UChar ch);
01606
01614 inline UnicodeString& operator= (UChar32 ch);
01615
01627 inline UnicodeString& setTo(const UnicodeString& srcText,
01628 int32_t srcStart);
01629
01643 inline UnicodeString& setTo(const UnicodeString& srcText,
01644 int32_t srcStart,
01645 int32_t srcLength);
01646
01655 inline UnicodeString& setTo(const UnicodeString& srcText);
01656
01665 inline UnicodeString& setTo(const UChar *srcChars,
01666 int32_t srcLength);
01667
01676 UnicodeString& setTo(UChar srcChar);
01677
01686 UnicodeString& setTo(UChar32 srcChar);
01687
01708 UnicodeString &setTo(UBool isTerminated,
01709 const UChar *text,
01710 int32_t textLength);
01711
01731 UnicodeString &setTo(UChar *buffer,
01732 int32_t buffLength,
01733 int32_t buffCapacity);
01734
01775 void setToBogus();
01776
01784 UnicodeString& setCharAt(int32_t offset,
01785 UChar ch);
01786
01787
01788
01789
01797 inline UnicodeString& operator+= (UChar ch);
01798
01806 inline UnicodeString& operator+= (UChar32 ch);
01807
01816 inline UnicodeString& operator+= (const UnicodeString& srcText);
01817
01832 inline UnicodeString& append(const UnicodeString& srcText,
01833 int32_t srcStart,
01834 int32_t srcLength);
01835
01843 inline UnicodeString& append(const UnicodeString& srcText);
01844
01858 inline UnicodeString& append(const UChar *srcChars,
01859 int32_t srcStart,
01860 int32_t srcLength);
01861
01870 inline UnicodeString& append(const UChar *srcChars,
01871 int32_t srcLength);
01872
01879 inline UnicodeString& append(UChar srcChar);
01880
01887 inline UnicodeString& append(UChar32 srcChar);
01888
01889
01890
01891
01905 inline UnicodeString& insert(int32_t start,
01906 const UnicodeString& srcText,
01907 int32_t srcStart,
01908 int32_t srcLength);
01909
01918 inline UnicodeString& insert(int32_t start,
01919 const UnicodeString& srcText);
01920
01934 inline UnicodeString& insert(int32_t start,
01935 const UChar *srcChars,
01936 int32_t srcStart,
01937 int32_t srcLength);
01938
01948 inline UnicodeString& insert(int32_t start,
01949 const UChar *srcChars,
01950 int32_t srcLength);
01951
01960 inline UnicodeString& insert(int32_t start,
01961 UChar srcChar);
01962
01971 inline UnicodeString& insert(int32_t start,
01972 UChar32 srcChar);
01973
01974
01975
01976
01994 UnicodeString& replace(int32_t start,
01995 int32_t length,
01996 const UnicodeString& srcText,
01997 int32_t srcStart,
01998 int32_t srcLength);
01999
02012 UnicodeString& replace(int32_t start,
02013 int32_t length,
02014 const UnicodeString& srcText);
02015
02033 UnicodeString& replace(int32_t start,
02034 int32_t length,
02035 const UChar *srcChars,
02036 int32_t srcStart,
02037 int32_t srcLength);
02038
02051 inline UnicodeString& replace(int32_t start,
02052 int32_t length,
02053 const UChar *srcChars,
02054 int32_t srcLength);
02055
02067 inline UnicodeString& replace(int32_t start,
02068 int32_t length,
02069 UChar srcChar);
02070
02082 inline UnicodeString& replace(int32_t start,
02083 int32_t length,
02084 UChar32 srcChar);
02085
02095 inline UnicodeString& replaceBetween(int32_t start,
02096 int32_t limit,
02097 const UnicodeString& srcText);
02098
02113 inline UnicodeString& replaceBetween(int32_t start,
02114 int32_t limit,
02115 const UnicodeString& srcText,
02116 int32_t srcStart,
02117 int32_t srcLimit);
02118
02129 virtual void handleReplaceBetween(int32_t start,
02130 int32_t limit,
02131 const UnicodeString& text);
02132
02138 virtual UBool hasMetaData() const;
02139
02155 virtual void copy(int32_t start, int32_t limit, int32_t dest);
02156
02157
02158
02167 inline UnicodeString& findAndReplace(const UnicodeString& oldText,
02168 const UnicodeString& newText);
02169
02181 inline UnicodeString& findAndReplace(int32_t start,
02182 int32_t length,
02183 const UnicodeString& oldText,
02184 const UnicodeString& newText);
02185
02203 UnicodeString& findAndReplace(int32_t start,
02204 int32_t length,
02205 const UnicodeString& oldText,
02206 int32_t oldStart,
02207 int32_t oldLength,
02208 const UnicodeString& newText,
02209 int32_t newStart,
02210 int32_t newLength);
02211
02212
02213
02214
02220 inline UnicodeString& remove(void);
02221
02230 inline UnicodeString& remove(int32_t start,
02231 int32_t length = (int32_t)INT32_MAX);
02232
02241 inline UnicodeString& removeBetween(int32_t start,
02242 int32_t limit = (int32_t)INT32_MAX);
02243
02244
02245
02246
02258 UBool padLeading(int32_t targetLength,
02259 UChar padChar = 0x0020);
02260
02272 UBool padTrailing(int32_t targetLength,
02273 UChar padChar = 0x0020);
02274
02281 inline UBool truncate(int32_t targetLength);
02282
02288 UnicodeString& trim(void);
02289
02290
02291
02292
02298 inline UnicodeString& reverse(void);
02299
02308 inline UnicodeString& reverse(int32_t start,
02309 int32_t length);
02310
02317 UnicodeString& toUpper(void);
02318
02326 UnicodeString& toUpper(const Locale& locale);
02327
02334 UnicodeString& toLower(void);
02335
02343 UnicodeString& toLower(const Locale& locale);
02344
02345 #if !UCONFIG_NO_BREAK_ITERATION
02346
02373 UnicodeString &toTitle(BreakIterator *titleIter);
02374
02402 UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale);
02403
02404 #endif
02405
02417 UnicodeString &foldCase(uint32_t options=0 );
02418
02419
02420
02421
02422
02466 UChar *getBuffer(int32_t minCapacity);
02467
02488 void releaseBuffer(int32_t newLength=-1);
02489
02520 inline const UChar *getBuffer() const;
02521
02555 inline const UChar *getTerminatedBuffer();
02556
02557
02558
02559
02560
02564 UnicodeString();
02565
02577 UnicodeString(int32_t capacity, UChar32 c, int32_t count);
02578
02584 UnicodeString(UChar ch);
02585
02591 UnicodeString(UChar32 ch);
02592
02599 UnicodeString(const UChar *text);
02600
02608 UnicodeString(const UChar *text,
02609 int32_t textLength);
02610
02630 UnicodeString(UBool isTerminated,
02631 const UChar *text,
02632 int32_t textLength);
02633
02652 UnicodeString(UChar *buffer, int32_t buffLength, int32_t buffCapacity);
02653
02665 UnicodeString(const char *codepageData,
02666 const char *codepage = 0);
02667
02680 UnicodeString(const char *codepageData,
02681 int32_t dataLength,
02682 const char *codepage = 0);
02683
02705 UnicodeString(
02706 const char *src, int32_t srcLength,
02707 UConverter *cnv,
02708 UErrorCode &errorCode);
02709
02710
02716 UnicodeString(const UnicodeString& that);
02717
02724 UnicodeString(const UnicodeString& src, int32_t srcStart);
02725
02733 UnicodeString(const UnicodeString& src, int32_t srcStart, int32_t srcLength);
02734
02751 virtual Replaceable *clone() const;
02752
02756 ~UnicodeString();
02757
02758
02759
02760
02795 UnicodeString unescape() const;
02796
02816 UChar32 unescapeAt(int32_t &offset) const;
02817
02823 static UClassID getStaticClassID();
02824
02830 virtual UClassID getDynamicClassID() const;
02831
02832
02833
02834
02835
02836 protected:
02841 virtual int32_t getLength() const;
02842
02848 virtual UChar getCharAt(int32_t offset) const;
02849
02855 virtual UChar32 getChar32At(int32_t offset) const;
02856
02857 private:
02858
02859 inline int8_t
02860 doCompare(int32_t start,
02861 int32_t length,
02862 const UnicodeString& srcText,
02863 int32_t srcStart,
02864 int32_t srcLength) const;
02865
02866 int8_t doCompare(int32_t start,
02867 int32_t length,
02868 const UChar *srcChars,
02869 int32_t srcStart,
02870 int32_t srcLength) const;
02871
02872 inline int8_t
02873 doCompareCodePointOrder(int32_t start,
02874 int32_t length,
02875 const UnicodeString& srcText,
02876 int32_t srcStart,
02877 int32_t srcLength) const;
02878
02879 int8_t doCompareCodePointOrder(int32_t start,
02880 int32_t length,
02881 const UChar *srcChars,
02882 int32_t srcStart,
02883 int32_t srcLength) const;
02884
02885 inline int8_t
02886 doCaseCompare(int32_t start,
02887 int32_t length,
02888 const UnicodeString &srcText,
02889 int32_t srcStart,
02890 int32_t srcLength,
02891 uint32_t options) const;
02892
02893 int8_t
02894 doCaseCompare(int32_t start,
02895 int32_t length,
02896 const UChar *srcChars,
02897 int32_t srcStart,
02898 int32_t srcLength,
02899 uint32_t options) const;
02900
02901 int32_t doIndexOf(UChar c,
02902 int32_t start,
02903 int32_t length) const;
02904
02905 int32_t doIndexOf(UChar32 c,
02906 int32_t start,
02907 int32_t length) const;
02908
02909 int32_t doLastIndexOf(UChar c,
02910 int32_t start,
02911 int32_t length) const;
02912
02913 int32_t doLastIndexOf(UChar32 c,
02914 int32_t start,
02915 int32_t length) const;
02916
02917 void doExtract(int32_t start,
02918 int32_t length,
02919 UChar *dst,
02920 int32_t dstStart) const;
02921
02922 inline void doExtract(int32_t start,
02923 int32_t length,
02924 UnicodeString& target) const;
02925
02926 inline UChar doCharAt(int32_t offset) const;
02927
02928 UnicodeString& doReplace(int32_t start,
02929 int32_t length,
02930 const UnicodeString& srcText,
02931 int32_t srcStart,
02932 int32_t srcLength);
02933
02934 UnicodeString& doReplace(int32_t start,
02935 int32_t length,
02936 const UChar *srcChars,
02937 int32_t srcStart,
02938 int32_t srcLength);
02939
02940 UnicodeString& doReverse(int32_t start,
02941 int32_t length);
02942
02943
02944 int32_t doHashCode(void) const;
02945
02946
02947 inline UChar* getArrayStart(void);
02948 inline const UChar* getArrayStart(void) const;
02949
02950
02951
02952
02953
02954 UBool allocate(int32_t capacity);
02955
02956
02957 void releaseArray(void);
02958
02959
02960 void unBogus();
02961
02962
02963 UnicodeString ©From(const UnicodeString &src, UBool fastCopy=FALSE);
02964
02965
02966 inline void pinIndex(int32_t& start) const;
02967 inline void pinIndices(int32_t& start,
02968 int32_t& length) const;
02969
02970
02971 int32_t doExtract(int32_t start, int32_t length,
02972 char *dest, int32_t destCapacity,
02973 UConverter *cnv,
02974 UErrorCode &errorCode) const;
02975
02976
02977
02978
02979
02980
02981
02982
02983
02984
02985
02986 void doCodepageCreate(const char *codepageData,
02987 int32_t dataLength,
02988 const char *codepage);
02989
02990
02991
02992
02993
02994 void
02995 doCodepageCreate(const char *codepageData,
02996 int32_t dataLength,
02997 UConverter *converter,
02998 UErrorCode &status);
02999
03000
03001
03002
03003
03004
03005
03006
03007
03008
03009
03010 UBool cloneArrayIfNeeded(int32_t newCapacity = -1,
03011 int32_t growCapacity = -1,
03012 UBool doCopyArray = TRUE,
03013 int32_t **pBufferToDelete = 0,
03014 UBool forceClone = FALSE);
03015
03016
03017 UnicodeString &
03018 caseMap(BreakIterator *titleIter,
03019 const Locale& locale,
03020 uint32_t options,
03021 int32_t toWhichCase);
03022
03023
03024 void addRef(void);
03025 int32_t removeRef(void);
03026 int32_t refCount(void) const;
03027
03028
03029 enum {
03030 US_STACKBUF_SIZE=7,
03031 kInvalidUChar=0xffff,
03032 kGrowSize=128,
03033 kInvalidHashCode=0,
03034 kEmptyHashCode=1,
03035
03036
03037 kIsBogus=1,
03038 kUsingStackBuffer=2,
03039 kRefCounted=4,
03040 kBufferIsReadonly=8,
03041 kOpenGetBuffer=16,
03042
03043
03044
03045 kShortString=kUsingStackBuffer,
03046 kLongString=kRefCounted,
03047 kReadonlyAlias=kBufferIsReadonly,
03048 kWritableAlias=0
03049 };
03050
03051 friend class StringCharacterIterator;
03052 friend class StringThreadTest;
03053
03054
03055
03056
03057
03058
03059
03060
03061
03062
03063
03064
03065
03066 int32_t fLength;
03067 int32_t fCapacity;
03068 UChar *fArray;
03069 uint16_t fFlags;
03070 UChar fStackBuffer [ US_STACKBUF_SIZE ];
03071
03072 };
03073
03082 U_COMMON_API UnicodeString
03083 operator+ (const UnicodeString &s1, const UnicodeString &s2);
03084
03085 U_NAMESPACE_END
03086
03087
03088
03089
03090
03091
03096 inline void
03097 uprv_arrayCopy(const U_NAMESPACE_QUALIFIER UnicodeString *src, U_NAMESPACE_QUALIFIER UnicodeString *dst, int32_t count)
03098 { while(count-- > 0) *dst++ = *src++; }
03099
03104 inline void
03105 uprv_arrayCopy(const U_NAMESPACE_QUALIFIER UnicodeString *src, int32_t srcStart,
03106 U_NAMESPACE_QUALIFIER UnicodeString *dst, int32_t dstStart, int32_t count)
03107 { uprv_arrayCopy(src+srcStart, dst+dstStart, count); }
03108
03109 U_NAMESPACE_BEGIN
03110
03111
03112
03113
03114
03115
03116
03117
03118
03119 inline void
03120 UnicodeString::pinIndex(int32_t& start) const
03121 {
03122
03123 if(start < 0) {
03124 start = 0;
03125 } else if(start > fLength) {
03126 start = fLength;
03127 }
03128 }
03129
03130 inline void
03131 UnicodeString::pinIndices(int32_t& start,
03132 int32_t& _length) const
03133 {
03134
03135 if(start < 0) {
03136 start = 0;
03137 } else if(start > fLength) {
03138 start = fLength;
03139 }
03140 if(_length < 0) {
03141 _length = 0;
03142 } else if(_length > (fLength - start)) {
03143 _length = (fLength - start);
03144 }
03145 }
03146
03147 inline UChar*
03148 UnicodeString::getArrayStart()
03149 { return fArray; }
03150
03151 inline const UChar*
03152 UnicodeString::getArrayStart() const
03153 { return fArray; }
03154
03155
03156
03157
03158 inline int32_t
03159 UnicodeString::length() const
03160 { return fLength; }
03161
03162 inline int32_t
03163 UnicodeString::getCapacity() const
03164 { return fCapacity; }
03165
03166 inline int32_t
03167 UnicodeString::hashCode() const
03168 { return doHashCode(); }
03169
03170 inline UBool
03171 UnicodeString::isBogus() const
03172 { return (UBool)(fFlags & kIsBogus); }
03173
03174 inline const UChar *
03175 UnicodeString::getBuffer() const {
03176 if(!(fFlags&(kIsBogus|kOpenGetBuffer))) {
03177 return fArray;
03178 } else {
03179 return 0;
03180 }
03181 }
03182
03183
03184
03185
03186 inline int8_t
03187 UnicodeString::doCompare(int32_t start,
03188 int32_t length,
03189 const UnicodeString& srcText,
03190 int32_t srcStart,
03191 int32_t srcLength) const
03192 {
03193 if(srcText.isBogus()) {
03194 return (int8_t)!isBogus();
03195 } else {
03196 srcText.pinIndices(srcStart, srcLength);
03197 return doCompare(start, length, srcText.fArray, srcStart, srcLength);
03198 }
03199 }
03200
03201 inline UBool
03202 UnicodeString::operator== (const UnicodeString& text) const
03203 {
03204 if(isBogus()) {
03205 return text.isBogus();
03206 } else {
03207 return
03208 !text.isBogus() &&
03209 fLength == text.fLength &&
03210 doCompare(0, fLength, text, 0, text.fLength) == 0;
03211 }
03212 }
03213
03214 inline UBool
03215 UnicodeString::operator!= (const UnicodeString& text) const
03216 { return (! operator==(text)); }
03217
03218 inline UBool
03219 UnicodeString::operator> (const UnicodeString& text) const
03220 { return doCompare(0, fLength, text, 0, text.fLength) == 1; }
03221
03222 inline UBool
03223 UnicodeString::operator< (const UnicodeString& text) const
03224 { return doCompare(0, fLength, text, 0, text.fLength) == -1; }
03225
03226 inline UBool
03227 UnicodeString::operator>= (const UnicodeString& text) const
03228 { return doCompare(0, fLength, text, 0, text.fLength) != -1; }
03229
03230 inline UBool
03231 UnicodeString::operator<= (const UnicodeString& text) const
03232 { return doCompare(0, fLength, text, 0, text.fLength) != 1; }
03233
03234 inline int8_t
03235 UnicodeString::compare(const UnicodeString& text) const
03236 { return doCompare(0, fLength, text, 0, text.fLength); }
03237
03238 inline int8_t
03239 UnicodeString::compare(int32_t start,
03240 int32_t _length,
03241 const UnicodeString& srcText) const
03242 { return doCompare(start, _length, srcText, 0, srcText.fLength); }
03243
03244 inline int8_t
03245 UnicodeString::compare(const UChar *srcChars,
03246 int32_t srcLength) const
03247 { return doCompare(0, fLength, srcChars, 0, srcLength); }
03248
03249 inline int8_t
03250 UnicodeString::compare(int32_t start,
03251 int32_t _length,
03252 const UnicodeString& srcText,
03253 int32_t srcStart,
03254 int32_t srcLength) const
03255 { return doCompare(start, _length, srcText, srcStart, srcLength); }
03256
03257 inline int8_t
03258 UnicodeString::compare(int32_t start,
03259 int32_t _length,
03260 const UChar *srcChars) const
03261 { return doCompare(start, _length, srcChars, 0, _length); }
03262
03263 inline int8_t
03264 UnicodeString::compare(int32_t start,
03265 int32_t _length,
03266 const UChar *srcChars,
03267 int32_t srcStart,
03268 int32_t srcLength) const
03269 { return doCompare(start, _length, srcChars, srcStart, srcLength); }
03270
03271 inline int8_t
03272 UnicodeString::compareBetween(int32_t start,
03273 int32_t limit,
03274 const UnicodeString& srcText,
03275 int32_t srcStart,
03276 int32_t srcLimit) const
03277 { return doCompare(start, limit - start,
03278 srcText, srcStart, srcLimit - srcStart); }
03279
03280 inline int8_t
03281 UnicodeString::doCompareCodePointOrder(int32_t start,
03282 int32_t length,
03283 const UnicodeString& srcText,
03284 int32_t srcStart,
03285 int32_t srcLength) const
03286 {
03287 if(srcText.isBogus()) {
03288 return (int8_t)!isBogus();
03289 } else {
03290 srcText.pinIndices(srcStart, srcLength);
03291 return doCompareCodePointOrder(start, length, srcText.fArray, srcStart, srcLength);
03292 }
03293 }
03294
03295 inline int8_t
03296 UnicodeString::compareCodePointOrder(const UnicodeString& text) const
03297 { return doCompareCodePointOrder(0, fLength, text, 0, text.fLength); }
03298
03299 inline int8_t
03300 UnicodeString::compareCodePointOrder(int32_t start,
03301 int32_t _length,
03302 const UnicodeString& srcText) const
03303 { return doCompareCodePointOrder(start, _length, srcText, 0, srcText.fLength); }
03304
03305 inline int8_t
03306 UnicodeString::compareCodePointOrder(const UChar *srcChars,
03307 int32_t srcLength) const
03308 { return doCompareCodePointOrder(0, fLength, srcChars, 0, srcLength); }
03309
03310 inline int8_t
03311 UnicodeString::compareCodePointOrder(int32_t start,
03312 int32_t _length,
03313 const UnicodeString& srcText,
03314 int32_t srcStart,
03315 int32_t srcLength) const
03316 { return doCompareCodePointOrder(start, _length, srcText, srcStart, srcLength); }
03317
03318 inline int8_t
03319 UnicodeString::compareCodePointOrder(int32_t start,
03320 int32_t _length,
03321 const UChar *srcChars) const
03322 { return doCompareCodePointOrder(start, _length, srcChars, 0, _length); }
03323
03324 inline int8_t
03325 UnicodeString::compareCodePointOrder(int32_t start,
03326 int32_t _length,
03327 const UChar *srcChars,
03328 int32_t srcStart,
03329 int32_t srcLength) const
03330 { return doCompareCodePointOrder(start, _length, srcChars, srcStart, srcLength); }
03331
03332 inline int8_t
03333 UnicodeString::compareCodePointOrderBetween(int32_t start,
03334 int32_t limit,
03335 const UnicodeString& srcText,
03336 int32_t srcStart,
03337 int32_t srcLimit) const
03338 { return doCompareCodePointOrder(start, limit - start,
03339 srcText, srcStart, srcLimit - srcStart); }
03340
03341 inline int8_t
03342 UnicodeString::doCaseCompare(int32_t start,
03343 int32_t length,
03344 const UnicodeString &srcText,
03345 int32_t srcStart,
03346 int32_t srcLength,
03347 uint32_t options) const
03348 {
03349 if(srcText.isBogus()) {
03350 return (int8_t)!isBogus();
03351 } else {
03352 srcText.pinIndices(srcStart, srcLength);
03353 return doCaseCompare(start, length, srcText.fArray, srcStart, srcLength, options);
03354 }
03355 }
03356
03357 inline int8_t
03358 UnicodeString::caseCompare(const UnicodeString &text, uint32_t options) const {
03359 return doCaseCompare(0, fLength, text, 0, text.fLength, options);
03360 }
03361
03362 inline int8_t
03363 UnicodeString::caseCompare(int32_t start,
03364 int32_t _length,
03365 const UnicodeString &srcText,
03366 uint32_t options) const {
03367 return doCaseCompare(start, _length, srcText, 0, srcText.fLength, options);
03368 }
03369
03370 inline int8_t
03371 UnicodeString::caseCompare(const UChar *srcChars,
03372 int32_t srcLength,
03373 uint32_t options) const {
03374 return doCaseCompare(0, fLength, srcChars, 0, srcLength, options);
03375 }
03376
03377 inline int8_t
03378 UnicodeString::caseCompare(int32_t start,
03379 int32_t _length,
03380 const UnicodeString &srcText,
03381 int32_t srcStart,
03382 int32_t srcLength,
03383 uint32_t options) const {
03384 return doCaseCompare(start, _length, srcText, srcStart, srcLength, options);
03385 }
03386
03387 inline int8_t
03388 UnicodeString::caseCompare(int32_t start,
03389 int32_t _length,
03390 const UChar *srcChars,
03391 uint32_t options) const {
03392 return doCaseCompare(start, _length, srcChars, 0, _length, options);
03393 }
03394
03395 inline int8_t
03396 UnicodeString::caseCompare(int32_t start,
03397 int32_t _length,
03398 const UChar *srcChars,
03399 int32_t srcStart,
03400 int32_t srcLength,
03401 uint32_t options) const {
03402 return doCaseCompare(start, _length, srcChars, srcStart, srcLength, options);
03403 }
03404
03405 inline int8_t
03406 UnicodeString::caseCompareBetween(int32_t start,
03407 int32_t limit,
03408 const UnicodeString &srcText,
03409 int32_t srcStart,
03410 int32_t srcLimit,
03411 uint32_t options) const {
03412 return doCaseCompare(start, limit - start, srcText, srcStart, srcLimit - srcStart, options);
03413 }
03414
03415 inline int32_t
03416 UnicodeString::indexOf(const UnicodeString& srcText,
03417 int32_t srcStart,
03418 int32_t srcLength,
03419 int32_t start,
03420 int32_t _length) const
03421 {
03422 if(!srcText.isBogus()) {
03423 srcText.pinIndices(srcStart, srcLength);
03424 if(srcLength > 0) {
03425 return indexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
03426 }
03427 }
03428 return -1;
03429 }
03430
03431 inline int32_t
03432 UnicodeString::indexOf(const UnicodeString& text) const
03433 { return indexOf(text, 0, text.fLength, 0, fLength); }
03434
03435 inline int32_t
03436 UnicodeString::indexOf(const UnicodeString& text,
03437 int32_t start) const {
03438 pinIndex(start);
03439 return indexOf(text, 0, text.fLength, start, fLength - start);
03440 }
03441
03442 inline int32_t
03443 UnicodeString::indexOf(const UnicodeString& text,
03444 int32_t start,
03445 int32_t _length) const
03446 { return indexOf(text, 0, text.fLength, start, _length); }
03447
03448 inline int32_t
03449 UnicodeString::indexOf(const UChar *srcChars,
03450 int32_t srcLength,
03451 int32_t start) const {
03452 pinIndex(start);
03453 return indexOf(srcChars, 0, srcLength, start, fLength - start);
03454 }
03455
03456 inline int32_t
03457 UnicodeString::indexOf(const UChar *srcChars,
03458 int32_t srcLength,
03459 int32_t start,
03460 int32_t _length) const
03461 { return indexOf(srcChars, 0, srcLength, start, _length); }
03462
03463 inline int32_t
03464 UnicodeString::indexOf(UChar c,
03465 int32_t start,
03466 int32_t _length) const
03467 { return doIndexOf(c, start, _length); }
03468
03469 inline int32_t
03470 UnicodeString::indexOf(UChar32 c,
03471 int32_t start,
03472 int32_t _length) const
03473 { return doIndexOf(c, start, _length); }
03474
03475 inline int32_t
03476 UnicodeString::indexOf(UChar c) const
03477 { return doIndexOf(c, 0, fLength); }
03478
03479 inline int32_t
03480 UnicodeString::indexOf(UChar32 c) const
03481 { return indexOf(c, 0, fLength); }
03482
03483 inline int32_t
03484 UnicodeString::indexOf(UChar c,
03485 int32_t start) const {
03486 pinIndex(start);
03487 return doIndexOf(c, start, fLength - start);
03488 }
03489
03490 inline int32_t
03491 UnicodeString::indexOf(UChar32 c,
03492 int32_t start) const {
03493 pinIndex(start);
03494 return indexOf(c, start, fLength - start);
03495 }
03496
03497 inline int32_t
03498 UnicodeString::lastIndexOf(const UChar *srcChars,
03499 int32_t srcLength,
03500 int32_t start,
03501 int32_t _length) const
03502 { return lastIndexOf(srcChars, 0, srcLength, start, _length); }
03503
03504 inline int32_t
03505 UnicodeString::lastIndexOf(const UChar *srcChars,
03506 int32_t srcLength,
03507 int32_t start) const {
03508 pinIndex(start);
03509 return lastIndexOf(srcChars, 0, srcLength, start, fLength - start);
03510 }
03511
03512 inline int32_t
03513 UnicodeString::lastIndexOf(const UnicodeString& srcText,
03514 int32_t srcStart,
03515 int32_t srcLength,
03516 int32_t start,
03517 int32_t _length) const
03518 {
03519 if(!srcText.isBogus()) {
03520 srcText.pinIndices(srcStart, srcLength);
03521 if(srcLength > 0) {
03522 return lastIndexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
03523 }
03524 }
03525 return -1;
03526 }
03527
03528 inline int32_t
03529 UnicodeString::lastIndexOf(const UnicodeString& text,
03530 int32_t start,
03531 int32_t _length) const
03532 { return lastIndexOf(text, 0, text.fLength, start, _length); }
03533
03534 inline int32_t
03535 UnicodeString::lastIndexOf(const UnicodeString& text,
03536 int32_t start) const {
03537 pinIndex(start);
03538 return lastIndexOf(text, 0, text.fLength, start, fLength - start);
03539 }
03540
03541 inline int32_t
03542 UnicodeString::lastIndexOf(const UnicodeString& text) const
03543 { return lastIndexOf(text, 0, text.fLength, 0, fLength); }
03544
03545 inline int32_t
03546 UnicodeString::lastIndexOf(UChar c,
03547 int32_t start,
03548 int32_t _length) const
03549 { return doLastIndexOf(c, start, _length); }
03550
03551 inline int32_t
03552 UnicodeString::lastIndexOf(UChar32 c,
03553 int32_t start,
03554 int32_t _length) const {
03555 return doLastIndexOf(c, start, _length);
03556 }
03557
03558 inline int32_t
03559 UnicodeString::lastIndexOf(UChar c) const
03560 { return doLastIndexOf(c, 0, fLength); }
03561
03562 inline int32_t
03563 UnicodeString::lastIndexOf(UChar32 c) const {
03564 return lastIndexOf(c, 0, fLength);
03565 }
03566
03567 inline int32_t
03568 UnicodeString::lastIndexOf(UChar c,
03569 int32_t start) const {
03570 pinIndex(start);
03571 return doLastIndexOf(c, start, fLength - start);
03572 }
03573
03574 inline int32_t
03575 UnicodeString::lastIndexOf(UChar32 c,
03576 int32_t start) const {
03577 pinIndex(start);
03578 return lastIndexOf(c, start, fLength - start);
03579 }
03580
03581 inline UBool
03582 UnicodeString::startsWith(const UnicodeString& text) const
03583 { return compare(0, text.fLength, text, 0, text.fLength) == 0; }
03584
03585 inline UBool
03586 UnicodeString::startsWith(const UnicodeString& srcText,
03587 int32_t srcStart,
03588 int32_t srcLength) const
03589 { return doCompare(0, srcLength, srcText, srcStart, srcLength) == 0; }
03590
03591 inline UBool
03592 UnicodeString::startsWith(const UChar *srcChars,
03593 int32_t srcLength) const
03594 { return doCompare(0, srcLength, srcChars, 0, srcLength) == 0; }
03595
03596 inline UBool
03597 UnicodeString::startsWith(const UChar *srcChars,
03598 int32_t srcStart,
03599 int32_t srcLength) const
03600 { return doCompare(0, srcLength, srcChars, srcStart, srcLength) == 0;}
03601
03602 inline UBool
03603 UnicodeString::endsWith(const UnicodeString& text) const
03604 { return doCompare(fLength - text.fLength, text.fLength,
03605 text, 0, text.fLength) == 0; }
03606
03607 inline UBool
03608 UnicodeString::endsWith(const UnicodeString& srcText,
03609 int32_t srcStart,
03610 int32_t srcLength) const {
03611 srcText.pinIndices(srcStart, srcLength);
03612 return doCompare(fLength - srcLength, srcLength,
03613 srcText, srcStart, srcLength) == 0;
03614 }
03615
03616 inline UBool
03617 UnicodeString::endsWith(const UChar *srcChars,
03618 int32_t srcLength) const {
03619 if(srcLength < 0) {
03620 srcLength = u_strlen(srcChars);
03621 }
03622 return doCompare(fLength - srcLength, srcLength,
03623 srcChars, 0, srcLength) == 0;
03624 }
03625
03626 inline UBool
03627 UnicodeString::endsWith(const UChar *srcChars,
03628 int32_t srcStart,
03629 int32_t srcLength) const {
03630 if(srcLength < 0) {
03631 srcLength = u_strlen(srcChars + srcStart);
03632 }
03633 return doCompare(fLength - srcLength, srcLength,
03634 srcChars, srcStart, srcLength) == 0;
03635 }
03636
03637
03638
03639
03640 inline UnicodeString&
03641 UnicodeString::replace(int32_t start,
03642 int32_t _length,
03643 const UnicodeString& srcText)
03644 { return doReplace(start, _length, srcText, 0, srcText.fLength); }
03645
03646 inline UnicodeString&
03647 UnicodeString::replace(int32_t start,
03648 int32_t _length,
03649 const UnicodeString& srcText,
03650 int32_t srcStart,
03651 int32_t srcLength)
03652 { return doReplace(start, _length, srcText, srcStart, srcLength); }
03653
03654 inline UnicodeString&
03655 UnicodeString::replace(int32_t start,
03656 int32_t _length,
03657 const UChar *srcChars,
03658 int32_t srcLength)
03659 { return doReplace(start, _length, srcChars, 0, srcLength); }
03660
03661 inline UnicodeString&
03662 UnicodeString::replace(int32_t start,
03663 int32_t _length,
03664 const UChar *srcChars,
03665 int32_t srcStart,
03666 int32_t srcLength)
03667 { return doReplace(start, _length, srcChars, srcStart, srcLength); }
03668
03669 inline UnicodeString&
03670 UnicodeString::replace(int32_t start,
03671 int32_t _length,
03672 UChar srcChar)
03673 { return doReplace(start, _length, &srcChar, 0, 1); }
03674
03675 inline UnicodeString&
03676 UnicodeString::replace(int32_t start,
03677 int32_t _length,
03678 UChar32 srcChar) {
03679 UChar buffer[U16_MAX_LENGTH];
03680 int32_t count = 0;
03681 UBool isError = FALSE;
03682 U16_APPEND(buffer, count, U16_MAX_LENGTH, srcChar, isError);
03683 return doReplace(start, _length, buffer, 0, count);
03684 }
03685
03686 inline UnicodeString&
03687 UnicodeString::replaceBetween(int32_t start,
03688 int32_t limit,
03689 const UnicodeString& srcText)
03690 { return doReplace(start, limit - start, srcText, 0, srcText.fLength); }
03691
03692 inline UnicodeString&
03693 UnicodeString::replaceBetween(int32_t start,
03694 int32_t limit,
03695 const UnicodeString& srcText,
03696 int32_t srcStart,
03697 int32_t srcLimit)
03698 { return doReplace(start, limit - start, srcText, srcStart, srcLimit - srcStart); }
03699
03700 inline UnicodeString&
03701 UnicodeString::findAndReplace(const UnicodeString& oldText,
03702 const UnicodeString& newText)
03703 { return findAndReplace(0, fLength, oldText, 0, oldText.fLength,
03704 newText, 0, newText.fLength); }
03705
03706 inline UnicodeString&
03707 UnicodeString::findAndReplace(int32_t start,
03708 int32_t _length,
03709 const UnicodeString& oldText,
03710 const UnicodeString& newText)
03711 { return findAndReplace(start, _length, oldText, 0, oldText.fLength,
03712 newText, 0, newText.fLength); }
03713
03714
03715
03716
03717 inline void
03718 UnicodeString::doExtract(int32_t start,
03719 int32_t _length,
03720 UnicodeString& target) const
03721 { target.replace(0, target.fLength, *this, start, _length); }
03722
03723 inline void
03724 UnicodeString::extract(int32_t start,
03725 int32_t _length,
03726 UChar *target,
03727 int32_t targetStart) const
03728 { doExtract(start, _length, target, targetStart); }
03729
03730 inline void
03731 UnicodeString::extract(int32_t start,
03732 int32_t _length,
03733 UnicodeString& target) const
03734 { doExtract(start, _length, target); }
03735
03736 inline int32_t
03737 UnicodeString::extract(int32_t start,
03738 int32_t _length,
03739 char *dst,
03740 const char *codepage) const
03741
03742 {
03743
03744 return extract(start, _length, dst, dst!=0 ? 0xffffffff : 0, codepage);
03745 }
03746
03747 inline void
03748 UnicodeString::extractBetween(int32_t start,
03749 int32_t limit,
03750 UChar *dst,
03751 int32_t dstStart) const
03752 { doExtract(start, limit - start, dst, dstStart); }
03753
03754 inline UChar
03755 UnicodeString::doCharAt(int32_t offset) const
03756 {
03757 if((uint32_t)offset < (uint32_t)fLength) {
03758 return fArray[offset];
03759 } else {
03760 return kInvalidUChar;
03761 }
03762 }
03763
03764 inline UChar
03765 UnicodeString::charAt(int32_t offset) const
03766 { return doCharAt(offset); }
03767
03768 inline UChar
03769 UnicodeString::operator[] (int32_t offset) const
03770 { return doCharAt(offset); }
03771
03772 inline UChar32
03773 UnicodeString::char32At(int32_t offset) const
03774 {
03775 if((uint32_t)offset < (uint32_t)fLength) {
03776 UChar32 c;
03777 U16_GET(fArray, 0, offset, fLength, c);
03778 return c;
03779 } else {
03780 return kInvalidUChar;
03781 }
03782 }
03783
03784 inline int32_t
03785 UnicodeString::getChar32Start(int32_t offset) const {
03786 if((uint32_t)offset < (uint32_t)fLength) {
03787 U16_SET_CP_START(fArray, 0, offset);
03788 return offset;
03789 } else {
03790 return 0;
03791 }
03792 }
03793
03794 inline int32_t
03795 UnicodeString::getChar32Limit(int32_t offset) const {
03796 if((uint32_t)offset < (uint32_t)fLength) {
03797 U16_SET_CP_LIMIT(fArray, 0, offset, fLength);
03798 return offset;
03799 } else {
03800 return fLength;
03801 }
03802 }
03803
03804 inline UBool
03805 UnicodeString::isEmpty() const {
03806 return fLength == 0;
03807 }
03808
03809
03810
03811
03812 inline const UChar *
03813 UnicodeString::getTerminatedBuffer() {
03814 if(fFlags&(kIsBogus|kOpenGetBuffer)) {
03815 return 0;
03816 } else if(fLength<fCapacity && fArray[fLength]==0) {
03817 return fArray;
03818 } else if(cloneArrayIfNeeded(fLength+1)) {
03819 fArray[fLength]=0;
03820 return fArray;
03821 } else {
03822 return 0;
03823 }
03824 }
03825
03826 inline UnicodeString&
03827 UnicodeString::operator= (UChar ch)
03828 { return doReplace(0, fLength, &ch, 0, 1); }
03829
03830 inline UnicodeString&
03831 UnicodeString::operator= (UChar32 ch)
03832 { return replace(0, fLength, ch); }
03833
03834 inline UnicodeString&
03835 UnicodeString::setTo(const UnicodeString& srcText,
03836 int32_t srcStart,
03837 int32_t srcLength)
03838 {
03839 unBogus();
03840 return doReplace(0, fLength, srcText, srcStart, srcLength);
03841 }
03842
03843 inline UnicodeString&
03844 UnicodeString::setTo(const UnicodeString& srcText,
03845 int32_t srcStart)
03846 {
03847 unBogus();
03848 srcText.pinIndex(srcStart);
03849 return doReplace(0, fLength, srcText, srcStart, srcText.fLength - srcStart);
03850 }
03851
03852 inline UnicodeString&
03853 UnicodeString::setTo(const UnicodeString& srcText)
03854 {
03855 unBogus();
03856 return doReplace(0, fLength, srcText, 0, srcText.fLength);
03857 }
03858
03859 inline UnicodeString&
03860 UnicodeString::setTo(const UChar *srcChars,
03861 int32_t srcLength)
03862 {
03863 unBogus();
03864 return doReplace(0, fLength, srcChars, 0, srcLength);
03865 }
03866
03867 inline UnicodeString&
03868 UnicodeString::setTo(UChar srcChar)
03869 {
03870 unBogus();
03871 return doReplace(0, fLength, &srcChar, 0, 1);
03872 }
03873
03874 inline UnicodeString&
03875 UnicodeString::setTo(UChar32 srcChar)
03876 {
03877 unBogus();
03878 return replace(0, fLength, srcChar);
03879 }
03880
03881 inline UnicodeString&
03882 UnicodeString::operator+= (UChar ch)
03883 { return doReplace(fLength, 0, &ch, 0, 1); }
03884
03885 inline UnicodeString&
03886 UnicodeString::operator+= (UChar32 ch) {
03887 UChar buffer[U16_MAX_LENGTH];
03888 int32_t _length = 0;
03889 UBool isError = FALSE;
03890 U16_APPEND(buffer, _length, U16_MAX_LENGTH, ch, isError);
03891 return doReplace(fLength, 0, buffer, 0, _length);
03892 }
03893
03894 inline UnicodeString&
03895 UnicodeString::operator+= (const UnicodeString& srcText)
03896 { return doReplace(fLength, 0, srcText, 0, srcText.fLength); }
03897
03898 inline UnicodeString&
03899 UnicodeString::append(const UnicodeString& srcText,
03900 int32_t srcStart,
03901 int32_t srcLength)
03902 { return doReplace(fLength, 0, srcText, srcStart, srcLength); }
03903
03904 inline UnicodeString&
03905 UnicodeString::append(const UnicodeString& srcText)
03906 { return doReplace(fLength, 0, srcText, 0, srcText.fLength); }
03907
03908 inline UnicodeString&
03909 UnicodeString::append(const UChar *srcChars,
03910 int32_t srcStart,
03911 int32_t srcLength)
03912 { return doReplace(fLength, 0, srcChars, srcStart, srcLength); }
03913
03914 inline UnicodeString&
03915 UnicodeString::append(const UChar *srcChars,
03916 int32_t srcLength)
03917 { return doReplace(fLength, 0, srcChars, 0, srcLength); }
03918
03919 inline UnicodeString&
03920 UnicodeString::append(UChar srcChar)
03921 { return doReplace(fLength, 0, &srcChar, 0, 1); }
03922
03923 inline UnicodeString&
03924 UnicodeString::append(UChar32 srcChar) {
03925 UChar buffer[U16_MAX_LENGTH];
03926 int32_t _length = 0;
03927 UBool isError = FALSE;
03928 U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError);
03929 return doReplace(fLength, 0, buffer, 0, _length);
03930 }
03931
03932 inline UnicodeString&
03933 UnicodeString::insert(int32_t start,
03934 const UnicodeString& srcText,
03935 int32_t srcStart,
03936 int32_t srcLength)
03937 { return doReplace(start, 0, srcText, srcStart, srcLength); }
03938
03939 inline UnicodeString&
03940 UnicodeString::insert(int32_t start,
03941 const UnicodeString& srcText)
03942 { return doReplace(start, 0, srcText, 0, srcText.fLength); }
03943
03944 inline UnicodeString&
03945 UnicodeString::insert(int32_t start,
03946 const UChar *srcChars,
03947 int32_t srcStart,
03948 int32_t srcLength)
03949 { return doReplace(start, 0, srcChars, srcStart, srcLength); }
03950
03951 inline UnicodeString&
03952 UnicodeString::insert(int32_t start,
03953 const UChar *srcChars,
03954 int32_t srcLength)
03955 { return doReplace(start, 0, srcChars, 0, srcLength); }
03956
03957 inline UnicodeString&
03958 UnicodeString::insert(int32_t start,
03959 UChar srcChar)
03960 { return doReplace(start, 0, &srcChar, 0, 1); }
03961
03962 inline UnicodeString&
03963 UnicodeString::insert(int32_t start,
03964 UChar32 srcChar)
03965 { return replace(start, 0, srcChar); }
03966
03967
03968 inline UnicodeString&
03969 UnicodeString::remove()
03970 {
03971
03972 if(isBogus()) {
03973 unBogus();
03974 } else {
03975 fLength = 0;
03976 }
03977 return *this;
03978 }
03979
03980 inline UnicodeString&
03981 UnicodeString::remove(int32_t start,
03982 int32_t _length)
03983 {
03984 if(start <= 0 && _length == INT32_MAX) {
03985
03986 return remove();
03987 } else {
03988 return doReplace(start, _length, NULL, 0, 0);
03989 }
03990 }
03991
03992 inline UnicodeString&
03993 UnicodeString::removeBetween(int32_t start,
03994 int32_t limit)
03995 { return doReplace(start, limit - start, NULL, 0, 0); }
03996
03997 inline UBool
03998 UnicodeString::truncate(int32_t targetLength)
03999 {
04000 if(isBogus() && targetLength == 0) {
04001
04002 unBogus();
04003 return FALSE;
04004 } else if((uint32_t)targetLength < (uint32_t)fLength) {
04005 fLength = targetLength;
04006 return TRUE;
04007 } else {
04008 return FALSE;
04009 }
04010 }
04011
04012 inline UnicodeString&
04013 UnicodeString::reverse()
04014 { return doReverse(0, fLength); }
04015
04016 inline UnicodeString&
04017 UnicodeString::reverse(int32_t start,
04018 int32_t _length)
04019 { return doReverse(start, _length); }
04020
04021 U_NAMESPACE_END
04022
04023 #endif