unistr.h

Go to the documentation of this file.
00001 /*
00002 **********************************************************************
00003 *   Copyright (C) 1998-2007, International Business Machines
00004 *   Corporation and others.  All Rights Reserved.
00005 **********************************************************************
00006 *
00007 * File unistr.h
00008 *
00009 * Modification History:
00010 *
00011 *   Date        Name        Description
00012 *   09/25/98    stephen     Creation.
00013 *   11/11/98    stephen     Changed per 11/9 code review.
00014 *   04/20/99    stephen     Overhauled per 4/16 code review.
00015 *   11/18/99    aliu        Made to inherit from Replaceable.  Added method
00016 *                           handleReplaceBetween(); other methods unchanged.
00017 *   06/25/01    grhoten     Remove dependency on iostream.
00018 ******************************************************************************
00019 */
00020 
00021 #ifndef UNISTR_H
00022 #define UNISTR_H
00023 
00029 #include "unicode/rep.h"
00030 
00031 struct UConverter;          // unicode/ucnv.h
00032 class  StringThreadTest;
00033 
00034 #ifndef U_COMPARE_CODE_POINT_ORDER
00035 /* see also ustring.h and unorm.h */
00041 #define U_COMPARE_CODE_POINT_ORDER  0x8000
00042 #endif
00043 
00044 #ifndef USTRING_H
00045 
00048 U_STABLE int32_t U_EXPORT2
00049 u_strlen(const UChar *s);
00050 #endif
00051 
00052 U_NAMESPACE_BEGIN
00053 
00054 class Locale;               // unicode/locid.h
00055 class StringCharacterIterator;
00056 class BreakIterator;        // unicode/brkiter.h
00057 
00058 /* The <iostream> include has been moved to unicode/ustream.h */
00059 
00070 #define US_INV U_NAMESPACE_QUALIFIER UnicodeString::kInvariant
00071 
00089 #if defined(U_DECLARE_UTF16)
00090 #   define UNICODE_STRING(cs, _length) U_NAMESPACE_QUALIFIER UnicodeString(TRUE, (const UChar *)U_DECLARE_UTF16(cs), _length)
00091 #elif U_SIZEOF_WCHAR_T==U_SIZEOF_UCHAR && (U_CHARSET_FAMILY==U_ASCII_FAMILY || (U_SIZEOF_UCHAR == 2 && defined(U_WCHAR_IS_UTF16)))
00092 #   define UNICODE_STRING(cs, _length) U_NAMESPACE_QUALIFIER UnicodeString(TRUE, (const UChar *)L ## cs, _length)
00093 #elif U_SIZEOF_UCHAR==1 && U_CHARSET_FAMILY==U_ASCII_FAMILY
00094 #   define UNICODE_STRING(cs, _length) U_NAMESPACE_QUALIFIER UnicodeString(TRUE, (const UChar *)cs, _length)
00095 #else
00096 #   define UNICODE_STRING(cs, _length) U_NAMESPACE_QUALIFIER UnicodeString(cs, _length, US_INV)
00097 #endif
00098 
00112 #define UNICODE_STRING_SIMPLE(cs) UNICODE_STRING(cs, -1)
00113 
00183 class U_COMMON_API UnicodeString : public Replaceable
00184 {
00185 public:
00186 
00195   enum EInvariant {
00200     kInvariant
00201   };
00202 
00203   //========================================
00204   // Read-only operations
00205   //========================================
00206 
00207   /* Comparison - bitwise only - for international comparison use collation */
00208 
00216   inline UBool operator== (const UnicodeString& text) const;
00217 
00225   inline UBool operator!= (const UnicodeString& text) const;
00226 
00234   inline UBool operator> (const UnicodeString& text) const;
00235 
00243   inline UBool operator< (const UnicodeString& text) const;
00244 
00252   inline UBool operator>= (const UnicodeString& text) const;
00253 
00261   inline UBool operator<= (const UnicodeString& text) const;
00262 
00274   inline int8_t compare(const UnicodeString& text) const;
00275 
00290   inline int8_t compare(int32_t start,
00291          int32_t length,
00292          const UnicodeString& text) const;
00293 
00311    inline int8_t compare(int32_t start,
00312          int32_t length,
00313          const UnicodeString& srcText,
00314          int32_t srcStart,
00315          int32_t srcLength) const;
00316 
00329   inline int8_t compare(const UChar *srcChars,
00330          int32_t srcLength) const;
00331 
00346   inline int8_t compare(int32_t start,
00347          int32_t length,
00348          const UChar *srcChars) const;
00349 
00367   inline int8_t compare(int32_t start,
00368          int32_t length,
00369          const UChar *srcChars,
00370          int32_t srcStart,
00371          int32_t srcLength) const;
00372 
00390   inline int8_t compareBetween(int32_t start,
00391             int32_t limit,
00392             const UnicodeString& srcText,
00393             int32_t srcStart,
00394             int32_t srcLimit) const;
00395 
00413   inline int8_t compareCodePointOrder(const UnicodeString& text) const;
00414 
00434   inline int8_t compareCodePointOrder(int32_t start,
00435                                       int32_t length,
00436                                       const UnicodeString& srcText) const;
00437 
00459    inline int8_t compareCodePointOrder(int32_t start,
00460                                        int32_t length,
00461                                        const UnicodeString& srcText,
00462                                        int32_t srcStart,
00463                                        int32_t srcLength) const;
00464 
00483   inline int8_t compareCodePointOrder(const UChar *srcChars,
00484                                       int32_t srcLength) const;
00485 
00505   inline int8_t compareCodePointOrder(int32_t start,
00506                                       int32_t length,
00507                                       const UChar *srcChars) const;
00508 
00530   inline int8_t compareCodePointOrder(int32_t start,
00531                                       int32_t length,
00532                                       const UChar *srcChars,
00533                                       int32_t srcStart,
00534                                       int32_t srcLength) const;
00535 
00557   inline int8_t compareCodePointOrderBetween(int32_t start,
00558                                              int32_t limit,
00559                                              const UnicodeString& srcText,
00560                                              int32_t srcStart,
00561                                              int32_t srcLimit) const;
00562 
00581   inline int8_t caseCompare(const UnicodeString& text, uint32_t options) const;
00582 
00603   inline int8_t caseCompare(int32_t start,
00604          int32_t length,
00605          const UnicodeString& srcText,
00606          uint32_t options) const;
00607 
00630   inline int8_t caseCompare(int32_t start,
00631          int32_t length,
00632          const UnicodeString& srcText,
00633          int32_t srcStart,
00634          int32_t srcLength,
00635          uint32_t options) const;
00636 
00656   inline int8_t caseCompare(const UChar *srcChars,
00657          int32_t srcLength,
00658          uint32_t options) const;
00659 
00680   inline int8_t caseCompare(int32_t start,
00681          int32_t length,
00682          const UChar *srcChars,
00683          uint32_t options) const;
00684 
00707   inline int8_t caseCompare(int32_t start,
00708          int32_t length,
00709          const UChar *srcChars,
00710          int32_t srcStart,
00711          int32_t srcLength,
00712          uint32_t options) const;
00713 
00736   inline int8_t caseCompareBetween(int32_t start,
00737             int32_t limit,
00738             const UnicodeString& srcText,
00739             int32_t srcStart,
00740             int32_t srcLimit,
00741             uint32_t options) const;
00742 
00750   inline UBool startsWith(const UnicodeString& text) const;
00751 
00762   inline UBool startsWith(const UnicodeString& srcText,
00763             int32_t srcStart,
00764             int32_t srcLength) const;
00765 
00774   inline UBool startsWith(const UChar *srcChars,
00775             int32_t srcLength) const;
00776 
00786   inline UBool startsWith(const UChar *srcChars,
00787             int32_t srcStart,
00788             int32_t srcLength) const;
00789 
00797   inline UBool endsWith(const UnicodeString& text) const;
00798 
00809   inline UBool endsWith(const UnicodeString& srcText,
00810           int32_t srcStart,
00811           int32_t srcLength) const;
00812 
00821   inline UBool endsWith(const UChar *srcChars,
00822           int32_t srcLength) const;
00823 
00834   inline UBool endsWith(const UChar *srcChars,
00835           int32_t srcStart,
00836           int32_t srcLength) const;
00837 
00838 
00839   /* Searching - bitwise only */
00840 
00849   inline int32_t indexOf(const UnicodeString& text) const;
00850 
00860   inline int32_t indexOf(const UnicodeString& text,
00861               int32_t start) const;
00862 
00874   inline int32_t indexOf(const UnicodeString& text,
00875               int32_t start,
00876               int32_t length) const;
00877 
00894   inline int32_t indexOf(const UnicodeString& srcText,
00895               int32_t srcStart,
00896               int32_t srcLength,
00897               int32_t start,
00898               int32_t length) const;
00899 
00911   inline int32_t indexOf(const UChar *srcChars,
00912               int32_t srcLength,
00913               int32_t start) const;
00914 
00927   inline int32_t indexOf(const UChar *srcChars,
00928               int32_t srcLength,
00929               int32_t start,
00930               int32_t length) const;
00931 
00948   int32_t indexOf(const UChar *srcChars,
00949               int32_t srcStart,
00950               int32_t srcLength,
00951               int32_t start,
00952               int32_t length) const;
00953 
00961   inline int32_t indexOf(UChar c) const;
00962 
00971   inline int32_t indexOf(UChar32 c) const;
00972 
00981   inline int32_t indexOf(UChar c,
00982               int32_t start) const;
00983 
00993   inline int32_t indexOf(UChar32 c,
00994               int32_t start) const;
00995 
01006   inline int32_t indexOf(UChar c,
01007               int32_t start,
01008               int32_t length) const;
01009 
01021   inline int32_t indexOf(UChar32 c,
01022               int32_t start,
01023               int32_t length) const;
01024 
01033   inline int32_t lastIndexOf(const UnicodeString& text) const;
01034 
01044   inline int32_t lastIndexOf(const UnicodeString& text,
01045               int32_t start) const;
01046 
01058   inline int32_t lastIndexOf(const UnicodeString& text,
01059               int32_t start,
01060               int32_t length) const;
01061 
01078   inline int32_t lastIndexOf(const UnicodeString& srcText,
01079               int32_t srcStart,
01080               int32_t srcLength,
01081               int32_t start,
01082               int32_t length) const;
01083 
01094   inline int32_t lastIndexOf(const UChar *srcChars,
01095               int32_t srcLength,
01096               int32_t start) const;
01097 
01110   inline int32_t lastIndexOf(const UChar *srcChars,
01111               int32_t srcLength,
01112               int32_t start,
01113               int32_t length) const;
01114 
01131   int32_t lastIndexOf(const UChar *srcChars,
01132               int32_t srcStart,
01133               int32_t srcLength,
01134               int32_t start,
01135               int32_t length) const;
01136 
01144   inline int32_t lastIndexOf(UChar c) const;
01145 
01154   inline int32_t lastIndexOf(UChar32 c) const;
01155 
01164   inline int32_t lastIndexOf(UChar c,
01165               int32_t start) const;
01166 
01176   inline int32_t lastIndexOf(UChar32 c,
01177               int32_t start) const;
01178 
01189   inline int32_t lastIndexOf(UChar c,
01190               int32_t start,
01191               int32_t length) const;
01192 
01204   inline int32_t lastIndexOf(UChar32 c,
01205               int32_t start,
01206               int32_t length) const;
01207 
01208 
01209   /* Character access */
01210 
01219   inline UChar charAt(int32_t offset) const;
01220 
01228   inline UChar operator[] (int32_t offset) const;
01229 
01241   inline UChar32 char32At(int32_t offset) const;
01242 
01258   inline int32_t getChar32Start(int32_t offset) const;
01259 
01276   inline int32_t getChar32Limit(int32_t offset) const;
01277 
01328   int32_t moveIndex32(int32_t index, int32_t delta) const;
01329 
01330   /* Substring extraction */
01331 
01347   inline void extract(int32_t start,
01348            int32_t length,
01349            UChar *dst,
01350            int32_t dstStart = 0) const;
01351 
01373   int32_t
01374   extract(UChar *dest, int32_t destCapacity,
01375           UErrorCode &errorCode) const;
01376 
01387   inline void extract(int32_t start,
01388            int32_t length,
01389            UnicodeString& target) const;
01390 
01402   inline void extractBetween(int32_t start,
01403               int32_t limit,
01404               UChar *dst,
01405               int32_t dstStart = 0) const;
01406 
01416   virtual void extractBetween(int32_t start,
01417               int32_t limit,
01418               UnicodeString& target) const;
01419 
01441   int32_t extract(int32_t start,
01442            int32_t startLength,
01443            char *target,
01444            int32_t targetCapacity,
01445            enum EInvariant inv) const;
01446 
01447 #if !UCONFIG_NO_CONVERSION
01448 
01474   inline int32_t extract(int32_t start,
01475                  int32_t startLength,
01476                  char *target,
01477                  const char *codepage = 0) const;
01478 
01508   int32_t extract(int32_t start,
01509            int32_t startLength,
01510            char *target,
01511            uint32_t targetLength,
01512            const char *codepage = 0) const;
01513 
01531   int32_t extract(char *dest, int32_t destCapacity,
01532                   UConverter *cnv,
01533                   UErrorCode &errorCode) const;
01534 
01535 #endif
01536 
01537   /* Length operations */
01538 
01547   inline int32_t length(void) const;
01548 
01562   int32_t
01563   countChar32(int32_t start=0, int32_t length=INT32_MAX) const;
01564 
01588   UBool
01589   hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const;
01590 
01596   inline UBool isEmpty(void) const;
01597 
01607   inline int32_t getCapacity(void) const;
01608 
01609   /* Other operations */
01610 
01616   inline int32_t hashCode(void) const;
01617 
01629   inline UBool isBogus(void) const;
01630 
01631 
01632   //========================================
01633   // Write operations
01634   //========================================
01635 
01636   /* Assignment operations */
01637 
01645   UnicodeString &operator=(const UnicodeString &srcText);
01646 
01667   UnicodeString &fastCopyFrom(const UnicodeString &src);
01668 
01676   inline UnicodeString& operator= (UChar ch);
01677 
01685   inline UnicodeString& operator= (UChar32 ch);
01686 
01698   inline UnicodeString& setTo(const UnicodeString& srcText,
01699                int32_t srcStart);
01700 
01714   inline UnicodeString& setTo(const UnicodeString& srcText,
01715                int32_t srcStart,
01716                int32_t srcLength);
01717 
01726   inline UnicodeString& setTo(const UnicodeString& srcText);
01727 
01736   inline UnicodeString& setTo(const UChar *srcChars,
01737                int32_t srcLength);
01738 
01747   UnicodeString& setTo(UChar srcChar);
01748 
01757   UnicodeString& setTo(UChar32 srcChar);
01758 
01779   UnicodeString &setTo(UBool isTerminated,
01780                        const UChar *text,
01781                        int32_t textLength);
01782 
01802   UnicodeString &setTo(UChar *buffer,
01803                        int32_t buffLength,
01804                        int32_t buffCapacity);
01805 
01846   void setToBogus();
01847 
01855   UnicodeString& setCharAt(int32_t offset,
01856                UChar ch);
01857 
01858 
01859   /* Append operations */
01860 
01868  inline  UnicodeString& operator+= (UChar ch);
01869 
01877  inline  UnicodeString& operator+= (UChar32 ch);
01878 
01887   inline UnicodeString& operator+= (const UnicodeString& srcText);
01888 
01903   inline UnicodeString& append(const UnicodeString& srcText,
01904             int32_t srcStart,
01905             int32_t srcLength);
01906 
01914   inline UnicodeString& append(const UnicodeString& srcText);
01915 
01929   inline UnicodeString& append(const UChar *srcChars,
01930             int32_t srcStart,
01931             int32_t srcLength);
01932 
01941   inline UnicodeString& append(const UChar *srcChars,
01942             int32_t srcLength);
01943 
01950   inline UnicodeString& append(UChar srcChar);
01951 
01958   inline UnicodeString& append(UChar32 srcChar);
01959 
01960 
01961   /* Insert operations */
01962 
01976   inline UnicodeString& insert(int32_t start,
01977             const UnicodeString& srcText,
01978             int32_t srcStart,
01979             int32_t srcLength);
01980 
01989   inline UnicodeString& insert(int32_t start,
01990             const UnicodeString& srcText);
01991 
02005   inline UnicodeString& insert(int32_t start,
02006             const UChar *srcChars,
02007             int32_t srcStart,
02008             int32_t srcLength);
02009 
02019   inline UnicodeString& insert(int32_t start,
02020             const UChar *srcChars,
02021             int32_t srcLength);
02022 
02031   inline UnicodeString& insert(int32_t start,
02032             UChar srcChar);
02033 
02042   inline UnicodeString& insert(int32_t start,
02043             UChar32 srcChar);
02044 
02045 
02046   /* Replace operations */
02047 
02065   UnicodeString& replace(int32_t start,
02066              int32_t length,
02067              const UnicodeString& srcText,
02068              int32_t srcStart,
02069              int32_t srcLength);
02070 
02083   UnicodeString& replace(int32_t start,
02084              int32_t length,
02085              const UnicodeString& srcText);
02086 
02104   UnicodeString& replace(int32_t start,
02105              int32_t length,
02106              const UChar *srcChars,
02107              int32_t srcStart,
02108              int32_t srcLength);
02109 
02122   inline UnicodeString& replace(int32_t start,
02123              int32_t length,
02124              const UChar *srcChars,
02125              int32_t srcLength);
02126 
02138   inline UnicodeString& replace(int32_t start,
02139              int32_t length,
02140              UChar srcChar);
02141 
02153   inline UnicodeString& replace(int32_t start,
02154              int32_t length,
02155              UChar32 srcChar);
02156 
02166   inline UnicodeString& replaceBetween(int32_t start,
02167                 int32_t limit,
02168                 const UnicodeString& srcText);
02169 
02184   inline UnicodeString& replaceBetween(int32_t start,
02185                 int32_t limit,
02186                 const UnicodeString& srcText,
02187                 int32_t srcStart,
02188                 int32_t srcLimit);
02189 
02200   virtual void handleReplaceBetween(int32_t start,
02201                                     int32_t limit,
02202                                     const UnicodeString& text);
02203 
02209   virtual UBool hasMetaData() const;
02210 
02226   virtual void copy(int32_t start, int32_t limit, int32_t dest);
02227 
02228   /* Search and replace operations */
02229 
02238   inline UnicodeString& findAndReplace(const UnicodeString& oldText,
02239                 const UnicodeString& newText);
02240 
02252   inline UnicodeString& findAndReplace(int32_t start,
02253                 int32_t length,
02254                 const UnicodeString& oldText,
02255                 const UnicodeString& newText);
02256 
02274   UnicodeString& findAndReplace(int32_t start,
02275                 int32_t length,
02276                 const UnicodeString& oldText,
02277                 int32_t oldStart,
02278                 int32_t oldLength,
02279                 const UnicodeString& newText,
02280                 int32_t newStart,
02281                 int32_t newLength);
02282 
02283 
02284   /* Remove operations */
02285 
02291   inline UnicodeString& remove(void);
02292 
02301   inline UnicodeString& remove(int32_t start,
02302                                int32_t length = (int32_t)INT32_MAX);
02303 
02312   inline UnicodeString& removeBetween(int32_t start,
02313                                       int32_t limit = (int32_t)INT32_MAX);
02314 
02315 
02316   /* Length operations */
02317 
02329   UBool padLeading(int32_t targetLength,
02330                     UChar padChar = 0x0020);
02331 
02343   UBool padTrailing(int32_t targetLength,
02344                      UChar padChar = 0x0020);
02345 
02352   inline UBool truncate(int32_t targetLength);
02353 
02359   UnicodeString& trim(void);
02360 
02361 
02362   /* Miscellaneous operations */
02363 
02369   inline UnicodeString& reverse(void);
02370 
02379   inline UnicodeString& reverse(int32_t start,
02380              int32_t length);
02381 
02388   UnicodeString& toUpper(void);
02389 
02397   UnicodeString& toUpper(const Locale& locale);
02398 
02405   UnicodeString& toLower(void);
02406 
02414   UnicodeString& toLower(const Locale& locale);
02415 
02416 #if !UCONFIG_NO_BREAK_ITERATION
02417 
02444   UnicodeString &toTitle(BreakIterator *titleIter);
02445 
02473   UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale);
02474 
02506   UnicodeString &toTitle(BreakIterator *titleIter, const Locale &locale, uint32_t options);
02507 
02508 #endif
02509 
02521   UnicodeString &foldCase(uint32_t options=0 /*U_FOLD_CASE_DEFAULT*/);
02522 
02523   //========================================
02524   // Access to the internal buffer
02525   //========================================
02526 
02570   UChar *getBuffer(int32_t minCapacity);
02571 
02592   void releaseBuffer(int32_t newLength=-1);
02593 
02624   inline const UChar *getBuffer() const;
02625 
02659   inline const UChar *getTerminatedBuffer();
02660 
02661   //========================================
02662   // Constructors
02663   //========================================
02664 
02668   UnicodeString();
02669 
02681   UnicodeString(int32_t capacity, UChar32 c, int32_t count);
02682 
02688   UnicodeString(UChar ch);
02689 
02695   UnicodeString(UChar32 ch);
02696 
02703   UnicodeString(const UChar *text);
02704 
02712   UnicodeString(const UChar *text,
02713         int32_t textLength);
02714 
02734   UnicodeString(UBool isTerminated,
02735                 const UChar *text,
02736                 int32_t textLength);
02737 
02756   UnicodeString(UChar *buffer, int32_t buffLength, int32_t buffCapacity);
02757 
02758 #if !UCONFIG_NO_CONVERSION
02759 
02777   UnicodeString(const char *codepageData,
02778         const char *codepage = 0);
02779 
02797   UnicodeString(const char *codepageData,
02798         int32_t dataLength,
02799         const char *codepage = 0);
02800 
02822   UnicodeString(
02823         const char *src, int32_t srcLength,
02824         UConverter *cnv,
02825         UErrorCode &errorCode);
02826 
02827 #endif
02828 
02853   UnicodeString(const char *src, int32_t length, enum EInvariant inv);
02854 
02855 
02861   UnicodeString(const UnicodeString& that);
02862 
02869   UnicodeString(const UnicodeString& src, int32_t srcStart);
02870 
02878   UnicodeString(const UnicodeString& src, int32_t srcStart, int32_t srcLength);
02879 
02896   virtual Replaceable *clone() const;
02897 
02901   virtual ~UnicodeString();
02902 
02903 
02904   /* Miscellaneous operations */
02905 
02940   UnicodeString unescape() const;
02941 
02961   UChar32 unescapeAt(int32_t &offset) const;
02962 
02968   static UClassID U_EXPORT2 getStaticClassID();
02969 
02975   virtual UClassID getDynamicClassID() const;
02976 
02977   //========================================
02978   // Implementation methods
02979   //========================================
02980 
02981 protected:
02986   virtual int32_t getLength() const;
02987 
02993   virtual UChar getCharAt(int32_t offset) const;
02994 
03000   virtual UChar32 getChar32At(int32_t offset) const;
03001 
03002 private:
03003 
03004   inline int8_t
03005   doCompare(int32_t start,
03006            int32_t length,
03007            const UnicodeString& srcText,
03008            int32_t srcStart,
03009            int32_t srcLength) const;
03010 
03011   int8_t doCompare(int32_t start,
03012            int32_t length,
03013            const UChar *srcChars,
03014            int32_t srcStart,
03015            int32_t srcLength) const;
03016 
03017   inline int8_t
03018   doCompareCodePointOrder(int32_t start,
03019                           int32_t length,
03020                           const UnicodeString& srcText,
03021                           int32_t srcStart,
03022                           int32_t srcLength) const;
03023 
03024   int8_t doCompareCodePointOrder(int32_t start,
03025                                  int32_t length,
03026                                  const UChar *srcChars,
03027                                  int32_t srcStart,
03028                                  int32_t srcLength) const;
03029 
03030   inline int8_t
03031   doCaseCompare(int32_t start,
03032                 int32_t length,
03033                 const UnicodeString &srcText,
03034                 int32_t srcStart,
03035                 int32_t srcLength,
03036                 uint32_t options) const;
03037 
03038   int8_t
03039   doCaseCompare(int32_t start,
03040                 int32_t length,
03041                 const UChar *srcChars,
03042                 int32_t srcStart,
03043                 int32_t srcLength,
03044                 uint32_t options) const;
03045 
03046   int32_t doIndexOf(UChar c,
03047             int32_t start,
03048             int32_t length) const;
03049 
03050   int32_t doIndexOf(UChar32 c,
03051                         int32_t start,
03052                         int32_t length) const;
03053 
03054   int32_t doLastIndexOf(UChar c,
03055                 int32_t start,
03056                 int32_t length) const;
03057 
03058   int32_t doLastIndexOf(UChar32 c,
03059                             int32_t start,
03060                             int32_t length) const;
03061 
03062   void doExtract(int32_t start,
03063          int32_t length,
03064          UChar *dst,
03065          int32_t dstStart) const;
03066 
03067   inline void doExtract(int32_t start,
03068          int32_t length,
03069          UnicodeString& target) const;
03070 
03071   inline UChar doCharAt(int32_t offset)  const;
03072 
03073   UnicodeString& doReplace(int32_t start,
03074                int32_t length,
03075                const UnicodeString& srcText,
03076                int32_t srcStart,
03077                int32_t srcLength);
03078 
03079   UnicodeString& doReplace(int32_t start,
03080                int32_t length,
03081                const UChar *srcChars,
03082                int32_t srcStart,
03083                int32_t srcLength);
03084 
03085   UnicodeString& doReverse(int32_t start,
03086                int32_t length);
03087 
03088   // calculate hash code
03089   int32_t doHashCode(void) const;
03090 
03091   // get pointer to start of array
03092   inline UChar* getArrayStart(void);
03093   inline const UChar* getArrayStart(void) const;
03094 
03095   // allocate the array; result may be fStackBuffer
03096   // sets refCount to 1 if appropriate
03097   // sets fArray, fCapacity, and fFlags
03098   // returns boolean for success or failure
03099   UBool allocate(int32_t capacity);
03100 
03101   // release the array if owned
03102   void releaseArray(void);
03103 
03104   // turn a bogus string into an empty one
03105   void unBogus();
03106 
03107   // implements assigment operator, copy constructor, and fastCopyFrom()
03108   UnicodeString &copyFrom(const UnicodeString &src, UBool fastCopy=FALSE);
03109 
03110   // Pin start and limit to acceptable values.
03111   inline void pinIndex(int32_t& start) const;
03112   inline void pinIndices(int32_t& start,
03113                          int32_t& length) const;
03114 
03115 #if !UCONFIG_NO_CONVERSION
03116 
03117   /* Internal extract() using UConverter. */
03118   int32_t doExtract(int32_t start, int32_t length,
03119                     char *dest, int32_t destCapacity,
03120                     UConverter *cnv,
03121                     UErrorCode &errorCode) const;
03122 
03123   /*
03124    * Real constructor for converting from codepage data.
03125    * It assumes that it is called with !fRefCounted.
03126    *
03127    * If <code>codepage==0</code>, then the default converter
03128    * is used for the platform encoding.
03129    * If <code>codepage</code> is an empty string (<code>""</code>),
03130    * then a simple conversion is performed on the codepage-invariant
03131    * subset ("invariant characters") of the platform encoding. See utypes.h.
03132    */
03133   void doCodepageCreate(const char *codepageData,
03134                         int32_t dataLength,
03135                         const char *codepage);
03136 
03137   /*
03138    * Worker function for creating a UnicodeString from
03139    * a codepage string using a UConverter.
03140    */
03141   void
03142   doCodepageCreate(const char *codepageData,
03143                    int32_t dataLength,
03144                    UConverter *converter,
03145                    UErrorCode &status);
03146 
03147 #endif
03148 
03149   /*
03150    * This function is called when write access to the array
03151    * is necessary.
03152    *
03153    * We need to make a copy of the array if
03154    * the buffer is read-only, or
03155    * the buffer is refCounted (shared), and refCount>1, or
03156    * the buffer is too small.
03157    *
03158    * Return FALSE if memory could not be allocated.
03159    */
03160   UBool cloneArrayIfNeeded(int32_t newCapacity = -1,
03161                             int32_t growCapacity = -1,
03162                             UBool doCopyArray = TRUE,
03163                             int32_t **pBufferToDelete = 0,
03164                             UBool forceClone = FALSE);
03165 
03166   // common function for case mappings
03167   UnicodeString &
03168   caseMap(BreakIterator *titleIter,
03169           const char *locale,
03170           uint32_t options,
03171           int32_t toWhichCase);
03172 
03173   // ref counting
03174   void addRef(void);
03175   int32_t removeRef(void);
03176   int32_t refCount(void) const;
03177 
03178   // constants
03179   enum {
03180     US_STACKBUF_SIZE=7, // Size of stack buffer for small strings
03181     kInvalidUChar=0xffff, // invalid UChar index
03182     kGrowSize=128, // grow size for this buffer
03183     kInvalidHashCode=0, // invalid hash code
03184     kEmptyHashCode=1, // hash code for empty string
03185 
03186     // bit flag values for fFlags
03187     kIsBogus=1,         // this string is bogus, i.e., not valid or NULL
03188     kUsingStackBuffer=2,// fArray==fStackBuffer
03189     kRefCounted=4,      // there is a refCount field before the characters in fArray
03190     kBufferIsReadonly=8,// do not write to this buffer
03191     kOpenGetBuffer=16,  // getBuffer(minCapacity) was called (is "open"),
03192                         // and releaseBuffer(newLength) must be called
03193 
03194     // combined values for convenience
03195     kShortString=kUsingStackBuffer,
03196     kLongString=kRefCounted,
03197     kReadonlyAlias=kBufferIsReadonly,
03198     kWritableAlias=0
03199   };
03200 
03201   friend class StringCharacterIterator;
03202   friend class StringThreadTest;
03203 
03204   /*
03205    * The following are all the class fields that are stored
03206    * in each UnicodeString object.
03207    * Note that UnicodeString has virtual functions,
03208    * therefore there is an implicit vtable pointer
03209    * as the first real field.
03210    * The fields should be aligned such that no padding is
03211    * necessary, mostly by having larger types first.
03212    * On 32-bit machines, the size should be 32 bytes,
03213    * on 64-bit machines (8-byte pointers), it should be 40 bytes.
03214    */
03215   // (implicit) *vtable;
03216   int32_t   fLength;        // number of characters in fArray
03217   int32_t   fCapacity;      // sizeof fArray
03218   UChar     *fArray;        // the Unicode data
03219   uint16_t  fFlags;         // bit flags: see constants above
03220   UChar     fStackBuffer [ US_STACKBUF_SIZE ]; // buffer for small strings
03221 
03222 };
03223 
03232 U_COMMON_API UnicodeString U_EXPORT2
03233 operator+ (const UnicodeString &s1, const UnicodeString &s2);
03234 
03235 //========================================
03236 // Inline members
03237 //========================================
03238 
03239 //========================================
03240 // Privates
03241 //========================================
03242 
03243 inline void
03244 UnicodeString::pinIndex(int32_t& start) const
03245 {
03246   // pin index
03247   if(start < 0) {
03248     start = 0;
03249   } else if(start > fLength) {
03250     start = fLength;
03251   }
03252 }
03253 
03254 inline void
03255 UnicodeString::pinIndices(int32_t& start,
03256                           int32_t& _length) const
03257 {
03258   // pin indices
03259   if(start < 0) {
03260     start = 0;
03261   } else if(start > fLength) {
03262     start = fLength;
03263   }
03264   if(_length < 0) {
03265     _length = 0;
03266   } else if(_length > (fLength - start)) {
03267     _length = (fLength - start);
03268   }
03269 }
03270 
03271 inline UChar*
03272 UnicodeString::getArrayStart()
03273 { return fArray; }
03274 
03275 inline const UChar*
03276 UnicodeString::getArrayStart() const
03277 { return fArray; }
03278 
03279 //========================================
03280 // Read-only implementation methods
03281 //========================================
03282 inline int32_t
03283 UnicodeString::length() const
03284 { return fLength; }
03285 
03286 inline int32_t
03287 UnicodeString::getCapacity() const
03288 { return fCapacity; }
03289 
03290 inline int32_t
03291 UnicodeString::hashCode() const
03292 { return doHashCode(); }
03293 
03294 inline UBool
03295 UnicodeString::isBogus() const
03296 { return (UBool)(fFlags & kIsBogus); }
03297 
03298 inline const UChar *
03299 UnicodeString::getBuffer() const {
03300   if(!(fFlags&(kIsBogus|kOpenGetBuffer))) {
03301     return fArray;
03302   } else {
03303     return 0;
03304   }
03305 }
03306 
03307 //========================================
03308 // Read-only alias methods
03309 //========================================
03310 inline int8_t
03311 UnicodeString::doCompare(int32_t start,
03312               int32_t length,
03313               const UnicodeString& srcText,
03314               int32_t srcStart,
03315               int32_t srcLength) const
03316 {
03317   if(srcText.isBogus()) {
03318     return (int8_t)!isBogus(); // 0 if both are bogus, 1 otherwise
03319   } else {
03320     srcText.pinIndices(srcStart, srcLength);
03321     return doCompare(start, length, srcText.fArray, srcStart, srcLength);
03322   }
03323 }
03324 
03325 inline UBool
03326 UnicodeString::operator== (const UnicodeString& text) const
03327 {
03328   if(isBogus()) {
03329     return text.isBogus();
03330   } else {
03331     return
03332       !text.isBogus() &&
03333       fLength == text.fLength &&
03334       doCompare(0, fLength, text, 0, text.fLength) == 0;
03335   }
03336 }
03337 
03338 inline UBool
03339 UnicodeString::operator!= (const UnicodeString& text) const
03340 { return (! operator==(text)); }
03341 
03342 inline UBool
03343 UnicodeString::operator> (const UnicodeString& text) const
03344 { return doCompare(0, fLength, text, 0, text.fLength) == 1; }
03345 
03346 inline UBool
03347 UnicodeString::operator< (const UnicodeString& text) const
03348 { return doCompare(0, fLength, text, 0, text.fLength) == -1; }
03349 
03350 inline UBool
03351 UnicodeString::operator>= (const UnicodeString& text) const
03352 { return doCompare(0, fLength, text, 0, text.fLength) != -1; }
03353 
03354 inline UBool
03355 UnicodeString::operator<= (const UnicodeString& text) const
03356 { return doCompare(0, fLength, text, 0, text.fLength) != 1; }
03357 
03358 inline int8_t
03359 UnicodeString::compare(const UnicodeString& text) const
03360 { return doCompare(0, fLength, text, 0, text.fLength); }
03361 
03362 inline int8_t
03363 UnicodeString::compare(int32_t start,
03364                int32_t _length,
03365                const UnicodeString& srcText) const
03366 { return doCompare(start, _length, srcText, 0, srcText.fLength); }
03367 
03368 inline int8_t
03369 UnicodeString::compare(const UChar *srcChars,
03370                int32_t srcLength) const
03371 { return doCompare(0, fLength, srcChars, 0, srcLength); }
03372 
03373 inline int8_t
03374 UnicodeString::compare(int32_t start,
03375                int32_t _length,
03376                const UnicodeString& srcText,
03377                int32_t srcStart,
03378                int32_t srcLength) const
03379 { return doCompare(start, _length, srcText, srcStart, srcLength); }
03380 
03381 inline int8_t
03382 UnicodeString::compare(int32_t start,
03383                int32_t _length,
03384                const UChar *srcChars) const
03385 { return doCompare(start, _length, srcChars, 0, _length); }
03386 
03387 inline int8_t
03388 UnicodeString::compare(int32_t start,
03389                int32_t _length,
03390                const UChar *srcChars,
03391                int32_t srcStart,
03392                int32_t srcLength) const
03393 { return doCompare(start, _length, srcChars, srcStart, srcLength); }
03394 
03395 inline int8_t
03396 UnicodeString::compareBetween(int32_t start,
03397                   int32_t limit,
03398                   const UnicodeString& srcText,
03399                   int32_t srcStart,
03400                   int32_t srcLimit) const
03401 { return doCompare(start, limit - start,
03402            srcText, srcStart, srcLimit - srcStart); }
03403 
03404 inline int8_t
03405 UnicodeString::doCompareCodePointOrder(int32_t start,
03406                                        int32_t length,
03407                                        const UnicodeString& srcText,
03408                                        int32_t srcStart,
03409                                        int32_t srcLength) const
03410 {
03411   if(srcText.isBogus()) {
03412     return (int8_t)!isBogus(); // 0 if both are bogus, 1 otherwise
03413   } else {
03414     srcText.pinIndices(srcStart, srcLength);
03415     return doCompareCodePointOrder(start, length, srcText.fArray, srcStart, srcLength);
03416   }
03417 }
03418 
03419 inline int8_t
03420 UnicodeString::compareCodePointOrder(const UnicodeString& text) const
03421 { return doCompareCodePointOrder(0, fLength, text, 0, text.fLength); }
03422 
03423 inline int8_t
03424 UnicodeString::compareCodePointOrder(int32_t start,
03425                                      int32_t _length,
03426                                      const UnicodeString& srcText) const
03427 { return doCompareCodePointOrder(start, _length, srcText, 0, srcText.fLength); }
03428 
03429 inline int8_t
03430 UnicodeString::compareCodePointOrder(const UChar *srcChars,
03431                                      int32_t srcLength) const
03432 { return doCompareCodePointOrder(0, fLength, srcChars, 0, srcLength); }
03433 
03434 inline int8_t
03435 UnicodeString::compareCodePointOrder(int32_t start,
03436                                      int32_t _length,
03437                                      const UnicodeString& srcText,
03438                                      int32_t srcStart,
03439                                      int32_t srcLength) const
03440 { return doCompareCodePointOrder(start, _length, srcText, srcStart, srcLength); }
03441 
03442 inline int8_t
03443 UnicodeString::compareCodePointOrder(int32_t start,
03444                                      int32_t _length,
03445                                      const UChar *srcChars) const
03446 { return doCompareCodePointOrder(start, _length, srcChars, 0, _length); }
03447 
03448 inline int8_t
03449 UnicodeString::compareCodePointOrder(int32_t start,
03450                                      int32_t _length,
03451                                      const UChar *srcChars,
03452                                      int32_t srcStart,
03453                                      int32_t srcLength) const
03454 { return doCompareCodePointOrder(start, _length, srcChars, srcStart, srcLength); }
03455 
03456 inline int8_t
03457 UnicodeString::compareCodePointOrderBetween(int32_t start,
03458                                             int32_t limit,
03459                                             const UnicodeString& srcText,
03460                                             int32_t srcStart,
03461                                             int32_t srcLimit) const
03462 { return doCompareCodePointOrder(start, limit - start,
03463            srcText, srcStart, srcLimit - srcStart); }
03464 
03465 inline int8_t
03466 UnicodeString::doCaseCompare(int32_t start,
03467                              int32_t length,
03468                              const UnicodeString &srcText,
03469                              int32_t srcStart,
03470                              int32_t srcLength,
03471                              uint32_t options) const
03472 {
03473   if(srcText.isBogus()) {
03474     return (int8_t)!isBogus(); // 0 if both are bogus, 1 otherwise
03475   } else {
03476     srcText.pinIndices(srcStart, srcLength);
03477     return doCaseCompare(start, length, srcText.fArray, srcStart, srcLength, options);
03478   }
03479 }
03480 
03481 inline int8_t
03482 UnicodeString::caseCompare(const UnicodeString &text, uint32_t options) const {
03483   return doCaseCompare(0, fLength, text, 0, text.fLength, options);
03484 }
03485 
03486 inline int8_t
03487 UnicodeString::caseCompare(int32_t start,
03488                            int32_t _length,
03489                            const UnicodeString &srcText,
03490                            uint32_t options) const {
03491   return doCaseCompare(start, _length, srcText, 0, srcText.fLength, options);
03492 }
03493 
03494 inline int8_t
03495 UnicodeString::caseCompare(const UChar *srcChars,
03496                            int32_t srcLength,
03497                            uint32_t options) const {
03498   return doCaseCompare(0, fLength, srcChars, 0, srcLength, options);
03499 }
03500 
03501 inline int8_t
03502 UnicodeString::caseCompare(int32_t start,
03503                            int32_t _length,
03504                            const UnicodeString &srcText,
03505                            int32_t srcStart,
03506                            int32_t srcLength,
03507                            uint32_t options) const {
03508   return doCaseCompare(start, _length, srcText, srcStart, srcLength, options);
03509 }
03510 
03511 inline int8_t
03512 UnicodeString::caseCompare(int32_t start,
03513                            int32_t _length,
03514                            const UChar *srcChars,
03515                            uint32_t options) const {
03516   return doCaseCompare(start, _length, srcChars, 0, _length, options);
03517 }
03518 
03519 inline int8_t
03520 UnicodeString::caseCompare(int32_t start,
03521                            int32_t _length,
03522                            const UChar *srcChars,
03523                            int32_t srcStart,
03524                            int32_t srcLength,
03525                            uint32_t options) const {
03526   return doCaseCompare(start, _length, srcChars, srcStart, srcLength, options);
03527 }
03528 
03529 inline int8_t
03530 UnicodeString::caseCompareBetween(int32_t start,
03531                                   int32_t limit,
03532                                   const UnicodeString &srcText,
03533                                   int32_t srcStart,
03534                                   int32_t srcLimit,
03535                                   uint32_t options) const {
03536   return doCaseCompare(start, limit - start, srcText, srcStart, srcLimit - srcStart, options);
03537 }
03538 
03539 inline int32_t
03540 UnicodeString::indexOf(const UnicodeString& srcText,
03541                int32_t srcStart,
03542                int32_t srcLength,
03543                int32_t start,
03544                int32_t _length) const
03545 {
03546   if(!srcText.isBogus()) {
03547     srcText.pinIndices(srcStart, srcLength);
03548     if(srcLength > 0) {
03549       return indexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
03550     }
03551   }
03552   return -1;
03553 }
03554 
03555 inline int32_t
03556 UnicodeString::indexOf(const UnicodeString& text) const
03557 { return indexOf(text, 0, text.fLength, 0, fLength); }
03558 
03559 inline int32_t
03560 UnicodeString::indexOf(const UnicodeString& text,
03561                int32_t start) const {
03562   pinIndex(start);
03563   return indexOf(text, 0, text.fLength, start, fLength - start);
03564 }
03565 
03566 inline int32_t
03567 UnicodeString::indexOf(const UnicodeString& text,
03568                int32_t start,
03569                int32_t _length) const
03570 { return indexOf(text, 0, text.fLength, start, _length); }
03571 
03572 inline int32_t
03573 UnicodeString::indexOf(const UChar *srcChars,
03574                int32_t srcLength,
03575                int32_t start) const {
03576   pinIndex(start);
03577   return indexOf(srcChars, 0, srcLength, start, fLength - start);
03578 }
03579 
03580 inline int32_t
03581 UnicodeString::indexOf(const UChar *srcChars,
03582                int32_t srcLength,
03583                int32_t start,
03584                int32_t _length) const
03585 { return indexOf(srcChars, 0, srcLength, start, _length); }
03586 
03587 inline int32_t
03588 UnicodeString::indexOf(UChar c,
03589                int32_t start,
03590                int32_t _length) const
03591 { return doIndexOf(c, start, _length); }
03592 
03593 inline int32_t
03594 UnicodeString::indexOf(UChar32 c,
03595                int32_t start,
03596                int32_t _length) const
03597 { return doIndexOf(c, start, _length); }
03598 
03599 inline int32_t
03600 UnicodeString::indexOf(UChar c) const
03601 { return doIndexOf(c, 0, fLength); }
03602 
03603 inline int32_t
03604 UnicodeString::indexOf(UChar32 c) const
03605 { return indexOf(c, 0, fLength); }
03606 
03607 inline int32_t
03608 UnicodeString::indexOf(UChar c,
03609                int32_t start) const {
03610   pinIndex(start);
03611   return doIndexOf(c, start, fLength - start);
03612 }
03613 
03614 inline int32_t
03615 UnicodeString::indexOf(UChar32 c,
03616                int32_t start) const {
03617   pinIndex(start);
03618   return indexOf(c, start, fLength - start);
03619 }
03620 
03621 inline int32_t
03622 UnicodeString::lastIndexOf(const UChar *srcChars,
03623                int32_t srcLength,
03624                int32_t start,
03625                int32_t _length) const
03626 { return lastIndexOf(srcChars, 0, srcLength, start, _length); }
03627 
03628 inline int32_t
03629 UnicodeString::lastIndexOf(const UChar *srcChars,
03630                int32_t srcLength,
03631                int32_t start) const {
03632   pinIndex(start);
03633   return lastIndexOf(srcChars, 0, srcLength, start, fLength - start);
03634 }
03635 
03636 inline int32_t
03637 UnicodeString::lastIndexOf(const UnicodeString& srcText,
03638                int32_t srcStart,
03639                int32_t srcLength,
03640                int32_t start,
03641                int32_t _length) const
03642 {
03643   if(!srcText.isBogus()) {
03644     srcText.pinIndices(srcStart, srcLength);
03645     if(srcLength > 0) {
03646       return lastIndexOf(srcText.getArrayStart(), srcStart, srcLength, start, _length);
03647     }
03648   }
03649   return -1;
03650 }
03651 
03652 inline int32_t
03653 UnicodeString::lastIndexOf(const UnicodeString& text,
03654                int32_t start,
03655                int32_t _length) const
03656 { return lastIndexOf(text, 0, text.fLength, start, _length); }
03657 
03658 inline int32_t
03659 UnicodeString::lastIndexOf(const UnicodeString& text,
03660                int32_t start) const {
03661   pinIndex(start);
03662   return lastIndexOf(text, 0, text.fLength, start, fLength - start);
03663 }
03664 
03665 inline int32_t
03666 UnicodeString::lastIndexOf(const UnicodeString& text) const
03667 { return lastIndexOf(text, 0, text.fLength, 0, fLength); }
03668 
03669 inline int32_t
03670 UnicodeString::lastIndexOf(UChar c,
03671                int32_t start,
03672                int32_t _length) const
03673 { return doLastIndexOf(c, start, _length); }
03674 
03675 inline int32_t
03676 UnicodeString::lastIndexOf(UChar32 c,
03677                int32_t start,
03678                int32_t _length) const {
03679   return doLastIndexOf(c, start, _length);
03680 }
03681 
03682 inline int32_t
03683 UnicodeString::lastIndexOf(UChar c) const
03684 { return doLastIndexOf(c, 0, fLength); }
03685 
03686 inline int32_t
03687 UnicodeString::lastIndexOf(UChar32 c) const {
03688   return lastIndexOf(c, 0, fLength);
03689 }
03690 
03691 inline int32_t
03692 UnicodeString::lastIndexOf(UChar c,
03693                int32_t start) const {
03694   pinIndex(start);
03695   return doLastIndexOf(c, start, fLength - start);
03696 }
03697 
03698 inline int32_t
03699 UnicodeString::lastIndexOf(UChar32 c,
03700                int32_t start) const {
03701   pinIndex(start);
03702   return lastIndexOf(c, start, fLength - start);
03703 }
03704 
03705 inline UBool
03706 UnicodeString::startsWith(const UnicodeString& text) const
03707 { return compare(0, text.fLength, text, 0, text.fLength) == 0; }
03708 
03709 inline UBool
03710 UnicodeString::startsWith(const UnicodeString& srcText,
03711               int32_t srcStart,
03712               int32_t srcLength) const
03713 { return doCompare(0, srcLength, srcText, srcStart, srcLength) == 0; }
03714 
03715 inline UBool
03716 UnicodeString::startsWith(const UChar *srcChars,
03717               int32_t srcLength) const
03718 { return doCompare(0, srcLength, srcChars, 0, srcLength) == 0; }
03719 
03720 inline UBool
03721 UnicodeString::startsWith(const UChar *srcChars,
03722               int32_t srcStart,
03723               int32_t srcLength) const
03724 { return doCompare(0, srcLength, srcChars, srcStart, srcLength) == 0;}
03725 
03726 inline UBool
03727 UnicodeString::endsWith(const UnicodeString& text) const
03728 { return doCompare(fLength - text.fLength, text.fLength,
03729            text, 0, text.fLength) == 0; }
03730 
03731 inline UBool
03732 UnicodeString::endsWith(const UnicodeString& srcText,
03733             int32_t srcStart,
03734             int32_t srcLength) const {
03735   srcText.pinIndices(srcStart, srcLength);
03736   return doCompare(fLength - srcLength, srcLength,
03737                    srcText, srcStart, srcLength) == 0;
03738 }
03739 
03740 inline UBool
03741 UnicodeString::endsWith(const UChar *srcChars,
03742             int32_t srcLength) const {
03743   if(srcLength < 0) {
03744     srcLength = u_strlen(srcChars);
03745   }
03746   return doCompare(fLength - srcLength, srcLength,
03747                    srcChars, 0, srcLength) == 0;
03748 }
03749 
03750 inline UBool
03751 UnicodeString::endsWith(const UChar *srcChars,
03752             int32_t srcStart,
03753             int32_t srcLength) const {
03754   if(srcLength < 0) {
03755     srcLength = u_strlen(srcChars + srcStart);
03756   }
03757   return doCompare(fLength - srcLength, srcLength,
03758                    srcChars, srcStart, srcLength) == 0;
03759 }
03760 
03761 //========================================
03762 // replace
03763 //========================================
03764 inline UnicodeString&
03765 UnicodeString::replace(int32_t start,
03766                int32_t _length,
03767                const UnicodeString& srcText)
03768 { return doReplace(start, _length, srcText, 0, srcText.fLength); }
03769 
03770 inline UnicodeString&
03771 UnicodeString::replace(int32_t start,
03772                int32_t _length,
03773                const UnicodeString& srcText,
03774                int32_t srcStart,
03775                int32_t srcLength)
03776 { return doReplace(start, _length, srcText, srcStart, srcLength); }
03777 
03778 inline UnicodeString&
03779 UnicodeString::replace(int32_t start,
03780                int32_t _length,
03781                const UChar *srcChars,
03782                int32_t srcLength)
03783 { return doReplace(start, _length, srcChars, 0, srcLength); }
03784 
03785 inline UnicodeString&
03786 UnicodeString::replace(int32_t start,
03787                int32_t _length,
03788                const UChar *srcChars,
03789                int32_t srcStart,
03790                int32_t srcLength)
03791 { return doReplace(start, _length, srcChars, srcStart, srcLength); }
03792 
03793 inline UnicodeString&
03794 UnicodeString::replace(int32_t start,
03795                int32_t _length,
03796                UChar srcChar)
03797 { return doReplace(start, _length, &srcChar, 0, 1); }
03798 
03799 inline UnicodeString&
03800 UnicodeString::replace(int32_t start,
03801                int32_t _length,
03802                UChar32 srcChar) {
03803   UChar buffer[U16_MAX_LENGTH];
03804   int32_t count = 0;
03805   UBool isError = FALSE;
03806   U16_APPEND(buffer, count, U16_MAX_LENGTH, srcChar, isError);
03807   return doReplace(start, _length, buffer, 0, count);
03808 }
03809 
03810 inline UnicodeString&
03811 UnicodeString::replaceBetween(int32_t start,
03812                   int32_t limit,
03813                   const UnicodeString& srcText)
03814 { return doReplace(start, limit - start, srcText, 0, srcText.fLength); }
03815 
03816 inline UnicodeString&
03817 UnicodeString::replaceBetween(int32_t start,
03818                   int32_t limit,
03819                   const UnicodeString& srcText,
03820                   int32_t srcStart,
03821                   int32_t srcLimit)
03822 { return doReplace(start, limit - start, srcText, srcStart, srcLimit - srcStart); }
03823 
03824 inline UnicodeString&
03825 UnicodeString::findAndReplace(const UnicodeString& oldText,
03826                   const UnicodeString& newText)
03827 { return findAndReplace(0, fLength, oldText, 0, oldText.fLength,
03828             newText, 0, newText.fLength); }
03829 
03830 inline UnicodeString&
03831 UnicodeString::findAndReplace(int32_t start,
03832                   int32_t _length,
03833                   const UnicodeString& oldText,
03834                   const UnicodeString& newText)
03835 { return findAndReplace(start, _length, oldText, 0, oldText.fLength,
03836             newText, 0, newText.fLength); }
03837 
03838 // ============================
03839 // extract
03840 // ============================
03841 inline void
03842 UnicodeString::doExtract(int32_t start,
03843              int32_t _length,
03844              UnicodeString& target) const
03845 { target.replace(0, target.fLength, *this, start, _length); }
03846 
03847 inline void
03848 UnicodeString::extract(int32_t start,
03849                int32_t _length,
03850                UChar *target,
03851                int32_t targetStart) const
03852 { doExtract(start, _length, target, targetStart); }
03853 
03854 inline void
03855 UnicodeString::extract(int32_t start,
03856                int32_t _length,
03857                UnicodeString& target) const
03858 { doExtract(start, _length, target); }
03859 
03860 #if !UCONFIG_NO_CONVERSION
03861 
03862 inline int32_t
03863 UnicodeString::extract(int32_t start,
03864                int32_t _length,
03865                char *dst,
03866                const char *codepage) const
03867 
03868 {
03869   // This dstSize value will be checked explicitly
03870   return extract(start, _length, dst, dst!=0 ? 0xffffffff : 0, codepage);
03871 }
03872 
03873 #endif
03874 
03875 inline void
03876 UnicodeString::extractBetween(int32_t start,
03877                   int32_t limit,
03878                   UChar *dst,
03879                   int32_t dstStart) const {
03880   pinIndex(start);
03881   pinIndex(limit);
03882   doExtract(start, limit - start, dst, dstStart);
03883 }
03884 
03885 inline UChar
03886 UnicodeString::doCharAt(int32_t offset) const
03887 {
03888   if((uint32_t)offset < (uint32_t)fLength) {
03889     return fArray[offset];
03890   } else {
03891     return kInvalidUChar;
03892   }
03893 }
03894 
03895 inline UChar
03896 UnicodeString::charAt(int32_t offset) const
03897 { return doCharAt(offset); }
03898 
03899 inline UChar
03900 UnicodeString::operator[] (int32_t offset) const
03901 { return doCharAt(offset); }
03902 
03903 inline UChar32
03904 UnicodeString::char32At(int32_t offset) const
03905 {
03906   if((uint32_t)offset < (uint32_t)fLength) {
03907     UChar32 c;
03908     U16_GET(fArray, 0, offset, fLength, c);
03909     return c;
03910   } else {
03911     return kInvalidUChar;
03912   }
03913 }
03914 
03915 inline int32_t
03916 UnicodeString::getChar32Start(int32_t offset) const {
03917   if((uint32_t)offset < (uint32_t)fLength) {
03918     U16_SET_CP_START(fArray, 0, offset);
03919     return offset;
03920   } else {
03921     return 0;
03922   }
03923 }
03924 
03925 inline int32_t
03926 UnicodeString::getChar32Limit(int32_t offset) const {
03927   if((uint32_t)offset < (uint32_t)fLength) {
03928     U16_SET_CP_LIMIT(fArray, 0, offset, fLength);
03929     return offset;
03930   } else {
03931     return fLength;
03932   }
03933 }
03934 
03935 inline UBool
03936 UnicodeString::isEmpty() const {
03937   return fLength == 0;
03938 }
03939 
03940 //========================================
03941 // Write implementation methods
03942 //========================================
03943 inline const UChar *
03944 UnicodeString::getTerminatedBuffer() {
03945   if(fFlags&(kIsBogus|kOpenGetBuffer)) {
03946     return 0;
03947   } else if(fLength<fCapacity && fArray[fLength]==0) {
03948     return fArray;
03949   } else if(cloneArrayIfNeeded(fLength+1)) {
03950     fArray[fLength]=0;
03951     return fArray;
03952   } else {
03953     return 0;
03954   }
03955 }
03956 
03957 inline UnicodeString&
03958 UnicodeString::operator= (UChar ch)
03959 { return doReplace(0, fLength, &ch, 0, 1); }
03960 
03961 inline UnicodeString&
03962 UnicodeString::operator= (UChar32 ch)
03963 { return replace(0, fLength, ch); }
03964 
03965 inline UnicodeString&
03966 UnicodeString::setTo(const UnicodeString& srcText,
03967              int32_t srcStart,
03968              int32_t srcLength)
03969 {
03970   unBogus();
03971   return doReplace(0, fLength, srcText, srcStart, srcLength);
03972 }
03973 
03974 inline UnicodeString&
03975 UnicodeString::setTo(const UnicodeString& srcText,
03976              int32_t srcStart)
03977 {
03978   unBogus();
03979   srcText.pinIndex(srcStart);
03980   return doReplace(0, fLength, srcText, srcStart, srcText.fLength - srcStart);
03981 }
03982 
03983 inline UnicodeString&
03984 UnicodeString::setTo(const UnicodeString& srcText)
03985 {
03986   unBogus();
03987   return doReplace(0, fLength, srcText, 0, srcText.fLength);
03988 }
03989 
03990 inline UnicodeString&
03991 UnicodeString::setTo(const UChar *srcChars,
03992              int32_t srcLength)
03993 {
03994   unBogus();
03995   return doReplace(0, fLength, srcChars, 0, srcLength);
03996 }
03997 
03998 inline UnicodeString&
03999 UnicodeString::setTo(UChar srcChar)
04000 {
04001   unBogus();
04002   return doReplace(0, fLength, &srcChar, 0, 1);
04003 }
04004 
04005 inline UnicodeString&
04006 UnicodeString::setTo(UChar32 srcChar)
04007 {
04008   unBogus();
04009   return replace(0, fLength, srcChar);
04010 }
04011 
04012 inline UnicodeString&
04013 UnicodeString::append(const UnicodeString& srcText,
04014               int32_t srcStart,
04015               int32_t srcLength)
04016 { return doReplace(fLength, 0, srcText, srcStart, srcLength); }
04017 
04018 inline UnicodeString&
04019 UnicodeString::append(const UnicodeString& srcText)
04020 { return doReplace(fLength, 0, srcText, 0, srcText.fLength); }
04021 
04022 inline UnicodeString&
04023 UnicodeString::append(const UChar *srcChars,
04024               int32_t srcStart,
04025               int32_t srcLength)
04026 { return doReplace(fLength, 0, srcChars, srcStart, srcLength); }
04027 
04028 inline UnicodeString&
04029 UnicodeString::append(const UChar *srcChars,
04030               int32_t srcLength)
04031 { return doReplace(fLength, 0, srcChars, 0, srcLength); }
04032 
04033 inline UnicodeString&
04034 UnicodeString::append(UChar srcChar)
04035 { return doReplace(fLength, 0, &srcChar, 0, 1); }
04036 
04037 inline UnicodeString&
04038 UnicodeString::append(UChar32 srcChar) {
04039   UChar buffer[U16_MAX_LENGTH];
04040   int32_t _length = 0;
04041   UBool isError = FALSE;
04042   U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError);
04043   return doReplace(fLength, 0, buffer, 0, _length);
04044 }
04045 
04046 inline UnicodeString&
04047 UnicodeString::operator+= (UChar ch)
04048 { return doReplace(fLength, 0, &ch, 0, 1); }
04049 
04050 inline UnicodeString&
04051 UnicodeString::operator+= (UChar32 ch) {
04052   return append(ch);
04053 }
04054 
04055 inline UnicodeString&
04056 UnicodeString::operator+= (const UnicodeString& srcText)
04057 { return doReplace(fLength, 0, srcText, 0, srcText.fLength); }
04058 
04059 inline UnicodeString&
04060 UnicodeString::insert(int32_t start,
04061               const UnicodeString& srcText,
04062               int32_t srcStart,
04063               int32_t srcLength)
04064 { return doReplace(start, 0, srcText, srcStart, srcLength); }
04065 
04066 inline UnicodeString&
04067 UnicodeString::insert(int32_t start,
04068               const UnicodeString& srcText)
04069 { return doReplace(start, 0, srcText, 0, srcText.fLength); }
04070 
04071 inline UnicodeString&
04072 UnicodeString::insert(int32_t start,
04073               const UChar *srcChars,
04074               int32_t srcStart,
04075               int32_t srcLength)
04076 { return doReplace(start, 0, srcChars, srcStart, srcLength); }
04077 
04078 inline UnicodeString&
04079 UnicodeString::insert(int32_t start,
04080               const UChar *srcChars,
04081               int32_t srcLength)
04082 { return doReplace(start, 0, srcChars, 0, srcLength); }
04083 
04084 inline UnicodeString&
04085 UnicodeString::insert(int32_t start,
04086               UChar srcChar)
04087 { return doReplace(start, 0, &srcChar, 0, 1); }
04088 
04089 inline UnicodeString&
04090 UnicodeString::insert(int32_t start,
04091               UChar32 srcChar)
04092 { return replace(start, 0, srcChar); }
04093 
04094 
04095 inline UnicodeString&
04096 UnicodeString::remove()
04097 {
04098   // remove() of a bogus string makes the string empty and non-bogus
04099   if(isBogus()) {
04100     unBogus();
04101   } else {
04102     fLength = 0;
04103   }
04104   return *this;
04105 }
04106 
04107 inline UnicodeString&
04108 UnicodeString::remove(int32_t start,
04109              int32_t _length)
04110 {
04111     if(start <= 0 && _length == INT32_MAX) {
04112         // remove(guaranteed everything) of a bogus string makes the string empty and non-bogus
04113         return remove();
04114     }
04115     return doReplace(start, _length, NULL, 0, 0);
04116 }
04117 
04118 inline UnicodeString&
04119 UnicodeString::removeBetween(int32_t start,
04120                 int32_t limit)
04121 { return doReplace(start, limit - start, NULL, 0, 0); }
04122 
04123 inline UBool
04124 UnicodeString::truncate(int32_t targetLength)
04125 {
04126   if(isBogus() && targetLength == 0) {
04127     // truncate(0) of a bogus string makes the string empty and non-bogus
04128     unBogus();
04129     return FALSE;
04130   } else if((uint32_t)targetLength < (uint32_t)fLength) {
04131     fLength = targetLength;
04132     return TRUE;
04133   } else {
04134     return FALSE;
04135   }
04136 }
04137 
04138 inline UnicodeString&
04139 UnicodeString::reverse()
04140 { return doReverse(0, fLength); }
04141 
04142 inline UnicodeString&
04143 UnicodeString::reverse(int32_t start,
04144                int32_t _length)
04145 { return doReverse(start, _length); }
04146 
04147 U_NAMESPACE_END
04148 
04149 #endif

Generated on Wed Aug 8 04:04:33 2007 for ICU 3.8 by  doxygen 1.5.2