include/wx/string.h

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