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/utypes.h"
00025 #include "unicode/rep.h"
00026
00027 struct UConverter;
00028 class StringThreadTest;
00029
00030 U_NAMESPACE_BEGIN
00031
00032 class Locale;
00033 class UCharReference;
00034 class UnicodeConverter;
00035 class StringCharacterIterator;
00036 class BreakIterator;
00037
00038
00039
00057 #if U_SIZEOF_WCHAR_T==U_SIZEOF_UCHAR && U_CHARSET_FAMILY==U_ASCII_FAMILY
00058 # define UNICODE_STRING(cs, length) UnicodeString(TRUE, (const UChar *)L ## cs, length)
00059 #elif U_SIZEOF_UCHAR==1 && U_CHARSET_FAMILY==U_ASCII_FAMILY
00060 # define UNICODE_STRING(cs, length) UnicodeString(TRUE, (const UChar *)cs, length)
00061 #else
00062 # define UNICODE_STRING(cs, length) UnicodeString(cs, length, "")
00063 #endif
00064
00078 #if U_SIZEOF_WCHAR_T==U_SIZEOF_UCHAR && U_CHARSET_FAMILY==U_ASCII_FAMILY
00079 # define UNICODE_STRING_SIMPLE(cs) UnicodeString((const UChar *)L ## cs)
00080 #elif U_SIZEOF_UCHAR==1 && U_CHARSET_FAMILY==U_ASCII_FAMILY
00081 # define UNICODE_STRING_SIMPLE(cs) UnicodeString((const UChar *)cs)
00082 #else
00083 # define UNICODE_STRING_SIMPLE(cs) UnicodeString(cs, "")
00084 #endif
00085
00145 class U_COMMON_API UnicodeString : public Replaceable
00146 {
00147 public:
00148
00149
00150
00151
00152
00153
00154
00162 inline UBool operator== (const UnicodeString& text) const;
00163
00171 inline UBool operator!= (const UnicodeString& text) const;
00172
00180 inline UBool operator> (const UnicodeString& text) const;
00181
00189 inline UBool operator< (const UnicodeString& text) const;
00190
00198 inline UBool operator>= (const UnicodeString& text) const;
00199
00207 inline UBool operator<= (const UnicodeString& text) const;
00208
00220 inline int8_t compare(const UnicodeString& text) const;
00221
00236 inline int8_t compare(int32_t start,
00237 int32_t length,
00238 const UnicodeString& srcText) const;
00239
00257 inline int8_t compare(int32_t start,
00258 int32_t length,
00259 const UnicodeString& srcText,
00260 int32_t srcStart,
00261 int32_t srcLength) const;
00262
00275 inline int8_t compare(const UChar *srcChars,
00276 int32_t srcLength) const;
00277
00292 inline int8_t compare(int32_t start,
00293 int32_t length,
00294 const UChar *srcChars) const;
00295
00313 inline int8_t compare(int32_t start,
00314 int32_t length,
00315 const UChar *srcChars,
00316 int32_t srcStart,
00317 int32_t srcLength) const;
00318
00336 inline int8_t compareBetween(int32_t start,
00337 int32_t limit,
00338 const UnicodeString& srcText,
00339 int32_t srcStart,
00340 int32_t srcLimit) const;
00341
00359 inline int8_t compareCodePointOrder(const UnicodeString& text) const;
00360
00380 inline int8_t compareCodePointOrder(int32_t start,
00381 int32_t length,
00382 const UnicodeString& srcText) const;
00383
00405 inline int8_t compareCodePointOrder(int32_t start,
00406 int32_t length,
00407 const UnicodeString& srcText,
00408 int32_t srcStart,
00409 int32_t srcLength) const;
00410
00429 inline int8_t compareCodePointOrder(const UChar *srcChars,
00430 int32_t srcLength) const;
00431
00451 inline int8_t compareCodePointOrder(int32_t start,
00452 int32_t length,
00453 const UChar *srcChars) const;
00454
00476 inline int8_t compareCodePointOrder(int32_t start,
00477 int32_t length,
00478 const UChar *srcChars,
00479 int32_t srcStart,
00480 int32_t srcLength) const;
00481
00503 inline int8_t compareCodePointOrderBetween(int32_t start,
00504 int32_t limit,
00505 const UnicodeString& srcText,
00506 int32_t srcStart,
00507 int32_t srcLimit) const;
00508
00518 inline int8_t caseCompare(const UnicodeString& text, uint32_t options) const;
00519
00531 inline int8_t caseCompare(int32_t start,
00532 int32_t length,
00533 const UnicodeString& srcText,
00534 uint32_t options) const;
00535
00549 inline int8_t caseCompare(int32_t start,
00550 int32_t length,
00551 const UnicodeString& srcText,
00552 int32_t srcStart,
00553 int32_t srcLength,
00554 uint32_t options) const;
00555
00566 inline int8_t caseCompare(const UChar *srcChars,
00567 int32_t srcLength,
00568 uint32_t options) const;
00569
00581 inline int8_t caseCompare(int32_t start,
00582 int32_t length,
00583 const UChar *srcChars,
00584 uint32_t options) const;
00585
00599 inline int8_t caseCompare(int32_t start,
00600 int32_t length,
00601 const UChar *srcChars,
00602 int32_t srcStart,
00603 int32_t srcLength,
00604 uint32_t options) const;
00605
00619 inline int8_t caseCompareBetween(int32_t start,
00620 int32_t limit,
00621 const UnicodeString& srcText,
00622 int32_t srcStart,
00623 int32_t srcLimit,
00624 uint32_t options) const;
00625
00633 inline UBool startsWith(const UnicodeString& text) const;
00634
00645 inline UBool startsWith(const UnicodeString& srcText,
00646 int32_t srcStart,
00647 int32_t srcLength) const;
00648
00657 inline UBool startsWith(const UChar *srcChars,
00658 int32_t srcLength) const;
00659
00669 inline UBool startsWith(const UChar *srcChars,
00670 int32_t srcStart,
00671 int32_t srcLength) const;
00672
00680 inline UBool endsWith(const UnicodeString& text) const;
00681
00692 inline UBool endsWith(const UnicodeString& srcText,
00693 int32_t srcStart,
00694 int32_t srcLength) const;
00695
00704 inline UBool endsWith(const UChar *srcChars,
00705 int32_t srcLength) const;
00706
00717 inline UBool endsWith(const UChar *srcChars,
00718 int32_t srcStart,
00719 int32_t srcLength) const;
00720
00721
00722
00723
00732 inline int32_t indexOf(const UnicodeString& text) const;
00733
00743 inline int32_t indexOf(const UnicodeString& text,
00744 int32_t start) const;
00745
00757 inline int32_t indexOf(const UnicodeString& text,
00758 int32_t start,
00759 int32_t length) const;
00760
00777 inline int32_t indexOf(const UnicodeString& srcText,
00778 int32_t srcStart,
00779 int32_t srcLength,
00780 int32_t start,
00781 int32_t length) const;
00782
00794 inline int32_t indexOf(const UChar *srcChars,
00795 int32_t srcLength,
00796 int32_t start) const;
00797
00810 inline int32_t indexOf(const UChar *srcChars,
00811 int32_t srcLength,
00812 int32_t start,
00813 int32_t length) const;
00814
00831 int32_t indexOf(const UChar *srcChars,
00832 int32_t srcStart,
00833 int32_t srcLength,
00834 int32_t start,
00835 int32_t length) const;
00836
00844 inline int32_t indexOf(UChar c) const;
00845
00867 inline int32_t indexOf(UChar32 c) const;
00868
00877 inline int32_t indexOf(UChar c,
00878 int32_t start) const;
00879
00902 inline int32_t indexOf(UChar32 c,
00903 int32_t start) const;
00904
00915 inline int32_t indexOf(UChar c,
00916 int32_t start,
00917 int32_t length) const;
00918
00943 inline int32_t indexOf(UChar32 c,
00944 int32_t start,
00945 int32_t length) const;
00946
00955 inline int32_t lastIndexOf(const UnicodeString& text) const;
00956
00966 inline int32_t lastIndexOf(const UnicodeString& text,
00967 int32_t start) const;
00968
00980 inline int32_t lastIndexOf(const UnicodeString& text,
00981 int32_t start,
00982 int32_t length) const;
00983
01000 inline int32_t lastIndexOf(const UnicodeString& srcText,
01001 int32_t srcStart,
01002 int32_t srcLength,
01003 int32_t start,
01004 int32_t length) const;
01005
01016 inline int32_t lastIndexOf(const UChar *srcChars,
01017 int32_t srcLength,
01018 int32_t start) const;
01019
01032 inline int32_t lastIndexOf(const UChar *srcChars,
01033 int32_t srcLength,
01034 int32_t start,
01035 int32_t length) const;
01036
01053 int32_t lastIndexOf(const UChar *srcChars,
01054 int32_t srcStart,
01055 int32_t srcLength,
01056 int32_t start,
01057 int32_t length) const;
01058
01066 inline int32_t lastIndexOf(UChar c) const;
01067
01089 inline int32_t lastIndexOf(UChar32 c) const;
01090
01099 inline int32_t lastIndexOf(UChar c,
01100 int32_t start) const;
01101
01124 inline int32_t lastIndexOf(UChar32 c,
01125 int32_t start) const;
01126
01137 inline int32_t lastIndexOf(UChar c,
01138 int32_t start,
01139 int32_t length) const;
01140
01165 inline int32_t lastIndexOf(UChar32 c,
01166 int32_t start,
01167 int32_t length) const;
01168
01169
01170
01171
01178 inline UChar charAt(int32_t offset) const;
01179
01186 inline UChar operator [] (int32_t offset) const;
01187
01197 inline UChar32 char32At(int32_t offset) const;
01198
01213 inline int32_t getChar32Start(int32_t offset) const;
01214
01235 inline int32_t getCharStart(int32_t offset) const;
01236
01252 inline int32_t getChar32Limit(int32_t offset) const;
01253
01275 inline int32_t getCharLimit(int32_t offset) const;
01276
01318 int32_t moveIndex32(int32_t index, int32_t delta) const;
01319
01320
01321
01337 inline void extract(int32_t start,
01338 int32_t length,
01339 UChar *dst,
01340 int32_t dstStart = 0) const;
01341
01363 int32_t
01364 extract(UChar *dest, int32_t destCapacity,
01365 UErrorCode &errorCode) const;
01366
01377 inline void extract(int32_t start,
01378 int32_t length,
01379 UnicodeString& target) const;
01380
01392 inline void extractBetween(int32_t start,
01393 int32_t limit,
01394 UChar *dst,
01395 int32_t dstStart = 0) const;
01396
01406 virtual void extractBetween(int32_t start,
01407 int32_t limit,
01408 UnicodeString& target) const;
01409
01430 inline int32_t extract(int32_t start,
01431 int32_t startLength,
01432 char *target,
01433 const char *codepage = 0) const;
01434
01459 int32_t extract(int32_t start,
01460 int32_t startLength,
01461 char *target,
01462 uint32_t targetLength,
01463 const char *codepage = 0) const;
01464
01482 int32_t extract(char *dest, int32_t destCapacity,
01483 UConverter *cnv,
01484 UErrorCode &errorCode) const;
01485
01486
01487
01494 inline int32_t length(void) const;
01495
01508 int32_t
01509 countChar32(int32_t start=0, int32_t length=0x7fffffff) const;
01510
01516 inline UBool isEmpty(void) const;
01517
01527 inline UBool empty(void) const;
01528
01538 inline int32_t getCapacity(void) const;
01539
01540
01541
01547 inline int32_t hashCode(void) const;
01548
01555 inline UBool isBogus(void) const;
01556
01557
01558
01559
01560
01561
01562
01563
01571 UnicodeString& operator= (const UnicodeString& srcText);
01572
01580 inline UnicodeString& operator= (UChar ch);
01581
01589 inline UnicodeString& operator= (UChar32 ch);
01590
01604 inline UnicodeString& setTo(const UnicodeString& srcText,
01605 int32_t srcStart,
01606 int32_t srcLength);
01607
01616 inline UnicodeString& setTo(const UnicodeString& srcText);
01617
01626 inline UnicodeString& setTo(const UChar *srcChars,
01627 int32_t srcLength);
01628
01637 UnicodeString& setTo(UChar srcChar);
01638
01647 UnicodeString& setTo(UChar32 srcChar);
01648
01668 UnicodeString &setTo(UBool isTerminated,
01669 const UChar *text,
01670 int32_t textLength);
01671
01690 UnicodeString &setTo(UChar *buffer,
01691 int32_t buffLength,
01692 int32_t buffCapacity);
01693
01715 void setToBogus();
01716
01724 UnicodeString& setCharAt(int32_t offset,
01725 UChar ch);
01726
01727
01728
01729
01737 inline UnicodeString& operator+= (UChar ch);
01738
01746 inline UnicodeString& operator+= (UChar32 ch);
01747
01756 inline UnicodeString& operator+= (const UnicodeString& srcText);
01757
01772 inline UnicodeString& append(const UnicodeString& srcText,
01773 int32_t srcStart,
01774 int32_t srcLength);
01775
01783 inline UnicodeString& append(const UnicodeString& srcText);
01784
01798 inline UnicodeString& append(const UChar *srcChars,
01799 int32_t srcStart,
01800 int32_t srcLength);
01801
01810 inline UnicodeString& append(const UChar *srcChars,
01811 int32_t srcLength);
01812
01819 inline UnicodeString& append(UChar srcChar);
01820
01827 inline UnicodeString& append(UChar32 srcChar);
01828
01829
01830
01831
01845 inline UnicodeString& insert(int32_t start,
01846 const UnicodeString& srcText,
01847 int32_t srcStart,
01848 int32_t srcLength);
01849
01858 inline UnicodeString& insert(int32_t start,
01859 const UnicodeString& srcText);
01860
01874 inline UnicodeString& insert(int32_t start,
01875 const UChar *srcChars,
01876 int32_t srcStart,
01877 int32_t srcLength);
01878
01888 inline UnicodeString& insert(int32_t start,
01889 const UChar *srcChars,
01890 int32_t srcLength);
01891
01900 inline UnicodeString& insert(int32_t start,
01901 UChar srcChar);
01902
01911 inline UnicodeString& insert(int32_t start,
01912 UChar32 srcChar);
01913
01914
01915
01916
01934 UnicodeString& replace(int32_t start,
01935 int32_t length,
01936 const UnicodeString& srcText,
01937 int32_t srcStart,
01938 int32_t srcLength);
01939
01952 UnicodeString& replace(int32_t start,
01953 int32_t length,
01954 const UnicodeString& srcText);
01955
01973 UnicodeString& replace(int32_t start,
01974 int32_t length,
01975 const UChar *srcChars,
01976 int32_t srcStart,
01977 int32_t srcLength);
01978
01991 inline UnicodeString& replace(int32_t start,
01992 int32_t length,
01993 const UChar *srcChars,
01994 int32_t srcLength);
01995
02007 inline UnicodeString& replace(int32_t start,
02008 int32_t length,
02009 UChar srcChar);
02010
02022 inline UnicodeString& replace(int32_t start,
02023 int32_t length,
02024 UChar32 srcChar);
02025
02035 inline UnicodeString& replaceBetween(int32_t start,
02036 int32_t limit,
02037 const UnicodeString& srcText);
02038
02053 inline UnicodeString& replaceBetween(int32_t start,
02054 int32_t limit,
02055 const UnicodeString& srcText,
02056 int32_t srcStart,
02057 int32_t srcLimit);
02058
02069 virtual void handleReplaceBetween(int32_t start,
02070 int32_t limit,
02071 const UnicodeString& text);
02072
02088 virtual void copy(int32_t start, int32_t limit, int32_t dest);
02089
02090
02091
02100 inline UnicodeString& findAndReplace(const UnicodeString& oldText,
02101 const UnicodeString& newText);
02102
02114 inline UnicodeString& findAndReplace(int32_t start,
02115 int32_t length,
02116 const UnicodeString& oldText,
02117 const UnicodeString& newText);
02118
02136 UnicodeString& findAndReplace(int32_t start,
02137 int32_t length,
02138 const UnicodeString& oldText,
02139 int32_t oldStart,
02140 int32_t oldLength,
02141 const UnicodeString& newText,
02142 int32_t newStart,
02143 int32_t newLength);
02144
02145
02146
02147
02153 inline UnicodeString& remove(void);
02154
02163 inline UnicodeString& remove(int32_t start,
02164 int32_t length = (int32_t)INT32_MAX);
02165
02174 inline UnicodeString& removeBetween(int32_t start,
02175 int32_t limit = (int32_t)INT32_MAX);
02176
02177
02178
02179
02191 UBool padLeading(int32_t targetLength,
02192 UChar padChar = 0x0020);
02193
02205 UBool padTrailing(int32_t targetLength,
02206 UChar padChar = 0x0020);
02207
02214 inline UBool truncate(int32_t targetLength);
02215
02221 UnicodeString& trim(void);
02222
02223
02224
02225
02231 inline UnicodeString& reverse(void);
02232
02241 inline UnicodeString& reverse(int32_t start,
02242 int32_t length);
02243
02250 UnicodeString& toUpper(void);
02251
02259 UnicodeString& toUpper(const Locale& locale);
02260
02267 UnicodeString& toLower(void);
02268
02276 UnicodeString& toLower(const Locale& locale);
02277
02303 UnicodeString &toTitle(BreakIterator *titleIter);
02304
02331 UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale);
02332
02344 UnicodeString &foldCase(uint32_t options=0 );
02345
02346
02347
02348
02349
02389 UChar *getBuffer(int32_t minCapacity);
02390
02411 void releaseBuffer(int32_t newLength=-1);
02412
02441 inline const UChar *getBuffer() const;
02442
02443
02444
02445
02446
02450 UnicodeString();
02451
02463 UnicodeString(int32_t capacity, UChar32 c, int32_t count);
02464
02470 UnicodeString(UChar ch);
02471
02477 UnicodeString(UChar32 ch);
02478
02485 UnicodeString(const UChar *text);
02486
02494 UnicodeString(const UChar *text,
02495 int32_t textLength);
02496
02516 UnicodeString(UBool isTerminated,
02517 const UChar *text,
02518 int32_t textLength);
02519
02538 UnicodeString(UChar *buffer, int32_t buffLength, int32_t buffCapacity);
02539
02551 UnicodeString(const char *codepageData,
02552 const char *codepage = 0);
02553
02566 UnicodeString(const char *codepageData,
02567 int32_t dataLength,
02568 const char *codepage = 0);
02569
02591 UnicodeString(
02592 const char *src, int32_t srcLength,
02593 UConverter *cnv,
02594 UErrorCode &errorCode);
02595
02596
02602 UnicodeString(const UnicodeString& that);
02603
02607 ~UnicodeString();
02608
02609
02610
02611
02634 int32_t numDisplayCells(int32_t start = 0,
02635 int32_t length = INT32_MAX,
02636 UBool asian = TRUE) const;
02637
02645 UCharReference operator[] (int32_t pos);
02646
02680 UnicodeString unescape() const;
02681
02701 UChar32 unescapeAt(int32_t &offset) const;
02702
02703
02704
02705
02706
02707 protected:
02711 virtual int32_t getLength() const;
02712
02717 virtual UChar getCharAt(int32_t offset) const;
02718
02723 virtual UChar32 getChar32At(int32_t offset) const;
02724
02725 private:
02726
02727 inline int8_t
02728 doCompare(int32_t start,
02729 int32_t length,
02730 const UnicodeString& srcText,
02731 int32_t srcStart,
02732 int32_t srcLength) const;
02733
02734 int8_t doCompare(int32_t start,
02735 int32_t length,
02736 const UChar *srcChars,
02737 int32_t srcStart,
02738 int32_t srcLength) const;
02739
02740 inline int8_t
02741 doCompareCodePointOrder(int32_t start,
02742 int32_t length,
02743 const UnicodeString& srcText,
02744 int32_t srcStart,
02745 int32_t srcLength) const;
02746
02747 int8_t doCompareCodePointOrder(int32_t start,
02748 int32_t length,
02749 const UChar *srcChars,
02750 int32_t srcStart,
02751 int32_t srcLength) const;
02752
02753 inline int8_t
02754 doCaseCompare(int32_t start,
02755 int32_t length,
02756 const UnicodeString &srcText,
02757 int32_t srcStart,
02758 int32_t srcLength,
02759 uint32_t options) const;
02760
02761 int8_t
02762 doCaseCompare(int32_t start,
02763 int32_t length,
02764 const UChar *srcChars,
02765 int32_t srcStart,
02766 int32_t srcLength,
02767 uint32_t options) const;
02768
02769 int32_t doIndexOf(UChar c,
02770 int32_t start,
02771 int32_t length) const;
02772
02773
02774 int32_t doIndexOf(UChar32 c,
02775 int32_t start,
02776 int32_t length) const;
02777
02778 int32_t doLastIndexOf(UChar c,
02779 int32_t start,
02780 int32_t length) const;
02781
02782
02783 int32_t doLastIndexOf(UChar32 c,
02784 int32_t start,
02785 int32_t length) const;
02786
02787 void doExtract(int32_t start,
02788 int32_t length,
02789 UChar *dst,
02790 int32_t dstStart) const;
02791
02792 inline void doExtract(int32_t start,
02793 int32_t length,
02794 UnicodeString& target) const;
02795
02796 inline UChar doCharAt(int32_t offset) const;
02797
02798 UnicodeString& doReplace(int32_t start,
02799 int32_t length,
02800 const UnicodeString& srcText,
02801 int32_t srcStart,
02802 int32_t srcLength);
02803
02804 UnicodeString& doReplace(int32_t start,
02805 int32_t length,
02806 const UChar *srcChars,
02807 int32_t srcStart,
02808 int32_t srcLength);
02809
02810 UnicodeString& doReverse(int32_t start,
02811 int32_t length);
02812
02813
02814 int32_t doHashCode(void) const;
02815
02816
02817 inline UChar* getArrayStart(void);
02818 inline const UChar* getArrayStart(void) const;
02819
02820
02821
02822
02823
02824 UBool allocate(int32_t capacity);
02825
02826
02827 void releaseArray(void);
02828
02829
02830 inline void pinIndices(int32_t& start,
02831 int32_t& length) const;
02832
02833
02834 int32_t doExtract(int32_t start, int32_t length,
02835 char *dest, int32_t destCapacity,
02836 UConverter *cnv,
02837 UErrorCode &errorCode) const;
02838
02839
02840
02841
02842
02843
02844
02845
02846
02847
02848
02849 void doCodepageCreate(const char *codepageData,
02850 int32_t dataLength,
02851 const char *codepage);
02852
02853
02854
02855
02856
02857 void
02858 doCodepageCreate(const char *codepageData,
02859 int32_t dataLength,
02860 UConverter *converter,
02861 UErrorCode &status);
02862
02863
02864
02865
02866
02867
02868
02869
02870
02871
02872
02873 UBool cloneArrayIfNeeded(int32_t newCapacity = -1,
02874 int32_t growCapacity = -1,
02875 UBool doCopyArray = TRUE,
02876 int32_t **pBufferToDelete = 0,
02877 UBool forceClone = FALSE);
02878
02879
02880 UnicodeString &
02881 caseMap(BreakIterator *titleIter,
02882 const Locale& locale,
02883 uint32_t options,
02884 int32_t toWhichCase);
02885
02886
02887 void addRef(void);
02888 int32_t removeRef(void);
02889 int32_t refCount(void) const;
02890 int32_t setRefCount(int32_t count);
02891
02892
02893 enum {
02894 #if UTF_SIZE==8
02895 US_STACKBUF_SIZE=14,
02896 #elif UTF_SIZE==16
02897 US_STACKBUF_SIZE=7,
02898 #else // UTF_SIZE==32
02899 US_STACKBUF_SIZE=3,
02900 #endif
02901 kInvalidUChar=0xffff,
02902 kGrowSize=128,
02903 kInvalidHashCode=0,
02904 kEmptyHashCode=1,
02905
02906
02907 kIsBogus=1,
02908 kUsingStackBuffer=2,
02909 kRefCounted=4,
02910 kBufferIsReadonly=8,
02911 kOpenGetBuffer=16,
02912
02913
02914
02915 kShortString=kUsingStackBuffer,
02916 kLongString=kRefCounted,
02917 kReadonlyAlias=kBufferIsReadonly,
02918 kWritableAlias=0
02919 };
02920
02921 friend class UnicodeConverter;
02922
02923 friend class StringCharacterIterator;
02924 friend class StringThreadTest;
02925
02926
02927
02928
02929
02930
02931
02932
02933
02934
02935
02936
02937
02938 int32_t fLength;
02939 int32_t fCapacity;
02940 UChar *fArray;
02941 uint16_t fFlags;
02942 #if UTF_SIZE==32
02943 uint16_t fPadding;
02944 #endif
02945 UChar fStackBuffer [ US_STACKBUF_SIZE ];
02946 };
02947
02948 U_NAMESPACE_END
02949
02950
02951
02952
02953
02954 inline void
02955 uprv_arrayCopy(const U_NAMESPACE_QUALIFIER UnicodeString *src, U_NAMESPACE_QUALIFIER UnicodeString *dst, int32_t count)
02956 { while(count-- > 0) *dst++ = *src++; }
02957
02958 inline void
02959 uprv_arrayCopy(const U_NAMESPACE_QUALIFIER UnicodeString *src, int32_t srcStart,
02960 U_NAMESPACE_QUALIFIER UnicodeString *dst, int32_t dstStart, int32_t count)
02961 { uprv_arrayCopy(src+srcStart, dst+dstStart, count); }
02962
02963 U_NAMESPACE_BEGIN
02964
02965
02966
02967
02968
02969
02970
02971 inline UBool
02972 UnicodeString::operator== (const UnicodeString& text) const
02973 {
02974 if(isBogus()) {
02975 return text.isBogus();
02976 } else {
02977 return
02978 !text.isBogus() &&
02979 fLength == text.fLength &&
02980 doCompare(0, fLength, text, 0, text.fLength) == 0;
02981 }
02982 }
02983
02984 inline UBool
02985 UnicodeString::operator!= (const UnicodeString& text) const
02986 { return (! operator==(text)); }
02987
02988 inline UBool
02989 UnicodeString::operator> (const UnicodeString& text) const
02990 { return doCompare(0, fLength, text, 0, text.fLength) == 1; }
02991
02992 inline UBool
02993 UnicodeString::operator< (const UnicodeString& text) const
02994 { return doCompare(0, fLength, text, 0, text.fLength) == -1; }
02995
02996 inline UBool
02997 UnicodeString::operator>= (const UnicodeString& text) const
02998 { return doCompare(0, fLength, text, 0, text.fLength) != -1; }
02999
03000 inline UBool
03001 UnicodeString::operator<= (const UnicodeString& text) const
03002 { return doCompare(0, fLength, text, 0, text.fLength) != 1; }
03003
03004 inline int8_t
03005 UnicodeString::compare(const UnicodeString& text) const
03006 { return doCompare(0, fLength, text, 0, text.fLength); }
03007
03008 inline int8_t
03009 UnicodeString::compare(int32_t start,
03010 int32_t length,
03011 const UnicodeString& srcText) const
03012 { return doCompare(start, length, srcText, 0, srcText.fLength); }
03013
03014 inline int8_t
03015 UnicodeString::compare(const UChar *srcChars,
03016 int32_t srcLength) const
03017 { return doCompare(0, fLength, srcChars, 0, srcLength); }
03018
03019 inline int8_t
03020 UnicodeString::compare(int32_t start,
03021 int32_t length,
03022 const UnicodeString& srcText,
03023 int32_t srcStart,
03024 int32_t srcLength) const
03025 { return doCompare(start, length, srcText, srcStart, srcLength); }
03026
03027 inline int8_t
03028 UnicodeString::compare(int32_t start,
03029 int32_t length,
03030 const UChar *srcChars) const
03031 { return doCompare(start, length, srcChars, 0, length); }
03032
03033 inline int8_t
03034 UnicodeString::compare(int32_t start,
03035 int32_t length,
03036 const UChar *srcChars,
03037 int32_t srcStart,
03038 int32_t srcLength) const
03039 { return doCompare(start, length, srcChars, srcStart, srcLength); }
03040
03041 inline int8_t
03042 UnicodeString::compareBetween(int32_t start,
03043 int32_t limit,
03044 const UnicodeString& srcText,
03045 int32_t srcStart,
03046 int32_t srcLimit) const
03047 { return doCompare(start, limit - start,
03048 srcText, srcStart, srcLimit - srcStart); }
03049
03050 inline int8_t
03051 UnicodeString::doCompare(int32_t start,
03052 int32_t length,
03053 const UnicodeString& srcText,
03054 int32_t srcStart,
03055 int32_t srcLength) const
03056 {
03057 const UChar *srcChars;
03058 if(!srcText.isBogus()) {
03059 srcText.pinIndices(srcStart, srcLength);
03060 srcChars=srcText.getArrayStart();
03061 } else {
03062 srcChars=0;
03063 }
03064 return doCompare(start, length, srcChars, srcStart, srcLength);
03065 }
03066
03067 inline int8_t
03068 UnicodeString::compareCodePointOrder(const UnicodeString& text) const
03069 { return doCompareCodePointOrder(0, fLength, text, 0, text.fLength); }
03070
03071 inline int8_t
03072 UnicodeString::compareCodePointOrder(int32_t start,
03073 int32_t length,
03074 const UnicodeString& srcText) const
03075 { return doCompareCodePointOrder(start, length, srcText, 0, srcText.fLength); }
03076
03077 inline int8_t
03078 UnicodeString::compareCodePointOrder(const UChar *srcChars,
03079 int32_t srcLength) const
03080 { return doCompareCodePointOrder(0, fLength, srcChars, 0, srcLength); }
03081
03082 inline int8_t
03083 UnicodeString::compareCodePointOrder(int32_t start,
03084 int32_t length,
03085 const UnicodeString& srcText,
03086 int32_t srcStart,
03087 int32_t srcLength) const
03088 { return doCompareCodePointOrder(start, length, srcText, srcStart, srcLength); }
03089
03090 inline int8_t
03091 UnicodeString::compareCodePointOrder(int32_t start,
03092 int32_t length,
03093 const UChar *srcChars) const
03094 { return doCompareCodePointOrder(start, length, srcChars, 0, length); }
03095
03096 inline int8_t
03097 UnicodeString::compareCodePointOrder(int32_t start,
03098 int32_t length,
03099 const UChar *srcChars,
03100 int32_t srcStart,
03101 int32_t srcLength) const
03102 { return doCompareCodePointOrder(start, length, srcChars, srcStart, srcLength); }
03103
03104 inline int8_t
03105 UnicodeString::compareCodePointOrderBetween(int32_t start,
03106 int32_t limit,
03107 const UnicodeString& srcText,
03108 int32_t srcStart,
03109 int32_t srcLimit) const
03110 { return doCompareCodePointOrder(start, limit - start,
03111 srcText, srcStart, srcLimit - srcStart); }
03112
03113 inline int8_t
03114 UnicodeString::doCompareCodePointOrder(int32_t start,
03115 int32_t length,
03116 const UnicodeString& srcText,
03117 int32_t srcStart,
03118 int32_t srcLength) const
03119 {
03120 const UChar *srcChars;
03121 if(!srcText.isBogus()) {
03122 srcText.pinIndices(srcStart, srcLength);
03123 srcChars=srcText.getArrayStart();
03124 } else {
03125 srcChars=0;
03126 }
03127 return doCompareCodePointOrder(start, length, srcChars, srcStart, srcLength);
03128 }
03129
03130 inline int8_t
03131 UnicodeString::caseCompare(const UnicodeString &text, uint32_t options) const {
03132 return doCaseCompare(0, fLength, text, 0, text.fLength, options);
03133 }
03134
03135 inline int8_t
03136 UnicodeString::caseCompare(int32_t start,
03137 int32_t length,
03138 const UnicodeString &srcText,
03139 uint32_t options) const {
03140 return doCaseCompare(start, length, srcText, 0, srcText.fLength, options);
03141 }
03142
03143 inline int8_t
03144 UnicodeString::caseCompare(const UChar *srcChars,
03145 int32_t srcLength,
03146 uint32_t options) const {
03147 return doCaseCompare(0, fLength, srcChars, 0, srcLength, options);
03148 }
03149
03150 inline int8_t
03151 UnicodeString::caseCompare(int32_t start,
03152 int32_t length,
03153 const UnicodeString &srcText,
03154 int32_t srcStart,
03155 int32_t srcLength,
03156 uint32_t options) const {
03157 return doCaseCompare(start, length, srcText, srcStart, srcLength, options);
03158 }
03159
03160 inline int8_t
03161 UnicodeString::caseCompare(int32_t start,
03162 int32_t length,
03163 const UChar *srcChars,
03164 uint32_t options) const {
03165 return doCaseCompare(start, length, srcChars, 0, length, options);
03166 }
03167
03168 inline int8_t
03169 UnicodeString::caseCompare(int32_t start,
03170 int32_t length,
03171 const UChar *srcChars,
03172 int32_t srcStart,
03173 int32_t srcLength,
03174 uint32_t options) const {
03175 return doCaseCompare(start, length, srcChars, srcStart, srcLength, options);
03176 }
03177
03178 inline int8_t
03179 UnicodeString::caseCompareBetween(int32_t start,
03180 int32_t limit,
03181 const UnicodeString &srcText,
03182 int32_t srcStart,
03183 int32_t srcLimit,
03184 uint32_t options) const {
03185 return doCaseCompare(start, limit - start, srcText, srcStart, srcLimit - srcStart, options);
03186 }
03187
03188 inline int8_t
03189 UnicodeString::doCaseCompare(int32_t start,
03190 int32_t length,
03191 const UnicodeString &srcText,
03192 int32_t srcStart,
03193 int32_t srcLength,
03194 uint32_t options) const
03195 {
03196 const UChar *srcChars;
03197 if(!srcText.isBogus()) {
03198 srcText.pinIndices(srcStart, srcLength);
03199 srcChars=srcText.getArrayStart();
03200 } else {
03201 srcChars=0;
03202 }
03203 return doCaseCompare(start, length, srcChars, srcStart, srcLength, options);
03204 }
03205
03206 inline int32_t
03207 UnicodeString::indexOf(const UnicodeString& text) const
03208 { return indexOf(text, 0, text.fLength, 0, fLength); }
03209
03210 inline int32_t
03211 UnicodeString::indexOf(const UnicodeString& text,
03212 int32_t start) const
03213 { return indexOf(text, 0, text.fLength, start, fLength - start); }
03214
03215 inline int32_t
03216 UnicodeString::indexOf(const UnicodeString& text,
03217 int32_t start,
03218 int32_t length) const
03219 { return indexOf(text, 0, text.fLength, start, length); }
03220
03221 inline int32_t
03222 UnicodeString::indexOf(const UnicodeString& srcText,
03223 int32_t srcStart,
03224 int32_t srcLength,
03225 int32_t start,
03226 int32_t length) const
03227 {
03228 if(!srcText.isBogus()) {
03229 srcText.pinIndices(srcStart, srcLength);
03230 if(srcLength > 0) {
03231 return indexOf(srcText.getArrayStart(), srcStart, srcLength, start, length);
03232 }
03233 }
03234 return -1;
03235 }
03236
03237 inline int32_t
03238 UnicodeString::indexOf(const UChar *srcChars,
03239 int32_t srcLength,
03240 int32_t start) const
03241 { return indexOf(srcChars, 0, srcLength, start, fLength - start); }
03242
03243 inline int32_t
03244 UnicodeString::indexOf(const UChar *srcChars,
03245 int32_t srcLength,
03246 int32_t start,
03247 int32_t length) const
03248 { return indexOf(srcChars, 0, srcLength, start, length); }
03249
03250 inline int32_t
03251 UnicodeString::indexOf(UChar c) const
03252 { return doIndexOf(c, 0, fLength); }
03253
03254 inline int32_t
03255 UnicodeString::indexOf(UChar32 c) const {
03256 return indexOf(c, 0, fLength);
03257 }
03258
03259 inline int32_t
03260 UnicodeString::indexOf(UChar c,
03261 int32_t start) const
03262 { return doIndexOf(c, start, fLength - start); }
03263
03264 inline int32_t
03265 UnicodeString::indexOf(UChar32 c,
03266 int32_t start) const {
03267 return indexOf(c, start, fLength - start);
03268 }
03269
03270 inline int32_t
03271 UnicodeString::indexOf(UChar c,
03272 int32_t start,
03273 int32_t length) const
03274 { return doIndexOf(c, start, length); }
03275
03276 inline int32_t
03277 UnicodeString::indexOf(UChar32 c,
03278 int32_t start,
03279 int32_t length) const {
03280 if((uint32_t)c<0xd800) {
03281 return doIndexOf((UChar)c, start, length);
03282 } else {
03283 return doIndexOf(c, start, length);
03284 }
03285 }
03286
03287 inline int32_t
03288 UnicodeString::lastIndexOf(const UnicodeString& text) const
03289 { return lastIndexOf(text, 0, text.fLength, 0, fLength); }
03290
03291 inline int32_t
03292 UnicodeString::lastIndexOf(const UnicodeString& text,
03293 int32_t start) const
03294 { return lastIndexOf(text, 0, text.fLength, start, fLength - start); }
03295
03296 inline int32_t
03297 UnicodeString::lastIndexOf(const UnicodeString& text,
03298 int32_t start,
03299 int32_t length) const
03300 { return lastIndexOf(text, 0, text.fLength, start, length); }
03301
03302 inline int32_t
03303 UnicodeString::lastIndexOf(const UnicodeString& srcText,
03304 int32_t srcStart,
03305 int32_t srcLength,
03306 int32_t start,
03307 int32_t length) const
03308 {
03309 if(!srcText.isBogus()) {
03310 srcText.pinIndices(srcStart, srcLength);
03311 if(srcLength > 0) {
03312 return lastIndexOf(srcText.getArrayStart(), srcStart, srcLength, start, length);
03313 }
03314 }
03315 return -1;
03316 }
03317
03318 inline int32_t
03319 UnicodeString::lastIndexOf(const UChar *srcChars,
03320 int32_t srcLength,
03321 int32_t start) const
03322 { return lastIndexOf(srcChars, 0, srcLength, start, fLength - start); }
03323
03324 inline int32_t
03325 UnicodeString::lastIndexOf(const UChar *srcChars,
03326 int32_t srcLength,
03327 int32_t start,
03328 int32_t length) const
03329 { return lastIndexOf(srcChars, 0, srcLength, start, length); }
03330
03331 inline int32_t
03332 UnicodeString::lastIndexOf(UChar c) const
03333 { return doLastIndexOf(c, 0, fLength); }
03334
03335 inline int32_t
03336 UnicodeString::lastIndexOf(UChar32 c) const {
03337 return lastIndexOf(c, 0, fLength);
03338 }
03339
03340 inline int32_t
03341 UnicodeString::lastIndexOf(UChar c,
03342 int32_t start) const
03343 { return doLastIndexOf(c, start, fLength - start); }
03344
03345 inline int32_t
03346 UnicodeString::lastIndexOf(UChar32 c,
03347 int32_t start) const {
03348 return lastIndexOf(c, start, fLength - start);
03349 }
03350
03351 inline int32_t
03352 UnicodeString::lastIndexOf(UChar c,
03353 int32_t start,
03354 int32_t length) const
03355 { return doLastIndexOf(c, start, length); }
03356
03357 inline int32_t
03358 UnicodeString::lastIndexOf(UChar32 c,
03359 int32_t start,
03360 int32_t length) const {
03361 if((uint32_t)c<0xd800) {
03362 return doLastIndexOf((UChar)c, start, length);
03363 } else {
03364 return doLastIndexOf(c, start, length);
03365 }
03366 }
03367
03368 inline UBool
03369 UnicodeString::startsWith(const UnicodeString& text) const
03370 { return compare(0, text.fLength, text, 0, text.fLength) == 0; }
03371
03372 inline UBool
03373 UnicodeString::startsWith(const UnicodeString& srcText,
03374 int32_t srcStart,
03375 int32_t srcLength) const
03376 { return doCompare(0, srcLength, srcText, srcStart, srcLength) == 0; }
03377
03378 inline UBool
03379 UnicodeString::startsWith(const UChar *srcChars,
03380 int32_t srcLength) const
03381 { return doCompare(0, srcLength, srcChars, 0, srcLength) == 0; }
03382
03383 inline UBool
03384 UnicodeString::startsWith(const UChar *srcChars,
03385 int32_t srcStart,
03386 int32_t srcLength) const
03387 { return doCompare(0, srcLength, srcChars, srcStart, srcLength) == 0;}
03388
03389 inline UBool
03390 UnicodeString::endsWith(const UnicodeString& text) const
03391 { return doCompare(fLength - text.fLength, text.fLength,
03392 text, 0, text.fLength) == 0; }
03393
03394 inline UBool
03395 UnicodeString::endsWith(const UnicodeString& srcText,
03396 int32_t srcStart,
03397 int32_t srcLength) const
03398 { return doCompare(fLength - srcLength, srcLength,
03399 srcText, srcStart, srcLength) == 0; }
03400
03401 inline UBool
03402 UnicodeString::endsWith(const UChar *srcChars,
03403 int32_t srcLength) const
03404 { return doCompare(fLength - srcLength, srcLength,
03405 srcChars, 0, srcLength) == 0; }
03406
03407 inline UBool
03408 UnicodeString::endsWith(const UChar *srcChars,
03409 int32_t srcStart,
03410 int32_t srcLength) const
03411 { return doCompare(fLength - srcLength, srcLength,
03412 srcChars, srcStart, srcLength) == 0;}
03413
03414
03415
03416 inline UnicodeString&
03417 UnicodeString::replace(int32_t start,
03418 int32_t length,
03419 const UnicodeString& srcText)
03420 { return doReplace(start, length, srcText, 0, srcText.fLength); }
03421
03422 inline UnicodeString&
03423 UnicodeString::replace(int32_t start,
03424 int32_t length,
03425 const UnicodeString& srcText,
03426 int32_t srcStart,
03427 int32_t srcLength)
03428 { return doReplace(start, length, srcText, srcStart, srcLength); }
03429
03430 inline UnicodeString&
03431 UnicodeString::replace(int32_t start,
03432 int32_t length,
03433 const UChar *srcChars,
03434 int32_t srcLength)
03435 { return doReplace(start, length, srcChars, 0, srcLength); }
03436
03437 inline UnicodeString&
03438 UnicodeString::replace(int32_t start,
03439 int32_t length,
03440 const UChar *srcChars,
03441 int32_t srcStart,
03442 int32_t srcLength)
03443 { return doReplace(start, length, srcChars, srcStart, srcLength); }
03444
03445 inline UnicodeString&
03446 UnicodeString::replace(int32_t start,
03447 int32_t length,
03448 UChar srcChar)
03449 { return doReplace(start, length, &srcChar, 0, 1); }
03450
03451 inline UnicodeString&
03452 UnicodeString::replace(int32_t start,
03453 int32_t length,
03454 UChar32 srcChar) {
03455 UChar buffer[UTF_MAX_CHAR_LENGTH];
03456 int32_t count = 0;
03457 UTF_APPEND_CHAR_UNSAFE(buffer, count, srcChar);
03458 return doReplace(start, length, buffer, 0, count);
03459 }
03460
03461 inline UnicodeString&
03462 UnicodeString::replaceBetween(int32_t start,
03463 int32_t limit,
03464 const UnicodeString& srcText)
03465 { return doReplace(start, limit - start, srcText, 0, srcText.fLength); }
03466
03467 inline UnicodeString&
03468 UnicodeString::replaceBetween(int32_t start,
03469 int32_t limit,
03470 const UnicodeString& srcText,
03471 int32_t srcStart,
03472 int32_t srcLimit)
03473 { return doReplace(start, limit - start, srcText, srcStart, srcLimit - srcStart); }
03474
03475 inline UnicodeString&
03476 UnicodeString::findAndReplace(const UnicodeString& oldText,
03477 const UnicodeString& newText)
03478 { return findAndReplace(0, fLength, oldText, 0, oldText.fLength,
03479 newText, 0, newText.fLength); }
03480
03481 inline UnicodeString&
03482 UnicodeString::findAndReplace(int32_t start,
03483 int32_t length,
03484 const UnicodeString& oldText,
03485 const UnicodeString& newText)
03486 { return findAndReplace(start, length, oldText, 0, oldText.fLength,
03487 newText, 0, newText.fLength); }
03488
03489
03490
03491
03492 inline void
03493 UnicodeString::doExtract(int32_t start,
03494 int32_t length,
03495 UnicodeString& target) const
03496 { target.replace(0, target.fLength, *this, start, length); }
03497
03498 inline void
03499 UnicodeString::extract(int32_t start,
03500 int32_t length,
03501 UChar *target,
03502 int32_t targetStart) const
03503 { doExtract(start, length, target, targetStart); }
03504
03505 inline void
03506 UnicodeString::extract(int32_t start,
03507 int32_t length,
03508 UnicodeString& target) const
03509 { doExtract(start, length, target); }
03510
03511 inline int32_t
03512 UnicodeString::extract(int32_t start,
03513 int32_t length,
03514 char *dst,
03515 const char *codepage) const
03516
03517 {
03518
03519 return extract(start, length, dst, dst!=0 ? 0xffffffff : 0, codepage);
03520 }
03521
03522 inline void
03523 UnicodeString::extractBetween(int32_t start,
03524 int32_t limit,
03525 UChar *dst,
03526 int32_t dstStart) const
03527 { doExtract(start, limit - start, dst, dstStart); }
03528
03529 inline UChar
03530 UnicodeString::doCharAt(int32_t offset) const
03531 {
03532 if((uint32_t)offset < (uint32_t)fLength) {
03533 return fArray[offset];
03534 } else {
03535 return kInvalidUChar;
03536 }
03537 }
03538
03539 inline UChar
03540 UnicodeString::charAt(int32_t offset) const
03541 { return doCharAt(offset); }
03542
03543 inline UChar
03544 UnicodeString::operator[] (int32_t offset) const
03545 { return doCharAt(offset); }
03546
03547 inline UChar32
03548 UnicodeString::char32At(int32_t offset) const
03549 {
03550 if((uint32_t)offset < (uint32_t)fLength) {
03551 UChar32 c;
03552 UTF_GET_CHAR(fArray, 0, offset, fLength, c);
03553 return c;
03554 } else {
03555 return kInvalidUChar;
03556 }
03557 }
03558
03559 inline int32_t
03560 UnicodeString::getChar32Start(int32_t offset) const {
03561 if((uint32_t)offset < (uint32_t)fLength) {
03562 UTF_SET_CHAR_START(fArray, 0, offset);
03563 return offset;
03564 } else {
03565 return 0;
03566 }
03567 }
03568
03569 inline int32_t
03570 UnicodeString::getChar32Limit(int32_t offset) const {
03571 if((uint32_t)offset < (uint32_t)fLength) {
03572 UTF_SET_CHAR_LIMIT(fArray, 0, offset, fLength);
03573 return offset;
03574 } else {
03575 return fLength;
03576 }
03577 }
03578
03579 inline int32_t
03580 UnicodeString::getCharStart(int32_t offset) const {
03581 return getChar32Start(offset);
03582 }
03583
03584 inline int32_t
03585 UnicodeString::getCharLimit(int32_t offset) const {
03586 return getChar32Limit(offset);
03587 }
03588
03589 inline UBool
03590 UnicodeString::isEmpty() const {
03591 return fLength == 0;
03592 }
03593
03594 inline UBool
03595 UnicodeString::empty() const {
03596 return isEmpty();
03597 }
03598
03599
03600
03601
03602 inline int32_t
03603 UnicodeString::length() const
03604 { return fLength; }
03605
03606 inline int32_t
03607 UnicodeString::hashCode() const
03608 { return doHashCode(); }
03609
03610 inline const UChar *
03611 UnicodeString::getBuffer() const {
03612 if(!(fFlags&(kIsBogus|kOpenGetBuffer))) {
03613 return fArray;
03614 } else {
03615 return 0;
03616 }
03617 }
03618
03619
03620
03621
03622 inline UnicodeString&
03623 UnicodeString::operator= (UChar ch)
03624 { return doReplace(0, fLength, &ch, 0, 1); }
03625
03626 inline UnicodeString&
03627 UnicodeString::operator= (UChar32 ch)
03628 { return replace(0, fLength, ch); }
03629
03630 inline UnicodeString&
03631 UnicodeString::setTo(const UnicodeString& srcText,
03632 int32_t srcStart,
03633 int32_t srcLength)
03634 { return doReplace(0, fLength, srcText, srcStart, srcLength); }
03635
03636 inline UnicodeString&
03637 UnicodeString::setTo(const UnicodeString& srcText)
03638 { return doReplace(0, fLength, srcText, 0, srcText.fLength); }
03639
03640 inline UnicodeString&
03641 UnicodeString::setTo(const UChar *srcChars,
03642 int32_t srcLength)
03643 { return doReplace(0, fLength, srcChars, 0, srcLength); }
03644
03645 inline UnicodeString&
03646 UnicodeString::setTo(UChar srcChar)
03647 { return doReplace(0, fLength, &srcChar, 0, 1); }
03648
03649 inline UnicodeString&
03650 UnicodeString::setTo(UChar32 srcChar)
03651 { return replace(0, fLength, srcChar); }
03652
03653 inline UnicodeString&
03654 UnicodeString::operator+= (UChar ch)
03655 { return doReplace(fLength, 0, &ch, 0, 1); }
03656
03657 inline UnicodeString&
03658 UnicodeString::operator+= (UChar32 ch) {
03659 UChar buffer[UTF_MAX_CHAR_LENGTH];
03660 int32_t length = 0;
03661 UTF_APPEND_CHAR_UNSAFE(buffer, length, ch);
03662 return doReplace(fLength, 0, buffer, 0, length);
03663 }
03664
03665 inline UnicodeString&
03666 UnicodeString::operator+= (const UnicodeString& srcText)
03667 { return doReplace(fLength, 0, srcText, 0, srcText.fLength); }
03668
03669 inline UnicodeString&
03670 UnicodeString::append(const UnicodeString& srcText,
03671 int32_t srcStart,
03672 int32_t srcLength)
03673 { return doReplace(fLength, 0, srcText, srcStart, srcLength); }
03674
03675 inline UnicodeString&
03676 UnicodeString::append(const UnicodeString& srcText)
03677 { return doReplace(fLength, 0, srcText, 0, srcText.fLength); }
03678
03679 inline UnicodeString&
03680 UnicodeString::append(const UChar *srcChars,
03681 int32_t srcStart,
03682 int32_t srcLength)
03683 { return doReplace(fLength, 0, srcChars, srcStart, srcLength); }
03684
03685 inline UnicodeString&
03686 UnicodeString::append(const UChar *srcChars,
03687 int32_t srcLength)
03688 { return doReplace(fLength, 0, srcChars, 0, srcLength); }
03689
03690 inline UnicodeString&
03691 UnicodeString::append(UChar srcChar)
03692 { return doReplace(fLength, 0, &srcChar, 0, 1); }
03693
03694 inline UnicodeString&
03695 UnicodeString::append(UChar32 srcChar) {
03696 UChar buffer[UTF_MAX_CHAR_LENGTH];
03697 int32_t length = 0;
03698 UTF_APPEND_CHAR_UNSAFE(buffer, length, srcChar);
03699 return doReplace(fLength, 0, buffer, 0, length);
03700 }
03701
03702 inline UnicodeString&
03703 UnicodeString::insert(int32_t start,
03704 const UnicodeString& srcText,
03705 int32_t srcStart,
03706 int32_t srcLength)
03707 { return doReplace(start, 0, srcText, srcStart, srcLength); }
03708
03709 inline UnicodeString&
03710 UnicodeString::insert(int32_t start,
03711 const UnicodeString& srcText)
03712 { return doReplace(start, 0, srcText, 0, srcText.fLength); }
03713
03714 inline UnicodeString&
03715 UnicodeString::insert(int32_t start,
03716 const UChar *srcChars,
03717 int32_t srcStart,
03718 int32_t srcLength)
03719 { return doReplace(start, 0, srcChars, srcStart, srcLength); }
03720
03721 inline UnicodeString&
03722 UnicodeString::insert(int32_t start,
03723 const UChar *srcChars,
03724 int32_t srcLength)
03725 { return doReplace(start, 0, srcChars, 0, srcLength); }
03726
03727 inline UnicodeString&
03728 UnicodeString::insert(int32_t start,
03729 UChar srcChar)
03730 { return doReplace(start, 0, &srcChar, 0, 1); }
03731
03732 inline UnicodeString&
03733 UnicodeString::insert(int32_t start,
03734 UChar32 srcChar)
03735 { return replace(start, 0, srcChar); }
03736
03737
03738 inline UnicodeString&
03739 UnicodeString::remove(int32_t start,
03740 int32_t length)
03741 { return doReplace(start, length, NULL, 0, 0); }
03742
03743 inline UnicodeString&
03744 UnicodeString::remove()
03745 { return doReplace(0, fLength, 0, 0, 0); }
03746
03747 inline UnicodeString&
03748 UnicodeString::removeBetween(int32_t start,
03749 int32_t limit)
03750 { return doReplace(start, limit - start, NULL, 0, 0); }
03751
03752 inline UBool
03753 UnicodeString::truncate(int32_t targetLength)
03754 {
03755 if((uint32_t)targetLength < (uint32_t)fLength) {
03756 fLength = targetLength;
03757 return TRUE;
03758 } else {
03759 return FALSE;
03760 }
03761 }
03762
03763 inline UnicodeString&
03764 UnicodeString::reverse()
03765 { return doReverse(0, fLength); }
03766
03767 inline UnicodeString&
03768 UnicodeString::reverse(int32_t start,
03769 int32_t length)
03770 { return doReverse(start, length); }
03771
03772
03773
03774
03775
03776 inline UBool
03777 UnicodeString::isBogus() const
03778 { return (UBool)(fFlags & kIsBogus); }
03779
03780
03781
03782
03783
03784
03785 inline void
03786 UnicodeString::pinIndices(int32_t& start,
03787 int32_t& length) const
03788 {
03789
03790 if(start < 0) {
03791 start = 0;
03792 } else if(start > fLength) {
03793 start = fLength;
03794 }
03795 if(length < 0) {
03796 length = 0;
03797 } else if(length > (fLength - start)) {
03798 length = (fLength - start);
03799 }
03800 }
03801
03802 inline UChar*
03803 UnicodeString::getArrayStart()
03804 { return fArray; }
03805
03806 inline const UChar*
03807 UnicodeString::getArrayStart() const
03808 { return fArray; }
03809
03810 inline int32_t
03811 UnicodeString::getCapacity() const
03812 { return fCapacity; }
03813
03814 U_NAMESPACE_END
03815
03816
03817
03818
03819 U_NAMESPACE_BEGIN
03820
03821
03822
03823
03824 class U_COMMON_API UCharReference
03825 {
03826 public:
03827 UCharReference();
03828 inline UCharReference(UnicodeString *string,
03829 int32_t pos);
03830 inline UCharReference(const UCharReference& that);
03831 ~UCharReference();
03832
03833 inline UCharReference& operator= (const UCharReference& that);
03834 inline UCharReference& operator= (UChar c);
03835
03836 inline operator UChar();
03837
03838 private:
03839 UnicodeString *fString;
03840 int32_t fPos;
03841 };
03842
03843
03844
03845
03846
03847 inline
03848 UCharReference::UCharReference(UnicodeString *string,
03849 int32_t pos)
03850 : fString(string), fPos(pos)
03851 {}
03852
03853 inline
03854 UCharReference::UCharReference(const UCharReference& that)
03855 { this->operator=(that); }
03856
03857 inline
03858 UCharReference::~UCharReference()
03859 {}
03860
03861 inline UCharReference&
03862 UCharReference::operator= (const UCharReference& that)
03863 { fString->setCharAt(fPos, that.fString->charAt(that.fPos)); return *this; }
03864
03865 inline UCharReference&
03866 UCharReference::operator= (UChar c)
03867 { fString->setCharAt(fPos, c); return *this; }
03868
03869 inline
03870 UCharReference::operator UChar()
03871 { return fString->charAt(fPos); }
03872
03873 U_NAMESPACE_END
03874
03875 #endif