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