include/wx/string.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        string.h
   3 // Purpose:     wxString and wxArrayString classes
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 /*
  13     Efficient string class [more or less] compatible with MFC CString,
  14     wxWindows version 1 wxString and std::string and some handy functions
  15     missing from string.h.
  16 */
  17
  18 #ifndef _WX_WXSTRINGH__
  19 #define _WX_WXSTRINGH__
  20
  21 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  22     #pragma interface "string.h"
  23 #endif
  24
  25 // ----------------------------------------------------------------------------
  26 // headers
  27 // ----------------------------------------------------------------------------
  28
  29 #include "wx/defs.h"        // everybody should include this
  30
  31 #if defined(__WXMAC__) || defined(__VISAGECPP__)
  32     #include <ctype.h>
  33 #endif
  34
  35 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
  36    // problem in VACPP V4 with including stdlib.h multiple times
  37    // strconv includes it anyway
  38 #  include <stdio.h>
  39 #  include <string.h>
  40 #  include <stdarg.h>
  41 #  include <limits.h>
  42 #else
  43 #  include <string.h>
  44 #  include <stdio.h>
  45 #  include <stdarg.h>
  46 #  include <limits.h>
  47 #  include <stdlib.h>
  48 #endif
  49
  50 #ifdef HAVE_STRINGS_H
  51     #include <strings.h>    // for strcasecmp()
  52 #endif // HAVE_STRINGS_H
  53
  54 #include "wx/wxchar.h"      // for wxChar
  55 #include "wx/buffer.h"      // for wxCharBuffer
  56 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
  57
  58 // ---------------------------------------------------------------------------
  59 // macros
  60 // ---------------------------------------------------------------------------
  61
  62 // casts [unfortunately!] needed to call some broken functions which require
  63 // "char *" instead of "const char *"
  64 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
  65 #define   wxCSTRINGCAST (wxChar *)(const wxChar *)
  66 #define   wxMBSTRINGCAST (char *)(const char *)
  67 #define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
  68
  69 // implementation only
  70 #define   wxASSERT_VALID_INDEX(i) \
  71     wxASSERT_MSG( (size_t)(i) <= length(), _T("invalid index in wxString") )
  72
  73 // ----------------------------------------------------------------------------
  74 // constants
  75 // ----------------------------------------------------------------------------
  76
  77 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
  78 // must define this static for VA or else you get multiply defined symbols everywhere
  79 extern const unsigned int wxSTRING_MAXLEN;
  80
  81 #else
  82 // maximum possible length for a string means "take all string" everywhere
  83 //  (as sizeof(StringData) is unknown here, we substract 100)
  84 const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
  85
  86 #endif
  87
  88 // ----------------------------------------------------------------------------
  89 // global data
  90 // ----------------------------------------------------------------------------
  91
  92 // global pointer to empty string
  93 extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString;
  94
  95 // ---------------------------------------------------------------------------
  96 // global functions complementing standard C string library replacements for
  97 // strlen() and portable strcasecmp()
  98 //---------------------------------------------------------------------------
  99
 100 // Use wxXXX() functions from wxchar.h instead! These functions are for
 101 // backwards compatibility only.
 102
 103 // checks whether the passed in pointer is NULL and if the string is empty
 104 inline bool IsEmpty(const char *p) { return (!p || !*p); }
 105
 106 // safe version of strlen() (returns 0 if passed NULL pointer)
 107 inline size_t Strlen(const char *psz)
 108   { return psz ? strlen(psz) : 0; }
 109
 110 // portable strcasecmp/_stricmp
 111 inline int Stricmp(const char *psz1, const char *psz2)
 112 {
 113 #if defined(__VISUALC__) && defined(__WXWINCE__)
 114   register char c1, c2;
 115   do {
 116     c1 = tolower(*psz1++);
 117     c2 = tolower(*psz2++);
 118   } while ( c1 && (c1 == c2) );
 119
 120   return c1 - c2;
 121 #elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
 122   return _stricmp(psz1, psz2);
 123 #elif defined(__SC__)
 124   return _stricmp(psz1, psz2);
 125 #elif defined(__SALFORDC__)
 126   return stricmp(psz1, psz2);
 127 #elif defined(__BORLANDC__)
 128   return stricmp(psz1, psz2);
 129 #elif defined(__WATCOMC__)
 130   return stricmp(psz1, psz2);
 131 #elif defined(__DJGPP__)
 132   return stricmp(psz1, psz2);
 133 #elif defined(__EMX__)
 134   return stricmp(psz1, psz2);
 135 #elif defined(__WXPM__)
 136   return stricmp(psz1, psz2);
 137 #elif defined(__UNIX__) || defined(__GNUWIN32__)
 138   return strcasecmp(psz1, psz2);
 139 #elif defined(__MWERKS__) && !defined(__INTEL__)
 140   register char c1, c2;
 141   do {
 142     c1 = tolower(*psz1++);
 143     c2 = tolower(*psz2++);
 144   } while ( c1 && (c1 == c2) );
 145
 146   return c1 - c2;
 147 #else
 148   // almost all compilers/libraries provide this function (unfortunately under
 149   // different names), that's why we don't implement our own which will surely
 150   // be more efficient than this code (uncomment to use):
 151   /*
 152     register char c1, c2;
 153     do {
 154       c1 = tolower(*psz1++);
 155       c2 = tolower(*psz2++);
 156     } while ( c1 && (c1 == c2) );
 157
 158     return c1 - c2;
 159   */
 160
 161   #error  "Please define string case-insensitive compare for your OS/compiler"
 162 #endif  // OS/compiler
 163 }
 164
 165 // return an empty wxString
 166 class WXDLLIMPEXP_BASE wxString; // not yet defined
 167 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
 168
 169 #if wxUSE_STL
 170
 171 #include "wx/beforestd.h"
 172 #include <string>
 173 #include "wx/afterstd.h"
 174
 175 #if wxUSE_UNICODE
 176     #if HAVE_STD_WSTRING
 177         typedef std::wstring wxStringBase;
 178     #else
 179         typedef std::basic_string<wxChar> wxStringBase;
 180     #endif
 181 #else
 182     typedef std::string wxStringBase;
 183 #endif
 184
 185 #if (defined(__GNUG__) && (__GNUG__ < 3)) || \
 186     (defined(_MSC_VER) && (_MSC_VER <= 1100))
 187     #define wxSTRING_BASE_HASNT_CLEAR
 188 #endif
 189
 190 #else // if !wxUSE_STL
 191
 192 #ifndef HAVE_STD_STRING_COMPARE
 193     #define HAVE_STD_STRING_COMPARE
 194 #endif
 195
 196 // ---------------------------------------------------------------------------
 197 // string data prepended with some housekeeping info (used by wxString class),
 198 // is never used directly (but had to be put here to allow inlining)
 199 // ---------------------------------------------------------------------------
 200
 201 struct WXDLLIMPEXP_BASE wxStringData
 202 {
 203   int     nRefs;        // reference count
 204   size_t  nDataLength,  // actual string length
 205           nAllocLength; // allocated memory size
 206
 207   // mimics declaration 'wxChar data[nAllocLength]'
 208   wxChar* data() const { return (wxChar*)(this + 1); }
 209
 210   // empty string has a special ref count so it's never deleted
 211   bool  IsEmpty()   const { return (nRefs == -1); }
 212   bool  IsShared()  const { return (nRefs > 1);   }
 213
 214   // lock/unlock
 215   void  Lock()   { if ( !IsEmpty() ) nRefs++;                    }
 216
 217   // VC++ will refuse to inline Unlock but profiling shows that it is wrong
 218 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 219   __forceinline
 220 #endif
 221   // VC++ free must take place in same DLL as allocation when using non dll
 222   // run-time library (e.g. Multithreaded instead of Multithreaded DLL)
 223 #if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
 224   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) Free();  }
 225   // we must not inline deallocation since allocation is not inlined
 226   void  Free();
 227 #else
 228   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
 229 #endif
 230
 231   // if we had taken control over string memory (GetWriteBuf), it's
 232   // intentionally put in invalid state
 233   void  Validate(bool b)  { nRefs = (b ? 1 : 0); }
 234   bool  IsValid() const   { return (nRefs != 0); }
 235 };
 236
 237 class WXDLLIMPEXP_BASE wxStringBase
 238 {
 239 #if !wxUSE_STL
 240 friend class WXDLLIMPEXP_BASE wxArrayString;
 241 #endif
 242 public :
 243   // an 'invalid' value for string index, moved to this place due to a CW bug
 244   static const size_t npos;
 245 protected:
 246   // points to data preceded by wxStringData structure with ref count info
 247   wxChar *m_pchData;
 248
 249   // accessor to string data
 250   wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; }
 251
 252   // string (re)initialization functions
 253     // initializes the string to the empty value (must be called only from
 254     // ctors, use Reinit() otherwise)
 255   void Init() { m_pchData = (wxChar *)wxEmptyString; }
 256     // initializaes the string with (a part of) C-string
 257   void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos);
 258     // as Init, but also frees old data
 259   void Reinit() { GetStringData()->Unlock(); Init(); }
 260
 261   // memory allocation
 262     // allocates memory for string of length nLen
 263   bool AllocBuffer(size_t nLen);
 264     // copies data to another string
 265   bool AllocCopy(wxString&, int, int) const;
 266     // effectively copies data to string
 267   bool AssignCopy(size_t, const wxChar *);
 268
 269   // append a (sub)string
 270   bool ConcatSelf(size_t nLen, const wxChar *src, size_t nMaxLen);
 271   bool ConcatSelf(size_t nLen, const wxChar *src)
 272     { return ConcatSelf(nLen, src, nLen); }
 273
 274   // functions called before writing to the string: they copy it if there
 275   // are other references to our data (should be the only owner when writing)
 276   bool CopyBeforeWrite();
 277   bool AllocBeforeWrite(size_t);
 278
 279     // compatibility with wxString
 280   bool Alloc(size_t nLen);
 281 public:
 282   // standard types
 283   typedef wxChar value_type;
 284   typedef wxChar char_type;
 285   typedef size_t size_type;
 286   typedef value_type& reference;
 287   typedef const value_type& const_reference;
 288   typedef value_type* pointer;
 289   typedef const value_type* const_pointer;
 290   typedef value_type *iterator;
 291   typedef const value_type *const_iterator;
 292
 293   // constructors and destructor
 294     // ctor for an empty string
 295   wxStringBase() { Init(); }
 296     // copy ctor
 297   wxStringBase(const wxStringBase& stringSrc)
 298   {
 299     wxASSERT_MSG( stringSrc.GetStringData()->IsValid(),
 300                   _T("did you forget to call UngetWriteBuf()?") );
 301
 302     if ( stringSrc.empty() ) {
 303       // nothing to do for an empty string
 304       Init();
 305     }
 306     else {
 307       m_pchData = stringSrc.m_pchData;            // share same data
 308       GetStringData()->Lock();                    // => one more copy
 309     }
 310   }
 311     // string containing nRepeat copies of ch
 312   wxStringBase(size_type nRepeat, wxChar ch);
 313     // ctor takes first nLength characters from C string
 314     // (default value of npos means take all the string)
 315   wxStringBase(const wxChar *psz)
 316       { InitWith(psz, 0, npos); }
 317   wxStringBase(const wxChar *psz, size_t nLength)
 318       { InitWith(psz, 0, nLength); }
 319   wxStringBase(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
 320       { InitWith(psz, 0, nLength); }
 321     // take nLen chars starting at nPos
 322   wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen)
 323   {
 324     wxASSERT_MSG( str.GetStringData()->IsValid(),
 325                   _T("did you forget to call UngetWriteBuf()?") );
 326     Init();
 327     size_t strLen = str.length() - nPos; nLen = strLen < nLen ? strLen : nLen;
 328     InitWith(str.c_str(), nPos, nLen);
 329   }
 330     // take all characters from pStart to pEnd
 331   wxStringBase(const void *pStart, const void *pEnd);
 332
 333     // dtor is not virtual, this class must not be inherited from!
 334   ~wxStringBase() { GetStringData()->Unlock(); }
 335
 336   // overloaded assignment
 337     // from another wxString
 338   wxStringBase& operator=(const wxStringBase& stringSrc);
 339     // from a character
 340   wxStringBase& operator=(wxChar ch);
 341     // from a C string
 342   wxStringBase& operator=(const wxChar *psz);
 343
 344     // return the length of the string
 345   size_type size() const { return GetStringData()->nDataLength; }
 346     // return the length of the string
 347   size_type length() const { return size(); }
 348     // return the maximum size of the string
 349   size_type max_size() const { return wxSTRING_MAXLEN; }
 350     // resize the string, filling the space with c if c != 0
 351   void resize(size_t nSize, wxChar ch = wxT('\0'));
 352     // delete the contents of the string
 353   void clear() { erase(0, npos); }
 354     // returns true if the string is empty
 355   bool empty() const { return size() == 0; }
 356     // inform string about planned change in size
 357   void reserve(size_t sz) { Alloc(sz); }
 358   size_type capacity() const { return GetStringData()->nAllocLength; }
 359
 360   // lib.string.access
 361     // return the character at position n
 362   value_type at(size_type n) const
 363     { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
 364   value_type operator[](size_type n) const { return at(n); }
 365     // returns the writable character at position n
 366   reference at(size_type n)
 367     { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
 368   reference operator[](size_type n)
 369     { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
 370
 371   // lib.string.modifiers
 372     // append elements str[pos], ..., str[pos+n]
 373   wxStringBase& append(const wxStringBase& str, size_t pos, size_t n)
 374   {
 375     wxASSERT(pos <= str.length());
 376     ConcatSelf(n, str.c_str() + pos, str.length() - pos);
 377     return *this;
 378   }
 379     // append a string
 380   wxStringBase& append(const wxStringBase& str)
 381     { ConcatSelf(str.length(), str.c_str()); return *this; }
 382     // append first n (or all if n == npos) characters of sz
 383   wxStringBase& append(const wxChar *sz)
 384     { ConcatSelf(wxStrlen(sz), sz); return *this; }
 385   wxStringBase& append(const wxChar *sz, size_t n)
 386     { ConcatSelf(n, sz); return *this; }
 387     // append n copies of ch
 388   wxStringBase& append(size_t n, wxChar ch);
 389     // append from first to last
 390   wxStringBase& append(const_iterator first, const_iterator last)
 391     { ConcatSelf(last - first, first); return *this; }
 392
 393     // same as `this_string = str'
 394   wxStringBase& assign(const wxStringBase& str)
 395     { return *this = str; }
 396     // same as ` = str[pos..pos + n]
 397   wxStringBase& assign(const wxStringBase& str, size_t pos, size_t n)
 398     { clear(); return append(str, pos, n); }
 399     // same as `= first n (or all if n == npos) characters of sz'
 400   wxStringBase& assign(const wxChar *sz)
 401     { clear(); return append(sz, wxStrlen(sz)); }
 402   wxStringBase& assign(const wxChar *sz, size_t n)
 403     { clear(); return append(sz, n); }
 404     // same as `= n copies of ch'
 405   wxStringBase& assign(size_t n, wxChar ch)
 406     { clear(); return append(n, ch); }
 407     // assign from first to last
 408   wxStringBase& assign(const_iterator first, const_iterator last)
 409     { clear(); return append(first, last); }
 410
 411     // first valid index position
 412   const_iterator begin() const { return m_pchData; }
 413     // position one after the last valid one
 414   const_iterator end() const { return m_pchData + length(); }
 415
 416   // first valid index position
 417   iterator begin() { CopyBeforeWrite(); return m_pchData; }
 418   // position one after the last valid one
 419   iterator end() { CopyBeforeWrite(); return m_pchData + length(); }
 420
 421     // insert another string
 422   wxStringBase& insert(size_t nPos, const wxStringBase& str)
 423   {
 424     wxASSERT( str.GetStringData()->IsValid() );
 425     return insert(nPos, str.c_str(), str.length());
 426   }
 427     // insert n chars of str starting at nStart (in str)
 428   wxStringBase& insert(size_t nPos, const wxStringBase& str, size_t nStart, size_t n)
 429   {
 430     wxASSERT( str.GetStringData()->IsValid() );
 431     wxASSERT( nStart < str.length() );
 432     size_t strLen = str.length() - nStart;
 433     n = strLen < n ? strLen : n;
 434     return insert(nPos, str.c_str() + nStart, n);
 435   }
 436     // insert first n (or all if n == npos) characters of sz
 437   wxStringBase& insert(size_t nPos, const wxChar *sz, size_t n = npos);
 438     // insert n copies of ch
 439   wxStringBase& insert(size_t nPos, size_t n, wxChar ch)
 440     { return insert(nPos, wxStringBase(n, ch)); }
 441   iterator insert(iterator it, wxChar ch)
 442     { size_t idx = it - begin(); insert(idx, 1, ch); return begin() + idx; }
 443   void insert(iterator it, const_iterator first, const_iterator last)
 444     { insert(it - begin(), first, last - first); }
 445   void insert(iterator it, size_type n, wxChar ch)
 446     { insert(it - begin(), n, ch); }
 447
 448     // delete characters from nStart to nStart + nLen
 449   wxStringBase& erase(size_type pos = 0, size_type n = npos);
 450   iterator erase(iterator first, iterator last)
 451   {
 452     size_t idx = first - begin();
 453     erase(idx, last - first);
 454     return begin() + idx;
 455   }
 456   iterator erase(iterator first);
 457
 458   // explicit conversion to C string (use this with printf()!)
 459   const wxChar* c_str() const { return m_pchData; }
 460   const wxChar* data() const { return m_pchData; }
 461
 462     // replaces the substring of length nLen starting at nStart
 463   wxStringBase& replace(size_t nStart, size_t nLen, const wxChar* sz);
 464     // replaces the substring of length nLen starting at nStart
 465   wxStringBase& replace(size_t nStart, size_t nLen, const wxStringBase& str)
 466     { return replace(nStart, nLen, str.c_str()); }
 467     // replaces the substring with nCount copies of ch
 468   wxStringBase& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch);
 469     // replaces a substring with another substring
 470   wxStringBase& replace(size_t nStart, size_t nLen,
 471                         const wxStringBase& str, size_t nStart2, size_t nLen2);
 472     // replaces the substring with first nCount chars of sz
 473   wxStringBase& replace(size_t nStart, size_t nLen,
 474                         const wxChar* sz, size_t nCount);
 475   wxStringBase& replace(iterator first, iterator last, const_pointer s)
 476     { return replace(first - begin(), last - first, s); }
 477   wxStringBase& replace(iterator first, iterator last, const_pointer s,
 478                         size_type n)
 479     { return replace(first - begin(), last - first, s, n); }
 480   wxStringBase& replace(iterator first, iterator last, const wxStringBase& s)
 481     { return replace(first - begin(), last - first, s); }
 482   wxStringBase& replace(iterator first, iterator last, size_type n, wxChar c)
 483     { return replace(first - begin(), last - first, n, c); }
 484   wxStringBase& replace(iterator first, iterator last,
 485                         const_iterator first1, const_iterator last1)
 486     { return replace(first - begin(), last - first, first1, last1 - first1); }
 487
 488     // swap two strings
 489   void swap(wxStringBase& str);
 490
 491     // All find() functions take the nStart argument which specifies the
 492     // position to start the search on, the default value is 0. All functions
 493     // return npos if there were no match.
 494
 495     // find a substring
 496   size_t find(const wxStringBase& str, size_t nStart = 0) const;
 497
 498   // VC++ 1.5 can't cope with this syntax.
 499 #if !defined(__VISUALC__) || defined(__WIN32__)
 500     // find first n characters of sz
 501   size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
 502 #endif // VC++ 1.5
 503
 504     // find the first occurence of character ch after nStart
 505   size_t find(wxChar ch, size_t nStart = 0) const;
 506
 507     // rfind() family is exactly like find() but works right to left
 508
 509     // as find, but from the end
 510   size_t rfind(const wxStringBase& str, size_t nStart = npos) const;
 511
 512   // VC++ 1.5 can't cope with this syntax.
 513     // as find, but from the end
 514   size_t rfind(const wxChar* sz, size_t nStart = npos,
 515                size_t n = npos) const;
 516     // as find, but from the end
 517   size_t rfind(wxChar ch, size_t nStart = npos) const;
 518
 519     // find first/last occurence of any character in the set
 520
 521     // as strpbrk() but starts at nStart, returns npos if not found
 522   size_t find_first_of(const wxStringBase& str, size_t nStart = 0) const
 523     { return find_first_of(str.c_str(), nStart); }
 524     // same as above
 525   size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;
 526     // same as find(char, size_t)
 527   size_t find_first_of(wxChar c, size_t nStart = 0) const
 528     { return find(c, nStart); }
 529     // find the last (starting from nStart) char from str in this string
 530   size_t find_last_of (const wxStringBase& str, size_t nStart = npos) const
 531     { return find_last_of(str.c_str(), nStart); }
 532     // same as above
 533   size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;
 534     // same as above
 535   size_t find_last_of(wxChar c, size_t nStart = npos) const
 536     { return rfind(c, nStart); }
 537
 538     // find first/last occurence of any character not in the set
 539
 540     // as strspn() (starting from nStart), returns npos on failure
 541   size_t find_first_not_of(const wxStringBase& str, size_t nStart = 0) const
 542     { return find_first_not_of(str.c_str(), nStart); }
 543     // same as above
 544   size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;
 545     // same as above
 546   size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
 547     //  as strcspn()
 548   size_t find_last_not_of(const wxStringBase& str, size_t nStart = npos) const
 549     { return find_first_not_of(str.c_str(), nStart); }
 550     // same as above
 551   size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
 552     // same as above
 553   size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;
 554
 555     // All compare functions return -1, 0 or 1 if the [sub]string is less,
 556     // equal or greater than the compare() argument.
 557
 558     // just like strcmp()
 559   int compare(const wxStringBase& str) const
 560     { return wxStrcmp(c_str(), str.c_str()); }
 561     // comparison with a substring
 562   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
 563     // comparison of 2 substrings
 564   int compare(size_t nStart, size_t nLen,
 565               const wxStringBase& str, size_t nStart2, size_t nLen2) const;
 566     // just like strcmp()
 567   int compare(const wxChar* sz) const
 568     { return wxStrcmp(c_str(), sz); }
 569     // substring comparison with first nCount characters of sz
 570   int compare(size_t nStart, size_t nLen,
 571               const wxChar* sz, size_t nCount = npos) const;
 572
 573   size_type copy(wxChar* s, size_type n, size_type pos = 0);
 574
 575   // substring extraction
 576   wxStringBase substr(size_t nStart = 0, size_t nLen = npos) const;
 577
 578       // string += string
 579   wxStringBase& operator+=(const wxStringBase& s) { return append(s); }
 580       // string += C string
 581   wxStringBase& operator+=(const wxChar *psz) { return append(psz); }
 582       // string += char
 583   wxStringBase& operator+=(wxChar ch) { return append(1, ch); }
 584 };
 585
 586 #endif // !wxUSE_STL
 587
 588 // ---------------------------------------------------------------------------
 589 // This is (yet another one) String class for C++ programmers. It doesn't use
 590 // any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)
 591 // thus you should be able to compile it with practicaly any C++ compiler.
 592 // This class uses copy-on-write technique, i.e. identical strings share the
 593 // same memory as long as neither of them is changed.
 594 //
 595 // This class aims to be as compatible as possible with the new standard
 596 // std::string class, but adds some additional functions and should be at
 597 // least as efficient than the standard implementation.
 598 //
 599 // Performance note: it's more efficient to write functions which take "const
 600 // String&" arguments than "const char *" if you assign the argument to
 601 // another string.
 602 //
 603 // It was compiled and tested under Win32, Linux (libc 5 & 6), Solaris 5.5.
 604 //
 605 // To do:
 606 //  - ressource support (string tables in ressources)
 607 //  - more wide character (UNICODE) support
 608 //  - regular expressions support
 609 // ---------------------------------------------------------------------------
 610
 611 class WXDLLIMPEXP_BASE wxString : public wxStringBase
 612 {
 613 #if !wxUSE_STL
 614 friend class WXDLLIMPEXP_BASE wxArrayString;
 615 #endif
 616
 617   // NB: special care was taken in arranging the member functions in such order
 618   //     that all inline functions can be effectively inlined, verify that all
 619   //     performace critical functions are still inlined if you change order!
 620 private:
 621   // if we hadn't made these operators private, it would be possible to
 622   // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
 623   // converted to char in C and we do have operator=(char)
 624   //
 625   // NB: we don't need other versions (short/long and unsigned) as attempt
 626   //     to assign another numeric type to wxString will now result in
 627   //     ambiguity between operator=(char) and operator=(int)
 628   wxString& operator=(int);
 629
 630   // these methods are not implemented - there is _no_ conversion from int to
 631   // string, you're doing something wrong if the compiler wants to call it!
 632   //
 633   // try `s << i' or `s.Printf("%d", i)' instead
 634   wxString(int);
 635
 636 public:
 637   // constructors and destructor
 638     // ctor for an empty string
 639   wxString() : wxStringBase() { }
 640     // copy ctor
 641   wxString(const wxStringBase& stringSrc) : wxStringBase(stringSrc) { }
 642   wxString(const wxString& stringSrc) : wxStringBase(stringSrc) { }
 643     // string containing nRepeat copies of ch
 644   wxString(wxChar ch, size_t nRepeat = 1)
 645       : wxStringBase(nRepeat, ch) { }
 646   wxString(size_t nRepeat, wxChar ch)
 647       : wxStringBase(nRepeat, ch) { }
 648     // ctor takes first nLength characters from C string
 649     // (default value of npos means take all the string)
 650   wxString(const wxChar *psz)
 651       : wxStringBase(psz ? psz : wxT("")) { }
 652   wxString(const wxChar *psz, size_t nLength)
 653       : wxStringBase(psz, nLength) { }
 654   wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
 655       : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
 656
 657 #if wxUSE_UNICODE
 658     // from multibyte string
 659     // (NB: nLength is right now number of Unicode characters, not
 660     //  characters in psz! So try not to use it yet!)
 661   wxString(const char *psz, wxMBConv& conv, size_t nLength = npos);
 662     // from wxWCharBuffer (i.e. return from wxGetString)
 663   wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { }
 664 #else // ANSI
 665     // from C string (for compilers using unsigned char)
 666   wxString(const unsigned char* psz, size_t nLength = npos)
 667       : wxStringBase((const char*)psz, nLength) { }
 668
 669 #if wxUSE_WCHAR_T
 670     // from wide (Unicode) string
 671   wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = npos);
 672 #endif // !wxUSE_WCHAR_T
 673
 674     // from wxCharBuffer
 675   wxString(const wxCharBuffer& psz)
 676       : wxStringBase(psz, npos) { }
 677 #endif // Unicode/ANSI
 678
 679   // generic attributes & operations
 680     // as standard strlen()
 681   size_t Len() const { return length(); }
 682     // string contains any characters?
 683   bool IsEmpty() const { return empty(); }
 684     // empty string is "FALSE", so !str will return TRUE
 685   bool operator!() const { return IsEmpty(); }
 686     // truncate the string to given length
 687   wxString& Truncate(size_t uiLen);
 688     // empty string contents
 689   void Empty()
 690   {
 691     Truncate(0);
 692
 693     wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );
 694   }
 695     // empty the string and free memory
 696   void Clear()
 697   {
 698     wxString tmp(wxEmptyString);
 699     swap(tmp);
 700   }
 701
 702   // contents test
 703     // Is an ascii value
 704   bool IsAscii() const;
 705     // Is a number
 706   bool IsNumber() const;
 707     // Is a word
 708   bool IsWord() const;
 709
 710   // data access (all indexes are 0 based)
 711     // read access
 712     wxChar  GetChar(size_t n) const
 713       { return operator[](n); }
 714     // read/write access
 715     wxChar& GetWritableChar(size_t n)
 716       { return operator[](n); }
 717     // write access
 718     void  SetChar(size_t n, wxChar ch)
 719       { operator[](n) = ch; }
 720
 721     // get last character
 722     wxChar  Last() const
 723       {
 724           wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
 725
 726           return operator[](length() - 1);
 727       }
 728
 729     // get writable last character
 730     wxChar& Last()
 731       {
 732           wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
 733           return operator[](length() - 1);
 734       }
 735
 736     /*
 737         So why do we have all these overloaded operator[]s? A bit of history:
 738         initially there was only one of them, taking size_t. Then people
 739         started complaining because they wanted to use ints as indices (I
 740         wonder why) and compilers were giving warnings about it, so we had to
 741         add the operator[](int). Then it became apparent that you couldn't
 742         write str[0] any longer because there was ambiguity between two
 743         overloads and so you now had to write str[0u] (or, of course, use the
 744         explicit casts to either int or size_t but nobody did this).
 745
 746         Finally, someone decided to compile wxWin on an Alpha machine and got
 747         a surprize: str[0u] didn't compile there because it is of type
 748         unsigned int and size_t is unsigned _long_ on Alpha and so there was
 749         ambiguity between converting uint to int or ulong. To fix this one we
 750         now add operator[](uint) for the machines where size_t is not already
 751         the same as unsigned int - hopefully this fixes the problem (for some
 752         time)
 753
 754         The only real fix is, of course, to remove all versions but the one
 755         taking size_t...
 756      */
 757
 758     // operator version of GetChar
 759     wxChar  operator[](int n) const
 760       { return wxStringBase::operator[](n); }
 761     wxChar& operator[](size_type n)
 762       { return wxStringBase::operator[](n); }
 763     wxChar operator[](size_type n) const
 764       { return wxStringBase::operator[](n); }
 765 #ifndef wxSIZE_T_IS_UINT
 766     // operator version of GetChar
 767     wxChar operator[](unsigned int n) const
 768       { return wxStringBase::operator[](n); }
 769
 770     // operator version of GetWriteableChar
 771     wxChar& operator[](unsigned int n)
 772       { return wxStringBase::operator[](n); }
 773 #endif // size_t != unsigned int
 774
 775     // implicit conversion to C string
 776     operator const wxChar*() const { return c_str(); }
 777
 778     // identical to c_str(), for wxWin 1.6x compatibility
 779     const wxChar* wx_str()  const { return c_str(); }
 780     // identical to c_str(), for MFC compatibility
 781     const wxChar* GetData() const { return c_str(); }
 782
 783     // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
 784     // converting numbers or strings which are certain not to contain special
 785     // chars (typically system functions, X atoms, environment variables etc.)
 786     //
 787     // the behaviour of these functions with the strings containing anything
 788     // else than 7 bit ASCII characters is undefined, use at your own risk.
 789 #if wxUSE_UNICODE
 790     static wxString FromAscii(const char *ascii);  // string
 791     static wxString FromAscii(const char ascii);   // char
 792     const wxCharBuffer ToAscii() const;
 793 #else // ANSI
 794     static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
 795     static wxString FromAscii(const char ascii) { return wxString( ascii ); }
 796     const char *ToAscii() const { return c_str(); }
 797 #endif // Unicode/!Unicode
 798
 799     // conversions with (possible) format conversions: have to return a
 800     // buffer with temporary data
 801     //
 802     // the functions defined (in either Unicode or ANSI) mode are mb_str() to
 803     // return an ANSI (multibyte) string, wc_str() to return a wide string and
 804     // fn_str() to return a string which should be used with the OS APIs
 805     // accepting the file names. The return value is always the same, but the
 806     // type differs because a function may either return pointer to the buffer
 807     // directly or have to use intermediate buffer for translation.
 808 #if wxUSE_UNICODE
 809     const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
 810         { return conv.cWC2MB(c_str()); }
 811
 812     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 813
 814     const wxChar* wc_str() const { return c_str(); }
 815
 816     // for compatibility with !wxUSE_UNICODE version
 817     const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
 818
 819 #if wxMBFILES
 820     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
 821 #else // !wxMBFILES
 822     const wxChar* fn_str() const { return c_str(); }
 823 #endif // wxMBFILES/!wxMBFILES
 824 #else // ANSI
 825     const wxChar* mb_str() const { return c_str(); }
 826
 827     // for compatibility with wxUSE_UNICODE version
 828     const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
 829
 830     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 831
 832 #if wxUSE_WCHAR_T
 833     const wxWCharBuffer wc_str(wxMBConv& conv) const
 834         { return conv.cMB2WC(c_str()); }
 835 #endif // wxUSE_WCHAR_T
 836
 837     const wxChar* fn_str() const { return c_str(); }
 838 #endif // Unicode/ANSI
 839
 840   // overloaded assignment
 841     // from another wxString
 842   wxString& operator=(const wxStringBase& stringSrc)
 843     { return (wxString&)wxStringBase::operator=(stringSrc); }
 844     // from a character
 845   wxString& operator=(wxChar ch)
 846     { return (wxString&)wxStringBase::operator=(ch); }
 847     // from a C string
 848   wxString& operator=(const wxChar *psz)
 849     { return (wxString&)wxStringBase::operator=(psz); }
 850 #if wxUSE_UNICODE
 851     // from wxWCharBuffer
 852   wxString& operator=(const wxWCharBuffer& psz)
 853     { (void) operator=((const wchar_t *)psz); return *this; }
 854 #else // ANSI
 855     // from another kind of C string
 856   wxString& operator=(const unsigned char* psz);
 857 #if wxUSE_WCHAR_T
 858     // from a wide string
 859   wxString& operator=(const wchar_t *pwz);
 860 #endif
 861     // from wxCharBuffer
 862   wxString& operator=(const wxCharBuffer& psz)
 863     { (void) operator=((const char *)psz); return *this; }
 864 #endif // Unicode/ANSI
 865
 866   // string concatenation
 867     // in place concatenation
 868     /*
 869         Concatenate and return the result. Note that the left to right
 870         associativity of << allows to write things like "str << str1 << str2
 871         << ..." (unlike with +=)
 872      */
 873       // string += string
 874   wxString& operator<<(const wxString& s)
 875   {
 876 #if !wxUSE_STL
 877     wxASSERT_MSG( s.GetStringData()->IsValid(),
 878                   _T("did you forget to call UngetWriteBuf()?") );
 879 #endif
 880
 881     append(s);
 882     return *this;
 883   }
 884       // string += C string
 885   wxString& operator<<(const wxChar *psz)
 886     { append(psz); return *this; }
 887       // string += char
 888   wxString& operator<<(wxChar ch) { append(1, ch); return *this; }
 889
 890       // string += buffer (i.e. from wxGetString)
 891 #if wxUSE_UNICODE
 892   wxString& operator<<(const wxWCharBuffer& s)
 893     { (void)operator<<((const wchar_t *)s); return *this; }
 894   void operator+=(const wxWCharBuffer& s)
 895     { (void)operator<<((const wchar_t *)s); }
 896 #else // !wxUSE_UNICODE
 897   wxString& operator<<(const wxCharBuffer& s)
 898     { (void)operator<<((const char *)s); return *this; }
 899   void operator+=(const wxCharBuffer& s)
 900     { (void)operator<<((const char *)s); }
 901 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 902
 903     // string += C string
 904   wxString& Append(const wxString& s)
 905     {
 906         // test for IsEmpty() to share the string if possible
 907         if ( IsEmpty() )
 908             *this = s;
 909         else
 910             append(s);
 911         return *this;
 912     }
 913   wxString& Append(const wxChar* psz)
 914     { append(psz); return *this; }
 915     // append count copies of given character
 916   wxString& Append(wxChar ch, size_t count = 1u)
 917     { append(count, ch); return *this; }
 918   wxString& Append(const wxChar* psz, size_t nLen)
 919     { append(psz, nLen); return *this; }
 920
 921     // prepend a string, return the string itself
 922   wxString& Prepend(const wxString& str)
 923     { *this = str + *this; return *this; }
 924
 925     // non-destructive concatenation
 926       //
 927   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
 928       //
 929   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
 930       //
 931   friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
 932       //
 933   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
 934       //
 935   friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
 936
 937   // stream-like functions
 938       // insert an int into string
 939   wxString& operator<<(int i)
 940     { return (*this) << Format(_T("%d"), i); }
 941       // insert an unsigned int into string
 942   wxString& operator<<(unsigned int ui)
 943     { return (*this) << Format(_T("%u"), ui); }
 944       // insert a long into string
 945   wxString& operator<<(long l)
 946     { return (*this) << Format(_T("%ld"), l); }
 947       // insert an unsigned long into string
 948   wxString& operator<<(unsigned long ul)
 949     { return (*this) << Format(_T("%lu"), ul); }
 950       // insert a float into string
 951   wxString& operator<<(float f)
 952     { return (*this) << Format(_T("%f"), f); }
 953       // insert a double into string
 954   wxString& operator<<(double d)
 955     { return (*this) << Format(_T("%g"), d); }
 956
 957   // string comparison
 958     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
 959   int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
 960     // same as Cmp() but not case-sensitive
 961   int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }
 962     // test for the string equality, either considering case or not
 963     // (if compareWithCase then the case matters)
 964   bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
 965     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
 966     // comparison with a signle character: returns TRUE if equal
 967   bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
 968     {
 969       return (length() == 1) && (compareWithCase ? GetChar(0u) == c
 970                               : wxToupper(GetChar(0u)) == wxToupper(c));
 971     }
 972
 973   // simple sub-string extraction
 974       // return substring starting at nFirst of length nCount (or till the end
 975       // if nCount = default value)
 976   wxString Mid(size_t nFirst, size_t nCount = npos) const;
 977
 978       // operator version of Mid()
 979   wxString  operator()(size_t start, size_t len) const
 980     { return Mid(start, len); }
 981
 982       // check that the string starts with prefix and return the rest of the
 983       // string in the provided pointer if it is not NULL, otherwise return
 984       // FALSE
 985   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
 986
 987       // get first nCount characters
 988   wxString Left(size_t nCount) const;
 989       // get last nCount characters
 990   wxString Right(size_t nCount) const;
 991       // get all characters before the first occurance of ch
 992       // (returns the whole string if ch not found)
 993   wxString BeforeFirst(wxChar ch) const;
 994       // get all characters before the last occurence of ch
 995       // (returns empty string if ch not found)
 996   wxString BeforeLast(wxChar ch) const;
 997       // get all characters after the first occurence of ch
 998       // (returns empty string if ch not found)
 999   wxString AfterFirst(wxChar ch) const;
1000       // get all characters after the last occurence of ch
1001       // (returns the whole string if ch not found)
1002   wxString AfterLast(wxChar ch) const;
1003
1004     // for compatibility only, use more explicitly named functions above
1005   wxString Before(wxChar ch) const { return BeforeLast(ch); }
1006   wxString After(wxChar ch) const { return AfterFirst(ch); }
1007
1008   // case conversion
1009       // convert to upper case in place, return the string itself
1010   wxString& MakeUpper();
1011       // convert to upper case, return the copy of the string
1012       // Here's something to remember: BC++ doesn't like returns in inlines.
1013   wxString Upper() const ;
1014       // convert to lower case in place, return the string itself
1015   wxString& MakeLower();
1016       // convert to lower case, return the copy of the string
1017   wxString Lower() const ;
1018
1019   // trimming/padding whitespace (either side) and truncating
1020       // remove spaces from left or from right (default) side
1021   wxString& Trim(bool bFromRight = TRUE);
1022       // add nCount copies chPad in the beginning or at the end (default)
1023   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
1024
1025   // searching and replacing
1026       // searching (return starting index, or -1 if not found)
1027   int Find(wxChar ch, bool bFromEnd = FALSE) const;   // like strchr/strrchr
1028       // searching (return starting index, or -1 if not found)
1029   int Find(const wxChar *pszSub) const;               // like strstr
1030       // replace first (or all of bReplaceAll) occurences of substring with
1031       // another string, returns the number of replacements made
1032   size_t Replace(const wxChar *szOld,
1033                  const wxChar *szNew,
1034                  bool bReplaceAll = TRUE);
1035
1036     // check if the string contents matches a mask containing '*' and '?'
1037   bool Matches(const wxChar *szMask) const;
1038
1039     // conversion to numbers: all functions return TRUE only if the whole
1040     // string is a number and put the value of this number into the pointer
1041     // provided, the base is the numeric base in which the conversion should be
1042     // done and must be comprised between 2 and 36 or be 0 in which case the
1043     // standard C rules apply (leading '0' => octal, "0x" => hex)
1044         // convert to a signed integer
1045     bool ToLong(long *val, int base = 10) const;
1046         // convert to an unsigned integer
1047     bool ToULong(unsigned long *val, int base = 10) const;
1048         // convert to a double
1049     bool ToDouble(double *val) const;
1050
1051   // formated input/output
1052     // as sprintf(), returns the number of characters written or < 0 on error
1053     // (take 'this' into account in attribute parameter count)
1054   int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
1055     // as vprintf(), returns the number of characters written or < 0 on error
1056   int PrintfV(const wxChar* pszFormat, va_list argptr);
1057
1058     // returns the string containing the result of Printf() to it
1059   static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;
1060     // the same as above, but takes a va_list
1061   static wxString FormatV(const wxChar *pszFormat, va_list argptr);
1062
1063   // raw access to string memory
1064     // ensure that string has space for at least nLen characters
1065     // only works if the data of this string is not shared
1066   bool Alloc(size_t nLen) { reserve(nLen); /*return capacity() >= nLen;*/ return true; }
1067     // minimize the string's memory
1068     // only works if the data of this string is not shared
1069   bool Shrink();
1070 #if !wxUSE_STL
1071     // get writable buffer of at least nLen bytes. Unget() *must* be called
1072     // a.s.a.p. to put string back in a reasonable state!
1073   wxChar *GetWriteBuf(size_t nLen);
1074     // call this immediately after GetWriteBuf() has been used
1075   void UngetWriteBuf();
1076   void UngetWriteBuf(size_t nLen);
1077 #endif
1078
1079   // wxWindows version 1 compatibility functions
1080
1081   // use Mid()
1082   wxString SubString(size_t from, size_t to) const
1083       { return Mid(from, (to - from + 1)); }
1084     // values for second parameter of CompareTo function
1085   enum caseCompare {exact, ignoreCase};
1086     // values for first parameter of Strip function
1087   enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
1088
1089   // use Printf()
1090   // (take 'this' into account in attribute parameter count)
1091   int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
1092
1093     // use Cmp()
1094   inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
1095     { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
1096
1097     // use Len
1098   size_t Length() const { return length(); }
1099     // Count the number of characters
1100   int Freq(wxChar ch) const;
1101     // use MakeLower
1102   void LowerCase() { MakeLower(); }
1103     // use MakeUpper
1104   void UpperCase() { MakeUpper(); }
1105     // use Trim except that it doesn't change this string
1106   wxString Strip(stripType w = trailing) const;
1107
1108     // use Find (more general variants not yet supported)
1109   size_t Index(const wxChar* psz) const { return Find(psz); }
1110   size_t Index(wxChar ch)         const { return Find(ch);  }
1111     // use Truncate
1112   wxString& Remove(size_t pos) { return Truncate(pos); }
1113   wxString& RemoveLast(size_t n = 1) { return Truncate(length() - n); }
1114
1115   wxString& Remove(size_t nStart, size_t nLen)
1116       { return (wxString&)erase( nStart, nLen ); }
1117
1118     // use Find()
1119   int First( const wxChar ch ) const { return Find(ch); }
1120   int First( const wxChar* psz ) const { return Find(psz); }
1121   int First( const wxString &str ) const { return Find(str); }
1122   int Last( const wxChar ch ) const { return Find(ch, TRUE); }
1123   bool Contains(const wxString& str) const { return Find(str) != -1; }
1124
1125     // use IsEmpty()
1126   bool IsNull() const { return IsEmpty(); }
1127
1128   // std::string compatibility functions
1129
1130     // take nLen chars starting at nPos
1131   wxString(const wxString& str, size_t nPos, size_t nLen)
1132       : wxStringBase(str, nPos, nLen) { }
1133     // take all characters from pStart to pEnd
1134   wxString(const void *pStart, const void *pEnd)
1135       : wxStringBase((const char*)pStart, (const char*)pEnd) { }
1136 #if wxUSE_STL
1137   wxString(const_iterator first, const_iterator last)
1138       : wxStringBase(first, last) { }
1139 #endif
1140
1141   // lib.string.modifiers
1142     // append elements str[pos], ..., str[pos+n]
1143   wxString& append(const wxString& str, size_t pos, size_t n)
1144     { return (wxString&)wxStringBase::append(str, pos, n); }
1145     // append a string
1146   wxString& append(const wxString& str)
1147     { return (wxString&)wxStringBase::append(str); }
1148     // append first n (or all if n == npos) characters of sz
1149   wxString& append(const wxChar *sz)
1150     { return (wxString&)wxStringBase::append(sz); }
1151   wxString& append(const wxChar *sz, size_t n)
1152     { return (wxString&)wxStringBase::append(sz, n); }
1153     // append n copies of ch
1154   wxString& append(size_t n, wxChar ch)
1155     { return (wxString&)wxStringBase::append(n, ch); }
1156     // append from first to last
1157   wxString& append(const_iterator first, const_iterator last)
1158     { return (wxString&)wxStringBase::append(first, last); }
1159
1160     // same as `this_string = str'
1161   wxString& assign(const wxString& str)
1162     { return (wxString&)wxStringBase::assign(str); }
1163     // same as ` = str[pos..pos + n]
1164   wxString& assign(const wxString& str, size_t pos, size_t n)
1165     { return (wxString&)wxStringBase::assign(str, pos, n); }
1166     // same as `= first n (or all if n == npos) characters of sz'
1167   wxString& assign(const wxChar *sz)
1168     { return (wxString&)wxStringBase::assign(sz); }
1169   wxString& assign(const wxChar *sz, size_t n)
1170     { return (wxString&)wxStringBase::assign(sz, n); }
1171     // same as `= n copies of ch'
1172   wxString& assign(size_t n, wxChar ch)
1173     { return (wxString&)wxStringBase::assign(n, ch); }
1174     // assign from first to last
1175   wxString& assign(const_iterator first, const_iterator last)
1176     { return (wxString&)wxStringBase::assign(first, last); }
1177
1178     // string comparison
1179 #ifndef HAVE_STD_STRING_COMPARE
1180   int compare(const wxStringBase& str) const;
1181     // comparison with a substring
1182   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
1183     // comparison of 2 substrings
1184   int compare(size_t nStart, size_t nLen,
1185               const wxStringBase& str, size_t nStart2, size_t nLen2) const;
1186     // just like strcmp()
1187   int compare(const wxChar* sz) const;
1188     // substring comparison with first nCount characters of sz
1189   int compare(size_t nStart, size_t nLen,
1190               const wxChar* sz, size_t nCount = npos) const;
1191 #endif // !defined HAVE_STD_STRING_COMPARE
1192
1193     // insert another string
1194   wxString& insert(size_t nPos, const wxString& str)
1195     { return (wxString&)wxStringBase::insert(nPos, str); }
1196     // insert n chars of str starting at nStart (in str)
1197   wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
1198     { return (wxString&)wxStringBase::insert(nPos, str, nStart, n); }
1199     // insert first n (or all if n == npos) characters of sz
1200   wxString& insert(size_t nPos, const wxChar *sz)
1201     { return (wxString&)wxStringBase::insert(nPos, sz); }
1202   wxString& insert(size_t nPos, const wxChar *sz, size_t n)
1203     { return (wxString&)wxStringBase::insert(nPos, sz, n); }
1204     // insert n copies of ch
1205   wxString& insert(size_t nPos, size_t n, wxChar ch)
1206     { return (wxString&)wxStringBase::insert(nPos, n, ch); }
1207   iterator insert(iterator it, wxChar ch)
1208     { return wxStringBase::insert(it, ch); }
1209   void insert(iterator it, const_iterator first, const_iterator last)
1210     { wxStringBase::insert(it, first, last); }
1211   void insert(iterator it, size_type n, wxChar ch)
1212     { wxStringBase::insert(it, n, ch); }
1213
1214     // delete characters from nStart to nStart + nLen
1215   wxString& erase(size_type pos = 0, size_type n = npos)
1216     { return (wxString&)wxStringBase::erase(pos, n); }
1217   iterator erase(iterator first, iterator last)
1218     { return wxStringBase::erase(first, last); }
1219   iterator erase(iterator first)
1220     { return wxStringBase::erase(first); }
1221
1222 #ifdef wxSTRING_BASE_HASNT_CLEAR
1223   void clear() { erase(); }
1224 #endif
1225
1226     // replaces the substring of length nLen starting at nStart
1227   wxString& replace(size_t nStart, size_t nLen, const wxChar* sz)
1228     { return (wxString&)wxStringBase::replace(nStart, nLen, sz); }
1229     // replaces the substring of length nLen starting at nStart
1230   wxString& replace(size_t nStart, size_t nLen, const wxString& str)
1231     { return (wxString&)wxStringBase::replace(nStart, nLen, str); }
1232     // replaces the substring with nCount copies of ch
1233   wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch)
1234     { return (wxString&)wxStringBase::replace(nStart, nLen, nCount, ch); }
1235     // replaces a substring with another substring
1236   wxString& replace(size_t nStart, size_t nLen,
1237                     const wxString& str, size_t nStart2, size_t nLen2)
1238     { return (wxString&)wxStringBase::replace(nStart, nLen, str,
1239                                               nStart2, nLen2); }
1240      // replaces the substring with first nCount chars of sz
1241   wxString& replace(size_t nStart, size_t nLen,
1242                     const wxChar* sz, size_t nCount)
1243     { return (wxString&)wxStringBase::replace(nStart, nLen, sz, nCount); }
1244   wxString& replace(iterator first, iterator last, const_pointer s)
1245     { return (wxString&)wxStringBase::replace(first, last, s); }
1246   wxString& replace(iterator first, iterator last, const_pointer s,
1247                     size_type n)
1248     { return (wxString&)wxStringBase::replace(first, last, s, n); }
1249   wxString& replace(iterator first, iterator last, const wxString& s)
1250     { return (wxString&)wxStringBase::replace(first, last, s); }
1251   wxString& replace(iterator first, iterator last, size_type n, wxChar c)
1252     { return (wxString&)wxStringBase::replace(first, last, n, c); }
1253   wxString& replace(iterator first, iterator last,
1254                     const_iterator first1, const_iterator last1)
1255     { return (wxString&)wxStringBase::replace(first, last, first1, last1); }
1256
1257       // string += string
1258   wxString& operator+=(const wxString& s)
1259     { return (wxString&)wxStringBase::operator+=(s); }
1260       // string += C string
1261   wxString& operator+=(const wxChar *psz)
1262     { return (wxString&)wxStringBase::operator+=(psz); }
1263       // string += char
1264   wxString& operator+=(wxChar ch)
1265     { return (wxString&)wxStringBase::operator+=(ch); }
1266 };
1267
1268 // define wxArrayString, for compatibility
1269 #if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL
1270     #include "wx/arrstr.h"
1271 #endif
1272
1273 // ----------------------------------------------------------------------------
1274 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
1275 // ----------------------------------------------------------------------------
1276
1277 #if wxUSE_STL
1278
1279 class WXDLLIMPEXP_BASE wxStringBuffer
1280 {
1281 public:
1282     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
1283         : m_str(str), m_buf(lenWanted)
1284         { }
1285
1286     ~wxStringBuffer() { m_str.assign(m_buf.data(), wxStrlen(m_buf.data())); }
1287
1288     operator wxChar*() { return m_buf.data(); }
1289
1290 private:
1291     wxString& m_str;
1292 #if wxUSE_UNICODE
1293     wxWCharBuffer m_buf;
1294 #else
1295     wxCharBuffer m_buf;
1296 #endif
1297
1298     DECLARE_NO_COPY_CLASS(wxStringBuffer)
1299 };
1300
1301 class WXDLLIMPEXP_BASE wxStringBufferLength
1302 {
1303 public:
1304     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
1305         : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false)
1306         { }
1307
1308     ~wxStringBufferLength()
1309     {
1310         wxASSERT(m_lenSet);
1311         m_str.assign(m_buf.data(), m_len);
1312     }
1313
1314     operator wxChar*() { return m_buf.data(); }
1315     void SetLength(size_t length) { m_len = length; m_lenSet = true; }
1316
1317 private:
1318     wxString& m_str;
1319 #if wxUSE_UNICODE
1320     wxWCharBuffer m_buf;
1321 #else
1322     wxCharBuffer  m_buf;
1323 #endif
1324     size_t        m_len;
1325     bool          m_lenSet;
1326
1327     DECLARE_NO_COPY_CLASS(wxStringBufferLength)
1328 };
1329
1330 #else // if !wxUSE_STL
1331
1332 class WXDLLIMPEXP_BASE wxStringBuffer
1333 {
1334 public:
1335     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
1336         : m_str(str), m_buf(NULL)
1337         { m_buf = m_str.GetWriteBuf(lenWanted); }
1338
1339     ~wxStringBuffer() { m_str.UngetWriteBuf(); }
1340
1341     operator wxChar*() const { return m_buf; }
1342
1343 private:
1344     wxString& m_str;
1345     wxChar   *m_buf;
1346
1347     DECLARE_NO_COPY_CLASS(wxStringBuffer)
1348 };
1349
1350 class WXDLLIMPEXP_BASE wxStringBufferLength
1351 {
1352 public:
1353     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
1354         : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
1355         { m_buf = m_str.GetWriteBuf(lenWanted); }
1356
1357     ~wxStringBufferLength()
1358     {
1359         wxASSERT(m_lenSet);
1360         m_str.UngetWriteBuf(m_len);
1361     }
1362
1363     operator wxChar*() const { return m_buf; }
1364     void SetLength(size_t length) { m_len = length; m_lenSet = true; }
1365
1366 private:
1367     wxString& m_str;
1368     wxChar   *m_buf;
1369     size_t    m_len;
1370     bool      m_lenSet;
1371
1372     DECLARE_NO_COPY_CLASS(wxStringBufferLength)
1373 };
1374
1375 #endif // !wxUSE_STL
1376
1377 // ---------------------------------------------------------------------------
1378 // wxString comparison functions: operator versions are always case sensitive
1379 // ---------------------------------------------------------------------------
1380
1381 #if wxUSE_STL
1382
1383 inline bool operator==(const wxString& s1, const wxString& s2)
1384     { return s1.compare(s2) == 0; }
1385 inline bool operator==(const wxString& s1, const wxChar  * s2)
1386     { return s1.compare(s2) == 0; }
1387 inline bool operator==(const wxChar  * s1, const wxString& s2)
1388     { return s2.compare(s1) == 0; }
1389 inline bool operator!=(const wxString& s1, const wxString& s2)
1390     { return s1.compare(s2) != 0; }
1391 inline bool operator!=(const wxString& s1, const wxChar  * s2)
1392     { return s1.compare(s2) != 0; }
1393 inline bool operator!=(const wxChar  * s1, const wxString& s2)
1394     { return s2.compare(s1) != 0; }
1395 inline bool operator< (const wxString& s1, const wxString& s2)
1396     { return s1.compare(s2) <  0; }
1397 inline bool operator< (const wxString& s1, const wxChar  * s2)
1398     { return s1.compare(s2) <  0; }
1399 inline bool operator< (const wxChar  * s1, const wxString& s2)
1400     { return s2.compare(s1) >  0; }
1401 inline bool operator> (const wxString& s1, const wxString& s2)
1402     { return s1.compare(s2) >  0; }
1403 inline bool operator> (const wxString& s1, const wxChar  * s2)
1404     { return s1.compare(s2) >  0; }
1405 inline bool operator> (const wxChar  * s1, const wxString& s2)
1406     { return s2.compare(s1) <  0; }
1407 inline bool operator<=(const wxString& s1, const wxString& s2)
1408     { return s1.compare(s2) <= 0; }
1409 inline bool operator<=(const wxString& s1, const wxChar  * s2)
1410     { return s1.compare(s2) <= 0; }
1411 inline bool operator<=(const wxChar  * s1, const wxString& s2)
1412     { return s2.compare(s1) >= 0; }
1413 inline bool operator>=(const wxString& s1, const wxString& s2)
1414     { return s1.compare(s2) >= 0; }
1415 inline bool operator>=(const wxString& s1, const wxChar  * s2)
1416     { return s1.compare(s2) >= 0; }
1417 inline bool operator>=(const wxChar  * s1, const wxString& s2)
1418     { return s2.compare(s1) <= 0; }
1419
1420 #else // if !wxUSE_STL
1421
1422 inline bool operator==(const wxString& s1, const wxString& s2)
1423     { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
1424 inline bool operator==(const wxString& s1, const wxChar  * s2)
1425     { return s1.Cmp(s2) == 0; }
1426 inline bool operator==(const wxChar  * s1, const wxString& s2)
1427     { return s2.Cmp(s1) == 0; }
1428 inline bool operator!=(const wxString& s1, const wxString& s2)
1429     { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
1430 inline bool operator!=(const wxString& s1, const wxChar  * s2)
1431     { return s1.Cmp(s2) != 0; }
1432 inline bool operator!=(const wxChar  * s1, const wxString& s2)
1433     { return s2.Cmp(s1) != 0; }
1434 inline bool operator< (const wxString& s1, const wxString& s2)
1435     { return s1.Cmp(s2) < 0; }
1436 inline bool operator< (const wxString& s1, const wxChar  * s2)
1437     { return s1.Cmp(s2) <  0; }
1438 inline bool operator< (const wxChar  * s1, const wxString& s2)
1439     { return s2.Cmp(s1) >  0; }
1440 inline bool operator> (const wxString& s1, const wxString& s2)
1441     { return s1.Cmp(s2) >  0; }
1442 inline bool operator> (const wxString& s1, const wxChar  * s2)
1443     { return s1.Cmp(s2) >  0; }
1444 inline bool operator> (const wxChar  * s1, const wxString& s2)
1445     { return s2.Cmp(s1) <  0; }
1446 inline bool operator<=(const wxString& s1, const wxString& s2)
1447     { return s1.Cmp(s2) <= 0; }
1448 inline bool operator<=(const wxString& s1, const wxChar  * s2)
1449     { return s1.Cmp(s2) <= 0; }
1450 inline bool operator<=(const wxChar  * s1, const wxString& s2)
1451     { return s2.Cmp(s1) >= 0; }
1452 inline bool operator>=(const wxString& s1, const wxString& s2)
1453     { return s1.Cmp(s2) >= 0; }
1454 inline bool operator>=(const wxString& s1, const wxChar  * s2)
1455     { return s1.Cmp(s2) >= 0; }
1456 inline bool operator>=(const wxChar  * s1, const wxString& s2)
1457     { return s2.Cmp(s1) <= 0; }
1458
1459 #endif // !wxUSE_STL
1460
1461 // comparison with char
1462 inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
1463 inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
1464 inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
1465 inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
1466
1467 #if wxUSE_UNICODE
1468 inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
1469     { return (s1.Cmp((const wchar_t *)s2) == 0); }
1470 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
1471     { return (s2.Cmp((const wchar_t *)s1) == 0); }
1472 inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
1473     { return (s1.Cmp((const wchar_t *)s2) != 0); }
1474 inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
1475     { return (s2.Cmp((const wchar_t *)s1) != 0); }
1476 #else // !wxUSE_UNICODE
1477 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
1478     { return (s1.Cmp((const char *)s2) == 0); }
1479 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
1480     { return (s2.Cmp((const char *)s1) == 0); }
1481 inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
1482     { return (s1.Cmp((const char *)s2) != 0); }
1483 inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
1484     { return (s2.Cmp((const char *)s1) != 0); }
1485 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1486
1487 #if !wxUSE_STL
1488
1489 wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
1490 wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
1491 wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
1492 wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
1493 wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
1494
1495 #endif // !wxUSE_STL
1496
1497 #if wxUSE_UNICODE
1498 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
1499     { return string + (const wchar_t *)buf; }
1500 inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
1501     { return (const wchar_t *)buf + string; }
1502 #else // !wxUSE_UNICODE
1503 inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
1504     { return string + (const char *)buf; }
1505 inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
1506     { return (const char *)buf + string; }
1507 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1508
1509 // ---------------------------------------------------------------------------
1510 // Implementation only from here until the end of file
1511 // ---------------------------------------------------------------------------
1512
1513 // don't pollute the library user's name space
1514 #undef wxASSERT_VALID_INDEX
1515
1516 #if wxUSE_STD_IOSTREAM
1517
1518 #include "wx/iosfwrap.h"
1519
1520 WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);
1521 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
1522
1523 #endif  // wxSTD_STRING_COMPATIBILITY
1524
1525 #endif  // _WX_WXSTRINGH__