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 // ----------------------------------------------------------------------------
  22 // headers
  23 // ----------------------------------------------------------------------------
  24
  25 #include "wx/defs.h"        // everybody should include this
  26
  27 #if defined(__WXMAC__) || defined(__VISAGECPP__)
  28     #include <ctype.h>
  29 #endif
  30
  31 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
  32    // problem in VACPP V4 with including stdlib.h multiple times
  33    // strconv includes it anyway
  34 #  include <stdio.h>
  35 #  include <string.h>
  36 #  include <stdarg.h>
  37 #  include <limits.h>
  38 #else
  39 #  include <string.h>
  40 #  include <stdio.h>
  41 #  include <stdarg.h>
  42 #  include <limits.h>
  43 #  include <stdlib.h>
  44 #endif
  45
  46 #ifdef HAVE_STRCASECMP_IN_STRINGS_H
  47     #include <strings.h>    // for strcasecmp()
  48 #endif // HAVE_STRCASECMP_IN_STRINGS_H
  49
  50 #ifdef __WXPALMOS__
  51     #include <StringMgr.h>
  52 #endif
  53
  54 #include "wx/wxchar.h"      // for wxChar, wxStrlen() etc.
  55 #include "wx/unichar.h"
  56 #include "wx/strvararg.h"
  57 #include "wx/buffer.h"      // for wxCharBuffer
  58 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
  59
  60 class WXDLLIMPEXP_BASE wxString;
  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 WXWIN_COMPATIBILITY_2_6
  82
  83 // deprecated in favour of wxString::npos, don't use in new code
  84 //
  85 // maximum possible length for a string means "take all string" everywhere
  86 #define wxSTRING_MAXLEN wxStringBase::npos
  87
  88 #endif // WXWIN_COMPATIBILITY_2_6
  89
  90 // ----------------------------------------------------------------------------
  91 // global data
  92 // ----------------------------------------------------------------------------
  93
  94 // global pointer to empty string
  95 extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxEmptyString;
  96
  97 // ---------------------------------------------------------------------------
  98 // global functions complementing standard C string library replacements for
  99 // strlen() and portable strcasecmp()
 100 //---------------------------------------------------------------------------
 101
 102 #if WXWIN_COMPATIBILITY_2_8
 103 // Use wxXXX() functions from wxcrt.h instead! These functions are for
 104 // backwards compatibility only.
 105
 106 // checks whether the passed in pointer is NULL and if the string is empty
 107 wxDEPRECATED( inline bool IsEmpty(const char *p) );
 108 inline bool IsEmpty(const char *p) { return (!p || !*p); }
 109
 110 // safe version of strlen() (returns 0 if passed NULL pointer)
 111 wxDEPRECATED( inline size_t Strlen(const char *psz) );
 112 inline size_t Strlen(const char *psz)
 113   { return psz ? strlen(psz) : 0; }
 114
 115 // portable strcasecmp/_stricmp
 116 wxDEPRECATED( inline int Stricmp(const char *psz1, const char *psz2) );
 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(__WXPALMOS__) || \
 144       defined(HAVE_STRCASECMP_IN_STRING_H) || \
 145       defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
 146       defined(__GNUWIN32__)
 147   return strcasecmp(psz1, psz2);
 148 #elif defined(__MWERKS__) && !defined(__INTEL__)
 149   register char c1, c2;
 150   do {
 151     c1 = tolower(*psz1++);
 152     c2 = tolower(*psz2++);
 153   } while ( c1 && (c1 == c2) );
 154
 155   return c1 - c2;
 156 #else
 157   // almost all compilers/libraries provide this function (unfortunately under
 158   // different names), that's why we don't implement our own which will surely
 159   // be more efficient than this code (uncomment to use):
 160   /*
 161     register char c1, c2;
 162     do {
 163       c1 = tolower(*psz1++);
 164       c2 = tolower(*psz2++);
 165     } while ( c1 && (c1 == c2) );
 166
 167     return c1 - c2;
 168   */
 169
 170   #error  "Please define string case-insensitive compare for your OS/compiler"
 171 #endif  // OS/compiler
 172 }
 173
 174 #endif // WXWIN_COMPATIBILITY_2_8
 175
 176 // ----------------------------------------------------------------------------
 177 // deal with STL/non-STL/non-STL-but-wxUSE_STD_STRING
 178 // ----------------------------------------------------------------------------
 179
 180 // FIXME-UTF8: using std::string as wxString base class is currently broken,
 181 //             so we use the standard wxString with std::string conversion
 182 //             enabled, this is API-compatible.
 183 #define wxUSE_STL_BASED_WXSTRING 0
 184 #if wxUSE_STL
 185     #undef wxUSE_STD_STRING
 186     #define wxUSE_STD_STRING 1
 187 #endif
 188 //#define wxUSE_STL_BASED_WXSTRING  wxUSE_STL
 189
 190 // in both cases we need to define wxStdString
 191 #if wxUSE_STL_BASED_WXSTRING || wxUSE_STD_STRING
 192
 193 #include "wx/beforestd.h"
 194 #include <string>
 195 #include "wx/afterstd.h"
 196
 197 #if wxUSE_UNICODE
 198     #ifdef HAVE_STD_WSTRING
 199         typedef std::wstring wxStdString;
 200     #else
 201         typedef std::basic_string<wxChar> wxStdString;
 202     #endif
 203 #else
 204     typedef std::string wxStdString;
 205 #endif
 206
 207 #endif // need <string>
 208
 209 #if wxUSE_STL_BASED_WXSTRING
 210
 211     // we don't need an extra ctor from std::string when copy ctor already does
 212     // the work
 213     #undef wxUSE_STD_STRING
 214     #define wxUSE_STD_STRING 0
 215
 216     #if (defined(__GNUG__) && (__GNUG__ < 3)) || \
 217         (defined(_MSC_VER) && (_MSC_VER <= 1200))
 218         #define wxSTRING_BASE_HASNT_CLEAR
 219     #endif
 220
 221     typedef wxStdString wxStringBase;
 222 #else // if !wxUSE_STL_BASED_WXSTRING
 223
 224 #if !defined(HAVE_STD_STRING_COMPARE) && \
 225     (!defined(__WX_SETUP_H__) || wxUSE_STL_BASED_WXSTRING == 0)
 226     #define HAVE_STD_STRING_COMPARE
 227 #endif
 228
 229 // ---------------------------------------------------------------------------
 230 // string data prepended with some housekeeping info (used by wxString class),
 231 // is never used directly (but had to be put here to allow inlining)
 232 // ---------------------------------------------------------------------------
 233
 234 struct WXDLLIMPEXP_BASE wxStringData
 235 {
 236   int     nRefs;        // reference count
 237   size_t  nDataLength,  // actual string length
 238           nAllocLength; // allocated memory size
 239
 240   // mimics declaration 'wxChar data[nAllocLength]'
 241   wxChar* data() const { return (wxChar*)(this + 1); }
 242
 243   // empty string has a special ref count so it's never deleted
 244   bool  IsEmpty()   const { return (nRefs == -1); }
 245   bool  IsShared()  const { return (nRefs > 1);   }
 246
 247   // lock/unlock
 248   void  Lock()   { if ( !IsEmpty() ) nRefs++;                    }
 249
 250   // VC++ will refuse to inline Unlock but profiling shows that it is wrong
 251 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 252   __forceinline
 253 #endif
 254   // VC++ free must take place in same DLL as allocation when using non dll
 255   // run-time library (e.g. Multithreaded instead of Multithreaded DLL)
 256 #if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
 257   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) Free();  }
 258   // we must not inline deallocation since allocation is not inlined
 259   void  Free();
 260 #else
 261   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
 262 #endif
 263
 264   // if we had taken control over string memory (GetWriteBuf), it's
 265   // intentionally put in invalid state
 266   void  Validate(bool b)  { nRefs = (b ? 1 : 0); }
 267   bool  IsValid() const   { return (nRefs != 0); }
 268 };
 269
 270 class WXDLLIMPEXP_BASE wxStringBase
 271 {
 272 public :
 273   // an 'invalid' value for string index, moved to this place due to a CW bug
 274   static const size_t npos;
 275 protected:
 276   // points to data preceded by wxStringData structure with ref count info
 277   wxChar *m_pchData;
 278
 279   // accessor to string data
 280   wxStringData* GetStringData() const { return (wxStringData*)m_pchData - 1; }
 281
 282   // string (re)initialization functions
 283     // initializes the string to the empty value (must be called only from
 284     // ctors, use Reinit() otherwise)
 285   void Init() { m_pchData = (wxChar *)wxEmptyString; }
 286     // initializes the string with (a part of) C-string
 287   void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos);
 288     // as Init, but also frees old data
 289   void Reinit() { GetStringData()->Unlock(); Init(); }
 290
 291   // memory allocation
 292     // allocates memory for string of length nLen
 293   bool AllocBuffer(size_t nLen);
 294     // copies data to another string
 295   bool AllocCopy(wxString&, int, int) const;
 296     // effectively copies data to string
 297   bool AssignCopy(size_t, const wxChar *);
 298
 299   // append a (sub)string
 300   bool ConcatSelf(size_t nLen, const wxChar *src, size_t nMaxLen);
 301   bool ConcatSelf(size_t nLen, const wxChar *src)
 302     { return ConcatSelf(nLen, src, nLen); }
 303
 304   // functions called before writing to the string: they copy it if there
 305   // are other references to our data (should be the only owner when writing)
 306   bool CopyBeforeWrite();
 307   bool AllocBeforeWrite(size_t);
 308
 309     // compatibility with wxString
 310   bool Alloc(size_t nLen);
 311 public:
 312   // standard types
 313   typedef wxUniChar value_type;
 314   typedef wxUniChar char_type;
 315   typedef wxUniCharRef reference;
 316   typedef wxChar* pointer;
 317   typedef const wxChar* const_pointer;
 318
 319   typedef size_t size_type;
 320   typedef wxUniChar const_reference;
 321
 322   #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type,                 \
 323                                reference_type, reference_ctor)              \
 324       public:                                                               \
 325           typedef wxUniChar value_type;                                     \
 326           typedef reference_type reference;                                 \
 327           typedef pointer_type pointer;                                     \
 328                                                                             \
 329           iterator_name(const iterator_name& i) : m_cur(i.m_cur) {}         \
 330                                                                             \
 331           reference operator*() const { return reference_ctor; }            \
 332                                                                             \
 333           iterator_name& operator++()                                       \
 334             { ++m_cur; return *this; }                                      \
 335           iterator_name operator++(int)                                     \
 336             { iterator_name tmp = *this; ++m_cur; return tmp; }             \
 337           iterator_name& operator--()                                       \
 338             { --m_cur; return *this; }                                      \
 339           iterator_name operator--(int)                                     \
 340             { iterator_name tmp = *this; --m_cur; return tmp; }             \
 341                                                                             \
 342           iterator_name operator+(int n) const                              \
 343             { return iterator_name(m_cur + n); }                            \
 344           iterator_name operator+(size_t n) const                           \
 345             { return iterator_name(m_cur + n); }                            \
 346           iterator_name operator-(int n) const                              \
 347             { return iterator_name(m_cur - n); }                            \
 348           iterator_name operator-(size_t n) const                           \
 349             { return iterator_name(m_cur - n); }                            \
 350           iterator_name operator+=(int n)                                   \
 351             { m_cur += n; return *this; }                                   \
 352           iterator_name operator+=(size_t n)                                \
 353             { m_cur += n; return *this; }                                   \
 354           iterator_name operator-=(int n)                                   \
 355             { m_cur -= n; return *this; }                                   \
 356           iterator_name operator-=(size_t n)                                \
 357             { m_cur -= n; return *this; }                                   \
 358                                                                             \
 359           unsigned operator-(const iterator_name& i) const                  \
 360             { return m_cur - i.m_cur; }                                     \
 361                                                                             \
 362           bool operator==(const iterator_name&i) const                      \
 363             { return m_cur == i.m_cur; }                                    \
 364           bool operator!=(const iterator_name& i) const                     \
 365             { return m_cur != i.m_cur; }                                    \
 366                                                                             \
 367           bool operator<(const iterator_name& i) const                      \
 368             { return m_cur < i.m_cur; }                                     \
 369           bool operator>(const iterator_name& i) const                      \
 370             { return m_cur > i.m_cur; }                                     \
 371           bool operator<=(const iterator_name& i) const                     \
 372             { return m_cur <= i.m_cur; }                                    \
 373           bool operator>=(const iterator_name& i) const                     \
 374             { return m_cur >= i.m_cur; }                                    \
 375                                                                             \
 376       protected:                                                            \
 377           /* for internal wxString use only: */                             \
 378           iterator_name(pointer ptr) : m_cur(ptr) {}                        \
 379           operator pointer() const { return m_cur; }                        \
 380                                                                             \
 381           friend class WXDLLIMPEXP_BASE wxString;                           \
 382           friend class WXDLLIMPEXP_BASE wxStringBase;                       \
 383           friend class WXDLLIMPEXP_BASE wxCStrData;                         \
 384                                                                             \
 385       protected:                                                            \
 386           pointer m_cur;
 387
 388   class const_iterator;
 389
 390   class iterator
 391   {
 392       WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,
 393                            wxUniCharRef::CreateForString(m_cur))
 394
 395       friend class const_iterator;
 396   };
 397
 398   class const_iterator
 399   {
 400       // NB: reference_type is intentionally value, not reference, the character
 401       //     may be encoded differently in wxString data:
 402       WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar,
 403                            wxUniChar(*m_cur))
 404
 405   public:
 406       const_iterator(const iterator& i) : m_cur(i.m_cur) {}
 407   };
 408
 409   #undef WX_STR_ITERATOR
 410
 411   template <typename T>
 412   class reverse_iterator_impl
 413   {
 414   public:
 415       typedef T iterator_type;
 416       typedef typename T::value_type value_type;
 417       typedef typename T::reference reference;
 418       typedef typename T::pointer *pointer;
 419
 420       reverse_iterator_impl(iterator_type i) : m_cur(i) {}
 421       reverse_iterator_impl(const reverse_iterator_impl& ri)
 422           : m_cur(ri.m_cur) {}
 423
 424       iterator_type base() const { return m_cur; }
 425
 426       reference operator*() const { return *(m_cur-1); }
 427
 428       reverse_iterator_impl& operator++()
 429         { --m_cur; return *this; }
 430       reverse_iterator_impl operator++(int)
 431         { reverse_iterator_impl tmp = *this; --m_cur; return tmp; }
 432       reverse_iterator_impl& operator--()
 433         { ++m_cur; return *this; }
 434       reverse_iterator_impl operator--(int)
 435         { reverse_iterator_impl tmp = *this; ++m_cur; return tmp; }
 436
 437       bool operator==(const reverse_iterator_impl& ri) const
 438         { return m_cur == ri.m_cur; }
 439       bool operator!=(const reverse_iterator_impl& ri) const
 440         { return !(*this == ri); }
 441
 442   private:
 443       iterator_type m_cur;
 444   };
 445
 446   typedef reverse_iterator_impl<iterator> reverse_iterator;
 447   typedef reverse_iterator_impl<const_iterator> const_reverse_iterator;
 448
 449
 450   // constructors and destructor
 451     // ctor for an empty string
 452   wxStringBase() { Init(); }
 453     // copy ctor
 454   wxStringBase(const wxStringBase& stringSrc)
 455   {
 456     wxASSERT_MSG( stringSrc.GetStringData()->IsValid(),
 457                   _T("did you forget to call UngetWriteBuf()?") );
 458
 459     if ( stringSrc.empty() ) {
 460       // nothing to do for an empty string
 461       Init();
 462     }
 463     else {
 464       m_pchData = stringSrc.m_pchData;            // share same data
 465       GetStringData()->Lock();                    // => one more copy
 466     }
 467   }
 468     // string containing nRepeat copies of ch
 469   wxStringBase(size_type nRepeat, wxUniChar ch);
 470     // ctor takes first nLength characters from C string
 471     // (default value of npos means take all the string)
 472   wxStringBase(const wxChar *psz)
 473       { InitWith(psz, 0, npos); }
 474   wxStringBase(const wxChar *psz, size_t nLength)
 475       { InitWith(psz, 0, nLength); }
 476   wxStringBase(const wxChar *psz,
 477                const wxMBConv& WXUNUSED(conv),
 478                size_t nLength = npos)
 479       { InitWith(psz, 0, nLength); }
 480     // take nLen chars starting at nPos
 481   wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen)
 482   {
 483     wxASSERT_MSG( str.GetStringData()->IsValid(),
 484                   _T("did you forget to call UngetWriteBuf()?") );
 485     Init();
 486     size_t strLen = str.length() - nPos; nLen = strLen < nLen ? strLen : nLen;
 487     InitWith(str.c_str(), nPos, nLen);
 488   }
 489     // take all characters from pStart to pEnd
 490   wxStringBase(const void *pStart, const void *pEnd);
 491
 492     // dtor is not virtual, this class must not be inherited from!
 493   ~wxStringBase()
 494   {
 495 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 496       //RN - according to the above VC++ does indeed inline this,
 497       //even though it spits out two warnings
 498       #pragma warning (disable:4714)
 499 #endif
 500
 501       GetStringData()->Unlock();
 502   }
 503
 504 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 505     //re-enable inlining warning
 506     #pragma warning (default:4714)
 507 #endif
 508   // overloaded assignment
 509     // from another wxString
 510   wxStringBase& operator=(const wxStringBase& stringSrc);
 511     // from a character
 512   wxStringBase& operator=(wxUniChar ch);
 513     // from a C string
 514   wxStringBase& operator=(const wxChar *psz);
 515
 516     // return the length of the string
 517   size_type length() const { return GetStringData()->nDataLength; }
 518     // return the length of the string
 519   size_type size() const { return length(); }
 520     // return the maximum size of the string
 521   size_type max_size() const { return npos; }
 522     // resize the string, filling the space with c if c != 0
 523   void resize(size_t nSize, wxUniChar ch = wxT('\0'));
 524     // delete the contents of the string
 525   void clear() { erase(0, npos); }
 526     // returns true if the string is empty
 527   bool empty() const { return length() == 0; }
 528     // inform string about planned change in size
 529   void reserve(size_t sz) { Alloc(sz); }
 530   size_type capacity() const { return GetStringData()->nAllocLength; }
 531
 532   // lib.string.access
 533     // return the character at position n
 534   value_type at(size_type n) const
 535     { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
 536     // returns the writable character at position n
 537   reference at(size_type n)
 538   {
 539     wxASSERT_VALID_INDEX( n );
 540     CopyBeforeWrite();
 541     return wxUniCharRef::CreateForString(&m_pchData[n]);
 542   }
 543
 544   // lib.string.modifiers
 545     // append elements str[pos], ..., str[pos+n]
 546   wxStringBase& append(const wxStringBase& str, size_t pos, size_t n)
 547   {
 548     wxASSERT(pos <= str.length());
 549     ConcatSelf(n, str.c_str() + pos, str.length() - pos);
 550     return *this;
 551   }
 552     // append a string
 553   wxStringBase& append(const wxStringBase& str)
 554     { ConcatSelf(str.length(), str.c_str()); return *this; }
 555     // append first n (or all if n == npos) characters of sz
 556   wxStringBase& append(const wxChar *sz)
 557     { ConcatSelf(wxStrlen(sz), sz); return *this; }
 558   wxStringBase& append(const wxChar *sz, size_t n)
 559     { ConcatSelf(n, sz); return *this; }
 560     // append n copies of ch
 561   wxStringBase& append(size_t n, wxUniChar ch);
 562     // append from first to last
 563   wxStringBase& append(const_iterator first, const_iterator last)
 564     { ConcatSelf(last - first, first); return *this; }
 565
 566     // same as `this_string = str'
 567   wxStringBase& assign(const wxStringBase& str)
 568     { return *this = str; }
 569     // same as ` = str[pos..pos + n]
 570   wxStringBase& assign(const wxStringBase& str, size_t pos, size_t n)
 571     { clear(); return append(str, pos, n); }
 572     // same as `= first n (or all if n == npos) characters of sz'
 573   wxStringBase& assign(const wxChar *sz)
 574     { clear(); return append(sz, wxStrlen(sz)); }
 575   wxStringBase& assign(const wxChar *sz, size_t n)
 576     { clear(); return append(sz, n); }
 577     // same as `= n copies of ch'
 578   wxStringBase& assign(size_t n, wxUniChar ch)
 579     { clear(); return append(n, ch); }
 580     // assign from first to last
 581   wxStringBase& assign(const_iterator first, const_iterator last)
 582     { clear(); return append(first, last); }
 583
 584     // first valid index position
 585   const_iterator begin() const { return m_pchData; }
 586   iterator begin();
 587     // position one after the last valid one
 588   const_iterator end() const { return m_pchData + length(); }
 589   iterator end();
 590
 591     // first element of the reversed string
 592   const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
 593   reverse_iterator rbegin() { return reverse_iterator(end()); }
 594     // one beyond the end of the reversed string
 595   const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 596   reverse_iterator rend() { return reverse_iterator(begin()); }
 597
 598     // insert another string
 599   wxStringBase& insert(size_t nPos, const wxStringBase& str)
 600   {
 601     wxASSERT( str.GetStringData()->IsValid() );
 602     return insert(nPos, str.c_str(), str.length());
 603   }
 604     // insert n chars of str starting at nStart (in str)
 605   wxStringBase& insert(size_t nPos, const wxStringBase& str, size_t nStart, size_t n)
 606   {
 607     wxASSERT( str.GetStringData()->IsValid() );
 608     wxASSERT( nStart < str.length() );
 609     size_t strLen = str.length() - nStart;
 610     n = strLen < n ? strLen : n;
 611     return insert(nPos, str.c_str() + nStart, n);
 612   }
 613     // insert first n (or all if n == npos) characters of sz
 614   wxStringBase& insert(size_t nPos, const wxChar *sz, size_t n = npos);
 615     // insert n copies of ch
 616   wxStringBase& insert(size_t nPos, size_t n, wxUniChar ch)
 617     { return insert(nPos, wxStringBase(n, ch)); }
 618   iterator insert(iterator it, wxUniChar ch)
 619     { size_t idx = it - begin(); insert(idx, 1, ch); return begin() + idx; }
 620   void insert(iterator it, const_iterator first, const_iterator last)
 621     { insert(it - begin(), first, last - first); }
 622   void insert(iterator it, size_type n, wxUniChar ch)
 623     { insert(it - begin(), n, ch); }
 624
 625     // delete characters from nStart to nStart + nLen
 626   wxStringBase& erase(size_type pos = 0, size_type n = npos);
 627   iterator erase(iterator first, iterator last)
 628   {
 629     size_t idx = first - begin();
 630     erase(idx, last - first);
 631     return begin() + idx;
 632   }
 633   iterator erase(iterator first);
 634
 635   // explicit conversion to C string (use this with printf()!)
 636   const wxChar* c_str() const { return m_pchData; }
 637   const wxChar* data() const { return m_pchData; }
 638
 639     // replaces the substring of length nLen starting at nStart
 640   wxStringBase& replace(size_t nStart, size_t nLen, const wxChar* sz);
 641     // replaces the substring of length nLen starting at nStart
 642   wxStringBase& replace(size_t nStart, size_t nLen, const wxStringBase& str)
 643     { return replace(nStart, nLen, str.c_str()); }
 644     // replaces the substring with nCount copies of ch
 645   wxStringBase& replace(size_t nStart, size_t nLen, size_t nCount, wxUniChar ch);
 646     // replaces a substring with another substring
 647   wxStringBase& replace(size_t nStart, size_t nLen,
 648                         const wxStringBase& str, size_t nStart2, size_t nLen2);
 649     // replaces the substring with first nCount chars of sz
 650   wxStringBase& replace(size_t nStart, size_t nLen,
 651                         const wxChar* sz, size_t nCount);
 652   wxStringBase& replace(iterator first, iterator last, const_pointer s)
 653     { return replace(first - begin(), last - first, s); }
 654   wxStringBase& replace(iterator first, iterator last, const_pointer s,
 655                         size_type n)
 656     { return replace(first - begin(), last - first, s, n); }
 657   wxStringBase& replace(iterator first, iterator last, const wxStringBase& s)
 658     { return replace(first - begin(), last - first, s); }
 659   wxStringBase& replace(iterator first, iterator last, size_type n, wxUniChar c)
 660     { return replace(first - begin(), last - first, n, c); }
 661   wxStringBase& replace(iterator first, iterator last,
 662                         const_iterator first1, const_iterator last1)
 663     { return replace(first - begin(), last - first, first1, last1 - first1); }
 664
 665     // swap two strings
 666   void swap(wxStringBase& str);
 667
 668     // All find() functions take the nStart argument which specifies the
 669     // position to start the search on, the default value is 0. All functions
 670     // return npos if there were no match.
 671
 672     // find a substring
 673   size_t find(const wxStringBase& str, size_t nStart = 0) const;
 674
 675     // find first n characters of sz
 676   size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
 677
 678     // find the first occurence of character ch after nStart
 679   size_t find(wxUniChar ch, size_t nStart = 0) const;
 680
 681     // rfind() family is exactly like find() but works right to left
 682
 683     // as find, but from the end
 684   size_t rfind(const wxStringBase& str, size_t nStart = npos) const;
 685
 686     // as find, but from the end
 687   size_t rfind(const wxChar* sz, size_t nStart = npos,
 688                size_t n = npos) const;
 689     // as find, but from the end
 690   size_t rfind(wxUniChar ch, size_t nStart = npos) const;
 691
 692     // find first/last occurence of any character in the set
 693
 694     // as strpbrk() but starts at nStart, returns npos if not found
 695   size_t find_first_of(const wxStringBase& str, size_t nStart = 0) const
 696     { return find_first_of(str.c_str(), nStart); }
 697     // same as above
 698   size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;
 699   size_t find_first_of(const wxChar* sz, size_t nStart, size_t n) const;
 700     // same as find(char, size_t)
 701   size_t find_first_of(wxUniChar c, size_t nStart = 0) const
 702     { return find(c, nStart); }
 703     // find the last (starting from nStart) char from str in this string
 704   size_t find_last_of (const wxStringBase& str, size_t nStart = npos) const
 705     { return find_last_of(str.c_str(), nStart); }
 706     // same as above
 707   size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;
 708   size_t find_last_of(const wxChar* sz, size_t nStart, size_t n) const;
 709     // same as above
 710   size_t find_last_of(wxUniChar c, size_t nStart = npos) const
 711     { return rfind(c, nStart); }
 712
 713     // find first/last occurence of any character not in the set
 714
 715     // as strspn() (starting from nStart), returns npos on failure
 716   size_t find_first_not_of(const wxStringBase& str, size_t nStart = 0) const
 717     { return find_first_not_of(str.c_str(), nStart); }
 718     // same as above
 719   size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;
 720   size_t find_first_not_of(const wxChar* sz, size_t nStart, size_t n) const;
 721     // same as above
 722   size_t find_first_not_of(wxUniChar ch, size_t nStart = 0) const;
 723     //  as strcspn()
 724   size_t find_last_not_of(const wxStringBase& str, size_t nStart = npos) const
 725     { return find_last_not_of(str.c_str(), nStart); }
 726     // same as above
 727   size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
 728   size_t find_last_not_of(const wxChar* sz, size_t nStart, size_t n) const;
 729     // same as above
 730   size_t find_last_not_of(wxUniChar ch, size_t nStart = npos) const;
 731
 732     // All compare functions return -1, 0 or 1 if the [sub]string is less,
 733     // equal or greater than the compare() argument.
 734
 735     // comparison with another string
 736   int compare(const wxStringBase& str) const;
 737     // comparison with a substring
 738   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
 739     // comparison of 2 substrings
 740   int compare(size_t nStart, size_t nLen,
 741               const wxStringBase& str, size_t nStart2, size_t nLen2) const;
 742     // comparison with a c string
 743   int compare(const wxChar* sz) const;
 744     // substring comparison with first nCount characters of sz
 745   int compare(size_t nStart, size_t nLen,
 746               const wxChar* sz, size_t nCount = npos) const;
 747
 748   size_type copy(wxChar* s, size_type n, size_type pos = 0);
 749
 750   // substring extraction
 751   wxStringBase substr(size_t nStart = 0, size_t nLen = npos) const;
 752
 753       // string += string
 754   wxStringBase& operator+=(const wxStringBase& s) { return append(s); }
 755       // string += C string
 756   wxStringBase& operator+=(const wxChar *psz) { return append(psz); }
 757       // string += char
 758   wxStringBase& operator+=(wxUniChar ch) { return append(1, ch); }
 759   wxStringBase& operator+=(wxUniCharRef ch) { return append(1, ch); }
 760   wxStringBase& operator+=(char ch) { return append(1, ch); }
 761   wxStringBase& operator+=(wchar_t ch) { return append(1, ch); }
 762 };
 763
 764 #endif // !wxUSE_STL_BASED_WXSTRING
 765
 766 // ----------------------------------------------------------------------------
 767 // wxCStrData
 768 // ----------------------------------------------------------------------------
 769
 770 // Lightweight object returned by wxString::c_str() and implicitly convertible
 771 // to either const char* or const wchar_t*.
 772 class WXDLLIMPEXP_BASE wxCStrData
 773 {
 774 private:
 775     // Ctors; for internal use by wxString and wxCStrData only
 776     wxCStrData(const wxString *str, size_t offset = 0, bool owned = false)
 777         : m_str(str), m_offset(offset), m_owned(owned) {}
 778
 779 public:
 780     // Ctor constructs the object from char literal; they are needed to make
 781     // operator?: compile and they intentionally take char*, not const char*
 782     wxCStrData(char *buf);
 783     wxCStrData(wchar_t *buf);
 784
 785     ~wxCStrData();
 786
 787     // FIXME: we'll need convertors for both char* and wchar_t* and NONE
 788     //        for wxChar*, but that's after completing the transition to
 789     //        "smart" wxUniChar class. For now, just have conversion to
 790     //        char* in ANSI build and wchar_t in Unicode build.
 791 #if wxUSE_UNICODE
 792     const wchar_t* AsWChar() const;
 793     operator const wchar_t*() const { return AsWChar(); }
 794 #else
 795     const char* AsChar() const;
 796     const unsigned char* AsUnsignedChar() const
 797         { return (const unsigned char *) AsChar(); }
 798     operator const char*() const { return AsChar(); }
 799     operator const unsigned char*() const { return AsUnsignedChar(); }
 800 #endif
 801
 802     wxString AsString() const;
 803     operator wxString() const;
 804
 805     // allow expressions like "c_str()[0]":
 806     wxUniChar operator[](int n) const { return operator[](size_t(n)); }
 807     wxUniChar operator[](size_t n) const;
 808     wxUniChar operator[](long n) const { return operator[](size_t(n)); }
 809 #ifndef wxSIZE_T_IS_UINT
 810     wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }
 811 #endif // size_t != unsigned int
 812
 813     // these operators are needed to emulate the pointer semantics of c_str():
 814     // expressions like "wxChar *p = str.c_str() + 1;" should continue to work
 815     // (we need both versions to resolve ambiguities):
 816     wxCStrData operator+(int n) const
 817         { return wxCStrData(m_str, m_offset + n, m_owned); }
 818     wxCStrData operator+(long n) const
 819         { return wxCStrData(m_str, m_offset + n, m_owned); }
 820     wxCStrData operator+(size_t n) const
 821         { return wxCStrData(m_str, m_offset + n, m_owned); }
 822
 823     // this operator is needed to make expressions like "*c_str()" or
 824     // "*(c_str() + 2)" work
 825     wxUniChar operator*() const;
 826
 827 private:
 828     const wxString *m_str;
 829     size_t m_offset;
 830     bool m_owned;
 831
 832     friend class WXDLLIMPEXP_BASE wxString;
 833 };
 834
 835 // ----------------------------------------------------------------------------
 836 // wxStringPrintfMixin
 837 // ---------------------------------------------------------------------------
 838
 839 // NB: VC6 has a bug that causes linker errors if you have template methods
 840 //     in a class using __declspec(dllimport). The solution is to split such
 841 //     class into two classes, one that contains the template methods and does
 842 //     *not* use WXDLLIMPEXP_BASE and another class that contains the rest
 843 //     (with DLL linkage).
 844 //
 845 //     We only do this for VC6 here, because the code is less efficient
 846 //     (Printf() has to use dynamic_cast<>) and because OpenWatcom compiler
 847 //     cannot compile this code.
 848
 849 #if defined(__VISUALC__) && __VISUALC__ < 1300
 850     #define wxNEEDS_WXSTRING_PRINTF_MIXIN
 851 #endif
 852
 853 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 854 // this class contains implementation of wxString's vararg methods, it's
 855 // exported from wxBase DLL
 856 class WXDLLIMPEXP_BASE wxStringPrintfMixinBase
 857 {
 858 protected:
 859     wxStringPrintfMixinBase() {}
 860
 861     int DoPrintf(const wxChar *format, ...) ATTRIBUTE_PRINTF_2;
 862     static wxString DoFormat(const wxChar *format, ...) ATTRIBUTE_PRINTF_1;
 863 };
 864
 865 // this class contains template wrappers for wxString's vararg methods, it's
 866 // intentionally *not* exported from the DLL in order to fix the VC6 bug
 867 // described above
 868 class wxStringPrintfMixin : public wxStringPrintfMixinBase
 869 {
 870 private:
 871     // to further complicate things, we can't return wxString from
 872     // wxStringPrintfMixin::Format() because wxString is not yet declared at
 873     // this point; the solution is to use this fake type trait template - this
 874     // way the compiler won't know the return type until Format() is used
 875     // (this doesn't compile with Watcom, but VC6 compiles it just fine):
 876     template<typename T> struct StringReturnType
 877     {
 878         typedef wxString type;
 879     };
 880
 881 public:
 882     // these are duplicated wxString methods, they're also declared below
 883     // if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
 884
 885     // int Printf(const wxChar *pszFormat, ...);
 886     WX_DEFINE_VARARG_FUNC(int, Printf, DoPrintf)
 887     // static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;
 888     WX_DEFINE_VARARG_FUNC(static typename StringReturnType<T1>::type,
 889                           Format, DoFormat)
 890     // int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
 891     WX_DEFINE_VARARG_FUNC(int, sprintf, DoPrintf)
 892
 893 protected:
 894     wxStringPrintfMixin() : wxStringPrintfMixinBase() {}
 895 };
 896 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
 897
 898
 899 // ----------------------------------------------------------------------------
 900 // wxString: string class trying to be compatible with std::string, MFC
 901 //           CString and wxWindows 1.x wxString all at once
 902 // ---------------------------------------------------------------------------
 903
 904 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 905     // "non dll-interface class 'wxStringPrintfMixin' used as base interface
 906     // for dll-interface class 'wxString'" -- this is OK in our case
 907     #pragma warning (disable:4275)
 908 #endif
 909
 910 class WXDLLIMPEXP_BASE wxString : public wxStringBase
 911 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 912                                  ,public wxStringPrintfMixin
 913 #endif
 914 {
 915   // NB: special care was taken in arranging the member functions in such order
 916   //     that all inline functions can be effectively inlined, verify that all
 917   //     performance critical functions are still inlined if you change order!
 918 private:
 919   // if we hadn't made these operators private, it would be possible to
 920   // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
 921   // converted to char in C and we do have operator=(char)
 922   //
 923   // NB: we don't need other versions (short/long and unsigned) as attempt
 924   //     to assign another numeric type to wxString will now result in
 925   //     ambiguity between operator=(char) and operator=(int)
 926   wxString& operator=(int);
 927
 928   // these methods are not implemented - there is _no_ conversion from int to
 929   // string, you're doing something wrong if the compiler wants to call it!
 930   //
 931   // try `s << i' or `s.Printf("%d", i)' instead
 932   wxString(int);
 933
 934 public:
 935   // constructors and destructor
 936     // ctor for an empty string
 937   wxString() : wxStringBase() { }
 938     // copy ctor
 939   wxString(const wxStringBase& stringSrc) : wxStringBase(stringSrc) { }
 940   wxString(const wxString& stringSrc) : wxStringBase(stringSrc) { }
 941     // string containing nRepeat copies of ch
 942   wxString(wxUniChar ch, size_t nRepeat = 1)
 943       : wxStringBase(nRepeat, ch) { }
 944   wxString(size_t nRepeat, wxUniChar ch)
 945       : wxStringBase(nRepeat, ch) { }
 946   wxString(wxUniCharRef ch, size_t nRepeat = 1)
 947       : wxStringBase(nRepeat, ch) { }
 948   wxString(size_t nRepeat, wxUniCharRef ch)
 949       : wxStringBase(nRepeat, ch) { }
 950   wxString(char ch, size_t nRepeat = 1)
 951       : wxStringBase(nRepeat, ch) { }
 952   wxString(size_t nRepeat, char ch)
 953       : wxStringBase(nRepeat, ch) { }
 954   wxString(wchar_t ch, size_t nRepeat = 1)
 955       : wxStringBase(nRepeat, ch) { }
 956   wxString(size_t nRepeat, wchar_t ch)
 957       : wxStringBase(nRepeat, ch) { }
 958     // ctor takes first nLength characters from C string
 959     // (default value of npos means take all the string)
 960   wxString(const wxChar *psz)
 961       : wxStringBase(psz ? psz : wxT("")) { }
 962   wxString(const wxChar *psz, size_t nLength)
 963       : wxStringBase(psz, nLength) { }
 964   wxString(const wxChar *psz,
 965            const wxMBConv& WXUNUSED(conv),
 966            size_t nLength = npos)
 967       : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
 968
 969   // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
 970   // implicit conversions from std::string to wxString as this allows to use
 971   // the same strings in non-GUI and GUI code, however we don't want to
 972   // unconditionally add this ctor as it would make wx lib dependent on
 973   // libstdc++ on some Linux versions which is bad, so instead we ask the
 974   // client code to define this wxUSE_STD_STRING symbol if they need it
 975 #if wxUSE_STD_STRING
 976   wxString(const wxStdString& s)
 977       : wxStringBase(s.c_str()) { }
 978 #endif // wxUSE_STD_STRING
 979
 980 #if wxUSE_UNICODE
 981     // from multibyte string
 982   wxString(const char *psz,
 983            const wxMBConv& conv = wxConvLibc,
 984            size_t nLength = npos);
 985     // from wxWCharBuffer (i.e. return from wxGetString)
 986   wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { }
 987 #else // ANSI
 988     // from C string (for compilers using unsigned char)
 989   wxString(const unsigned char* psz)
 990       : wxStringBase((const char*)psz) { }
 991     // from part of C string (for compilers using unsigned char)
 992   wxString(const unsigned char* psz, size_t nLength)
 993       : wxStringBase((const char*)psz, nLength) { }
 994
 995     // as we provide both ctors with this signature for both char and unsigned
 996     // char string, we need to provide one for wxCStrData to resolve ambiguity
 997   wxString(const wxCStrData& cstr, size_t nLength)
 998       : wxStringBase(cstr.AsChar(), nLength) { }
 999
1000     // and because wxString is convertible to wxCStrData and const wxChar *
1001     // we also need to provide this one
1002   wxString(const wxString& str, size_t nLength)
1003       : wxStringBase(str, 0, nLength) { }
1004
1005 #if wxUSE_WCHAR_T
1006     // from wide (Unicode) string
1007   wxString(const wchar_t *pwz,
1008            const wxMBConv& conv = wxConvLibc,
1009            size_t nLength = npos);
1010 #endif // !wxUSE_WCHAR_T
1011
1012     // from wxCharBuffer
1013   wxString(const wxCharBuffer& psz)
1014       : wxStringBase(psz) { }
1015 #endif // Unicode/ANSI
1016
1017   // generic attributes & operations
1018     // as standard strlen()
1019   size_t Len() const { return length(); }
1020     // string contains any characters?
1021   bool IsEmpty() const { return empty(); }
1022     // empty string is "false", so !str will return true
1023   bool operator!() const { return empty(); }
1024     // truncate the string to given length
1025   wxString& Truncate(size_t uiLen);
1026     // empty string contents
1027   void Empty()
1028   {
1029     Truncate(0);
1030
1031     wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
1032   }
1033     // empty the string and free memory
1034   void Clear()
1035   {
1036     wxString tmp(wxEmptyString);
1037     swap(tmp);
1038   }
1039
1040   // contents test
1041     // Is an ascii value
1042   bool IsAscii() const;
1043     // Is a number
1044   bool IsNumber() const;
1045     // Is a word
1046   bool IsWord() const;
1047
1048   // data access (all indexes are 0 based)
1049     // read access
1050     wxUniChar GetChar(size_t n) const
1051       { return at(n); }
1052     // read/write access
1053     wxUniCharRef GetWritableChar(size_t n)
1054       { return at(n); }
1055     // write access
1056     void  SetChar(size_t n, wxUniChar ch)
1057       { at(n) = ch; }
1058
1059     // get last character
1060     wxUniChar  Last() const
1061       {
1062           wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1063
1064           return at(length() - 1);
1065       }
1066
1067     // get writable last character
1068     wxUniCharRef Last()
1069       {
1070           wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
1071           return at(length() - 1);
1072       }
1073
1074     /*
1075        Note that we we must define all of the overloads below to avoid
1076        ambiguity when using str[0].
1077      */
1078     wxUniChar operator[](int n) const
1079       { return wxStringBase::at(n); }
1080     wxUniChar operator[](long n) const
1081       { return wxStringBase::at(n); }
1082     wxUniChar operator[](size_t n) const
1083       { return wxStringBase::at(n); }
1084 #ifndef wxSIZE_T_IS_UINT
1085     wxUniChar operator[](unsigned int n) const
1086       { return wxStringBase::at(n); }
1087 #endif // size_t != unsigned int
1088
1089     // operator versions of GetWriteableChar()
1090     wxUniCharRef operator[](int n)
1091       { return wxStringBase::at(n); }
1092     wxUniCharRef operator[](long n)
1093       { return wxStringBase::at(n); }
1094     wxUniCharRef operator[](size_t n)
1095       { return wxStringBase::at(n); }
1096 #ifndef wxSIZE_T_IS_UINT
1097     wxUniCharRef operator[](unsigned int n)
1098       { return wxStringBase::at(n); }
1099 #endif // size_t != unsigned int
1100
1101     // explicit conversion to C string (use this with printf()!)
1102     wxCStrData c_str() const { return wxCStrData(this); }
1103
1104     // implicit conversion to C string
1105     operator wxCStrData() const { return c_str(); }
1106     operator const wxChar*() const { return c_str(); }
1107
1108     // identical to c_str(), for MFC compatibility
1109     const wxCStrData GetData() const { return c_str(); }
1110
1111     // explicit conversion to C string in internal representation (char*,
1112     // wchar_t*, UTF-8-encoded char*, depending on the build):
1113     const_pointer wx_str() const { return data(); }
1114
1115     // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
1116     // converting numbers or strings which are certain not to contain special
1117     // chars (typically system functions, X atoms, environment variables etc.)
1118     //
1119     // the behaviour of these functions with the strings containing anything
1120     // else than 7 bit ASCII characters is undefined, use at your own risk.
1121 #if wxUSE_UNICODE
1122     static wxString FromAscii(const char *ascii);  // string
1123     static wxString FromAscii(const char ascii);   // char
1124     const wxCharBuffer ToAscii() const;
1125 #else // ANSI
1126     static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
1127     static wxString FromAscii(const char ascii) { return wxString( ascii ); }
1128     const char *ToAscii() const { return c_str(); }
1129 #endif // Unicode/!Unicode
1130
1131     // conversions with (possible) format conversions: have to return a
1132     // buffer with temporary data
1133     //
1134     // the functions defined (in either Unicode or ANSI) mode are mb_str() to
1135     // return an ANSI (multibyte) string, wc_str() to return a wide string and
1136     // fn_str() to return a string which should be used with the OS APIs
1137     // accepting the file names. The return value is always the same, but the
1138     // type differs because a function may either return pointer to the buffer
1139     // directly or have to use intermediate buffer for translation.
1140 #if wxUSE_UNICODE
1141     const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;
1142
1143     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
1144
1145     const wxChar* wc_str() const { return c_str(); }
1146
1147     // for compatibility with !wxUSE_UNICODE version
1148     const wxChar* wc_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }
1149
1150 #if wxMBFILES
1151     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
1152 #else // !wxMBFILES
1153     const wxChar* fn_str() const { return c_str(); }
1154 #endif // wxMBFILES/!wxMBFILES
1155 #else // ANSI
1156     const wxChar* mb_str() const { return c_str(); }
1157
1158     // for compatibility with wxUSE_UNICODE version
1159     const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }
1160
1161     const wxWX2MBbuf mbc_str() const { return mb_str(); }
1162
1163 #if wxUSE_WCHAR_T
1164     const wxWCharBuffer wc_str(const wxMBConv& conv) const;
1165 #endif // wxUSE_WCHAR_T
1166 #ifdef __WXOSX__
1167     const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLocal ) ); }
1168 #else
1169     const wxChar* fn_str() const { return c_str(); }
1170 #endif
1171 #endif // Unicode/ANSI
1172
1173   // overloaded assignment
1174     // from another wxString
1175   wxString& operator=(const wxStringBase& stringSrc)
1176     { return (wxString&)wxStringBase::operator=(stringSrc); }
1177   wxString& operator=(const wxCStrData& cstr);
1178     // from a character
1179   wxString& operator=(wxUniChar ch)
1180     { return (wxString&)wxStringBase::operator=(ch); }
1181   wxString& operator=(wxUniCharRef ch)
1182     { return (wxString&)wxStringBase::operator=((wxUniChar)ch); }
1183   wxString& operator=(char ch)
1184     { return (wxString&)wxStringBase::operator=(wxUniChar(ch)); }
1185   wxString& operator=(wchar_t ch)
1186     { return (wxString&)wxStringBase::operator=(wxUniChar(ch)); }
1187     // from a C string - STL probably will crash on NULL,
1188     // so we need to compensate in that case
1189 #if wxUSE_STL_BASED_WXSTRING
1190   wxString& operator=(const wxChar *psz)
1191     { if(psz) wxStringBase::operator=(psz); else Clear(); return *this; }
1192 #else
1193   wxString& operator=(const wxChar *psz)
1194     { return (wxString&)wxStringBase::operator=(psz); }
1195 #endif
1196
1197 #if wxUSE_UNICODE
1198     // from wxWCharBuffer
1199   wxString& operator=(const wxWCharBuffer& psz)
1200     { (void) operator=((const wchar_t *)psz); return *this; }
1201     // from C string
1202   wxString& operator=(const char* psz)
1203     {  return operator=(wxString(psz)); }
1204 #else // ANSI
1205     // from another kind of C string
1206   wxString& operator=(const unsigned char* psz);
1207 #if wxUSE_WCHAR_T
1208     // from a wide string
1209   wxString& operator=(const wchar_t *pwz);
1210 #endif
1211     // from wxCharBuffer
1212   wxString& operator=(const wxCharBuffer& psz)
1213     { (void) operator=((const char *)psz); return *this; }
1214 #endif // Unicode/ANSI
1215
1216   // string concatenation
1217     // in place concatenation
1218     /*
1219         Concatenate and return the result. Note that the left to right
1220         associativity of << allows to write things like "str << str1 << str2
1221         << ..." (unlike with +=)
1222      */
1223       // string += string
1224   wxString& operator<<(const wxString& s)
1225   {
1226 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL
1227     wxASSERT_MSG( s.GetStringData()->IsValid(),
1228                   _T("did you forget to call UngetWriteBuf()?") );
1229 #endif
1230
1231     append(s);
1232     return *this;
1233   }
1234       // string += C string
1235   wxString& operator<<(const wxChar *psz)
1236     { append(psz); return *this; }
1237   wxString& operator<<(const wxCStrData& psz)
1238     { append(psz); return *this; }
1239       // string += char
1240   wxString& operator<<(wxUniChar ch) { append(1, ch); return *this; }
1241   wxString& operator<<(wxUniCharRef ch) { append(1, ch); return *this; }
1242   wxString& operator<<(char ch) { append(1, ch); return *this; }
1243   wxString& operator<<(wchar_t ch) { append(1, ch); return *this; }
1244
1245       // string += buffer (i.e. from wxGetString)
1246 #if wxUSE_UNICODE
1247   wxString& operator<<(const wxWCharBuffer& s)
1248     { return operator<<((const wchar_t *)s); }
1249   wxString& operator+=(const wxWCharBuffer& s)
1250     { return operator<<((const wchar_t *)s); }
1251 #else // !wxUSE_UNICODE
1252   wxString& operator<<(const wxCharBuffer& s)
1253     { return operator<<((const char *)s); }
1254   wxString& operator+=(const wxCharBuffer& s)
1255     { return operator<<((const char *)s); }
1256 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1257
1258 #if wxUSE_UNICODE
1259     // string += C string in Unicode build (with conversion)
1260   wxString& operator<<(const char *s)
1261     { return operator<<(wxString(s)); }
1262   wxString& operator+=(const char *s)
1263     { return operator+=(wxString(s)); }
1264 #endif // wxUSE_UNICODE
1265
1266     // string += C string
1267   wxString& Append(const wxString& s)
1268     {
1269         // test for empty() to share the string if possible
1270         if ( empty() )
1271             *this = s;
1272         else
1273             append(s);
1274         return *this;
1275     }
1276   wxString& Append(const wxCStrData& psz)
1277     { append(psz); return *this; }
1278   wxString& Append(const wxChar* psz)
1279     { append(psz); return *this; }
1280     // append count copies of given character
1281   wxString& Append(wxUniChar ch, size_t count = 1u)
1282     { append(count, ch); return *this; }
1283   wxString& Append(wxUniCharRef ch, size_t count = 1u)
1284     { append(count, ch); return *this; }
1285   wxString& Append(char ch, size_t count = 1u)
1286     { append(count, ch); return *this; }
1287   wxString& Append(wchar_t ch, size_t count = 1u)
1288     { append(count, ch); return *this; }
1289   wxString& Append(const wxChar* psz, size_t nLen)
1290     { append(psz, nLen); return *this; }
1291
1292     // prepend a string, return the string itself
1293   wxString& Prepend(const wxString& str)
1294     { *this = str + *this; return *this; }
1295
1296     // non-destructive concatenation
1297       // two strings
1298   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,
1299                                              const wxString& string2);
1300       // string with a single char
1301   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxUniChar ch);
1302       // char with a string
1303   friend wxString WXDLLIMPEXP_BASE operator+(wxUniChar ch, const wxString& string);
1304       // string with C string
1305   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string,
1306                                              const wxChar *psz);
1307       // C string with string
1308   friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz,
1309                                              const wxString& string);
1310
1311   // stream-like functions
1312       // insert an int into string
1313   wxString& operator<<(int i)
1314     { return (*this) << Format(_T("%d"), i); }
1315       // insert an unsigned int into string
1316   wxString& operator<<(unsigned int ui)
1317     { return (*this) << Format(_T("%u"), ui); }
1318       // insert a long into string
1319   wxString& operator<<(long l)
1320     { return (*this) << Format(_T("%ld"), l); }
1321       // insert an unsigned long into string
1322   wxString& operator<<(unsigned long ul)
1323     { return (*this) << Format(_T("%lu"), ul); }
1324 #if defined wxLongLong_t && !defined wxLongLongIsLong
1325       // insert a long long if they exist and aren't longs
1326   wxString& operator<<(wxLongLong_t ll)
1327     {
1328       const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d");
1329       return (*this) << Format(fmt, ll);
1330     }
1331       // insert an unsigned long long
1332   wxString& operator<<(wxULongLong_t ull)
1333     {
1334       const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
1335       return (*this) << Format(fmt , ull);
1336     }
1337 #endif
1338       // insert a float into string
1339   wxString& operator<<(float f)
1340     { return (*this) << Format(_T("%f"), f); }
1341       // insert a double into string
1342   wxString& operator<<(double d)
1343     { return (*this) << Format(_T("%g"), d); }
1344
1345   // string comparison
1346     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
1347   int Cmp(const wxChar *psz) const;
1348   int Cmp(const wxString& s) const;
1349     // same as Cmp() but not case-sensitive
1350   int CmpNoCase(const wxChar *psz) const;
1351   int CmpNoCase(const wxString& s) const;
1352     // test for the string equality, either considering case or not
1353     // (if compareWithCase then the case matters)
1354   bool IsSameAs(const wxChar *psz, bool compareWithCase = true) const
1355     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
1356     // comparison with a single character: returns true if equal
1357   bool IsSameAs(wxUniChar c, bool compareWithCase = true) const
1358     {
1359       return (length() == 1) && (compareWithCase ? GetChar(0u) == c
1360                               : wxToupper(GetChar(0u)) == wxToupper(c));
1361     }
1362
1363   // simple sub-string extraction
1364       // return substring starting at nFirst of length nCount (or till the end
1365       // if nCount = default value)
1366   wxString Mid(size_t nFirst, size_t nCount = npos) const;
1367
1368       // operator version of Mid()
1369   wxString  operator()(size_t start, size_t len) const
1370     { return Mid(start, len); }
1371
1372       // check if the string starts with the given prefix and return the rest
1373       // of the string in the provided pointer if it is not NULL; otherwise
1374       // return false
1375   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
1376       // check if the string ends with the given suffix and return the
1377       // beginning of the string before the suffix in the provided pointer if
1378       // it is not NULL; otherwise return false
1379   bool EndsWith(const wxChar *suffix, wxString *rest = NULL) const;
1380
1381       // get first nCount characters
1382   wxString Left(size_t nCount) const;
1383       // get last nCount characters
1384   wxString Right(size_t nCount) const;
1385       // get all characters before the first occurance of ch
1386       // (returns the whole string if ch not found)
1387   wxString BeforeFirst(wxUniChar ch) const;
1388       // get all characters before the last occurence of ch
1389       // (returns empty string if ch not found)
1390   wxString BeforeLast(wxUniChar ch) const;
1391       // get all characters after the first occurence of ch
1392       // (returns empty string if ch not found)
1393   wxString AfterFirst(wxUniChar ch) const;
1394       // get all characters after the last occurence of ch
1395       // (returns the whole string if ch not found)
1396   wxString AfterLast(wxUniChar ch) const;
1397
1398     // for compatibility only, use more explicitly named functions above
1399   wxString Before(wxUniChar ch) const { return BeforeLast(ch); }
1400   wxString After(wxUniChar ch) const { return AfterFirst(ch); }
1401
1402   // case conversion
1403       // convert to upper case in place, return the string itself
1404   wxString& MakeUpper();
1405       // convert to upper case, return the copy of the string
1406       // Here's something to remember: BC++ doesn't like returns in inlines.
1407   wxString Upper() const ;
1408       // convert to lower case in place, return the string itself
1409   wxString& MakeLower();
1410       // convert to lower case, return the copy of the string
1411   wxString Lower() const ;
1412
1413   // trimming/padding whitespace (either side) and truncating
1414       // remove spaces from left or from right (default) side
1415   wxString& Trim(bool bFromRight = true);
1416       // add nCount copies chPad in the beginning or at the end (default)
1417   wxString& Pad(size_t nCount, wxUniChar chPad = wxT(' '), bool bFromRight = true);
1418
1419   // searching and replacing
1420       // searching (return starting index, or -1 if not found)
1421   int Find(wxUniChar ch, bool bFromEnd = false) const;   // like strchr/strrchr
1422       // searching (return starting index, or -1 if not found)
1423   int Find(const wxChar *pszSub) const;               // like strstr
1424       // replace first (or all of bReplaceAll) occurences of substring with
1425       // another string, returns the number of replacements made
1426   size_t Replace(const wxChar *szOld,
1427                  const wxChar *szNew,
1428                  bool bReplaceAll = true);
1429
1430     // check if the string contents matches a mask containing '*' and '?'
1431   bool Matches(const wxChar *szMask) const;
1432
1433     // conversion to numbers: all functions return true only if the whole
1434     // string is a number and put the value of this number into the pointer
1435     // provided, the base is the numeric base in which the conversion should be
1436     // done and must be comprised between 2 and 36 or be 0 in which case the
1437     // standard C rules apply (leading '0' => octal, "0x" => hex)
1438         // convert to a signed integer
1439     bool ToLong(long *val, int base = 10) const;
1440         // convert to an unsigned integer
1441     bool ToULong(unsigned long *val, int base = 10) const;
1442         // convert to wxLongLong
1443 #if defined(wxLongLong_t)
1444     bool ToLongLong(wxLongLong_t *val, int base = 10) const;
1445         // convert to wxULongLong
1446     bool ToULongLong(wxULongLong_t *val, int base = 10) const;
1447 #endif // wxLongLong_t
1448         // convert to a double
1449     bool ToDouble(double *val) const;
1450
1451
1452 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1453   // formatted input/output
1454     // as sprintf(), returns the number of characters written or < 0 on error
1455     // (take 'this' into account in attribute parameter count)
1456   // int Printf(const wxChar *pszFormat, ...);
1457   WX_DEFINE_VARARG_FUNC(int, Printf, DoPrintf)
1458 #endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN
1459     // as vprintf(), returns the number of characters written or < 0 on error
1460   int PrintfV(const wxString& format, va_list argptr);
1461
1462 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1463     // returns the string containing the result of Printf() to it
1464   // static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;
1465   WX_DEFINE_VARARG_FUNC(static wxString, Format, DoFormat)
1466 #endif
1467     // the same as above, but takes a va_list
1468   static wxString FormatV(const wxString& format, va_list argptr);
1469
1470   // raw access to string memory
1471     // ensure that string has space for at least nLen characters
1472     // only works if the data of this string is not shared
1473   bool Alloc(size_t nLen) { reserve(nLen); /*return capacity() >= nLen;*/ return true; }
1474     // minimize the string's memory
1475     // only works if the data of this string is not shared
1476   bool Shrink();
1477 #if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING
1478     // These are deprecated, use wxStringBuffer or wxStringBufferLength instead
1479     //
1480     // get writable buffer of at least nLen bytes. Unget() *must* be called
1481     // a.s.a.p. to put string back in a reasonable state!
1482   wxDEPRECATED( wxChar *GetWriteBuf(size_t nLen) );
1483     // call this immediately after GetWriteBuf() has been used
1484   wxDEPRECATED( void UngetWriteBuf() );
1485   wxDEPRECATED( void UngetWriteBuf(size_t nLen) );
1486 #endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL_BASED_WXSTRING
1487
1488   // wxWidgets version 1 compatibility functions
1489
1490   // use Mid()
1491   wxString SubString(size_t from, size_t to) const
1492       { return Mid(from, (to - from + 1)); }
1493     // values for second parameter of CompareTo function
1494   enum caseCompare {exact, ignoreCase};
1495     // values for first parameter of Strip function
1496   enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
1497
1498 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1499   // use Printf()
1500   // (take 'this' into account in attribute parameter count)
1501   // int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
1502   WX_DEFINE_VARARG_FUNC(int, sprintf, DoPrintf)
1503 #endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
1504
1505     // use Cmp()
1506   inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
1507     { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
1508
1509     // use Len
1510   size_t Length() const { return length(); }
1511     // Count the number of characters
1512   int Freq(wxUniChar ch) const;
1513     // use MakeLower
1514   void LowerCase() { MakeLower(); }
1515     // use MakeUpper
1516   void UpperCase() { MakeUpper(); }
1517     // use Trim except that it doesn't change this string
1518   wxString Strip(stripType w = trailing) const;
1519
1520     // use Find (more general variants not yet supported)
1521   size_t Index(const wxChar* psz) const { return Find(psz); }
1522   size_t Index(wxUniChar ch)         const { return Find(ch);  }
1523     // use Truncate
1524   wxString& Remove(size_t pos) { return Truncate(pos); }
1525   wxString& RemoveLast(size_t n = 1) { return Truncate(length() - n); }
1526
1527   wxString& Remove(size_t nStart, size_t nLen)
1528       { return (wxString&)erase( nStart, nLen ); }
1529
1530     // use Find()
1531   int First( const wxUniChar ch ) const { return Find(ch); }
1532   int First( char ch ) const { return Find(ch); }
1533   int First( wchar_t ch ) const { return Find(ch); }
1534   int First( const wxChar* psz ) const { return Find(psz); }
1535   int First( const wxString &str ) const { return Find(str); }
1536   int Last( const wxUniChar ch ) const { return Find(ch, true); }
1537   bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; }
1538
1539     // use empty()
1540   bool IsNull() const { return empty(); }
1541
1542   // std::string compatibility functions
1543
1544     // take nLen chars starting at nPos
1545   wxString(const wxString& str, size_t nPos, size_t nLen)
1546       : wxStringBase(str, nPos, nLen) { }
1547     // take all characters from pStart to pEnd
1548   wxString(const void *pStart, const void *pEnd)
1549       : wxStringBase((const wxChar*)pStart, (const wxChar*)pEnd) { }
1550   wxString(const_iterator first, const_iterator last)
1551       : wxStringBase(first, last) { }
1552   wxString(iterator first, iterator last)
1553       : wxStringBase(first, last) { }
1554
1555   // lib.string.modifiers
1556     // append elements str[pos], ..., str[pos+n]
1557   wxString& append(const wxString& str, size_t pos, size_t n)
1558     { return (wxString&)wxStringBase::append(str, pos, n); }
1559     // append a string
1560   wxString& append(const wxString& str)
1561     { return (wxString&)wxStringBase::append(str); }
1562   wxString& append(const wxCStrData& str)
1563     { return (wxString&)wxStringBase::append(str.AsString()); }
1564     // append first n (or all if n == npos) characters of sz
1565   wxString& append(const wxChar *sz)
1566     { return (wxString&)wxStringBase::append(sz); }
1567   wxString& append(const wxChar *sz, size_t n)
1568     { return (wxString&)wxStringBase::append(sz, n); }
1569     // append n copies of ch
1570   wxString& append(size_t n, wxUniChar ch)
1571     { return (wxString&)wxStringBase::append(n, ch); }
1572     // append from first to last
1573   wxString& append(const_iterator first, const_iterator last)
1574     { return (wxString&)wxStringBase::append(first, last); }
1575
1576     // same as `this_string = str'
1577   wxString& assign(const wxString& str)
1578     { return (wxString&)wxStringBase::assign(str); }
1579     // same as ` = str[pos..pos + n]
1580   wxString& assign(const wxString& str, size_t pos, size_t n)
1581     { return (wxString&)wxStringBase::assign(str, pos, n); }
1582     // same as `= first n (or all if n == npos) characters of sz'
1583   wxString& assign(const wxChar *sz)
1584     { return (wxString&)wxStringBase::assign(sz); }
1585   wxString& assign(const wxChar *sz, size_t n)
1586     { return (wxString&)wxStringBase::assign(sz, n); }
1587     // same as `= n copies of ch'
1588   wxString& assign(size_t n, wxUniChar ch)
1589     { return (wxString&)wxStringBase::assign(n, ch); }
1590     // assign from first to last
1591   wxString& assign(const_iterator first, const_iterator last)
1592     { return (wxString&)wxStringBase::assign(first, last); }
1593
1594     // string comparison
1595 #if !defined(HAVE_STD_STRING_COMPARE)
1596   int compare(const wxStringBase& str) const;
1597     // comparison with a substring
1598   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
1599     // comparison of 2 substrings
1600   int compare(size_t nStart, size_t nLen,
1601               const wxStringBase& str, size_t nStart2, size_t nLen2) const;
1602     // just like strcmp()
1603   int compare(const wxChar* sz) const;
1604     // substring comparison with first nCount characters of sz
1605   int compare(size_t nStart, size_t nLen,
1606               const wxChar* sz, size_t nCount = npos) const;
1607 #endif // !defined HAVE_STD_STRING_COMPARE
1608
1609     // insert another string
1610   wxString& insert(size_t nPos, const wxString& str)
1611     { return (wxString&)wxStringBase::insert(nPos, str); }
1612     // insert n chars of str starting at nStart (in str)
1613   wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
1614     { return (wxString&)wxStringBase::insert(nPos, str, nStart, n); }
1615     // insert first n (or all if n == npos) characters of sz
1616   wxString& insert(size_t nPos, const wxChar *sz)
1617     { return (wxString&)wxStringBase::insert(nPos, sz); }
1618   wxString& insert(size_t nPos, const wxChar *sz, size_t n)
1619     { return (wxString&)wxStringBase::insert(nPos, sz, n); }
1620     // insert n copies of ch
1621   wxString& insert(size_t nPos, size_t n, wxUniChar ch)
1622     { return (wxString&)wxStringBase::insert(nPos, n, ch); }
1623   iterator insert(iterator it, wxUniChar ch)
1624     { return wxStringBase::insert(it, ch); }
1625   void insert(iterator it, const_iterator first, const_iterator last)
1626     { wxStringBase::insert(it, first, last); }
1627   void insert(iterator it, size_type n, wxUniChar ch)
1628     { wxStringBase::insert(it, n, ch); }
1629
1630     // delete characters from nStart to nStart + nLen
1631   wxString& erase(size_type pos = 0, size_type n = npos)
1632     { return (wxString&)wxStringBase::erase(pos, n); }
1633   iterator erase(iterator first, iterator last)
1634     { return wxStringBase::erase(first, last); }
1635   iterator erase(iterator first)
1636     { return wxStringBase::erase(first); }
1637
1638 #ifdef wxSTRING_BASE_HASNT_CLEAR
1639   void clear() { erase(); }
1640 #endif
1641
1642     // replaces the substring of length nLen starting at nStart
1643   wxString& replace(size_t nStart, size_t nLen, const wxChar* sz)
1644     { return (wxString&)wxStringBase::replace(nStart, nLen, sz); }
1645     // replaces the substring of length nLen starting at nStart
1646   wxString& replace(size_t nStart, size_t nLen, const wxString& str)
1647     { return (wxString&)wxStringBase::replace(nStart, nLen, str); }
1648     // replaces the substring with nCount copies of ch
1649   wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxUniChar ch)
1650     { return (wxString&)wxStringBase::replace(nStart, nLen, nCount, ch); }
1651     // replaces a substring with another substring
1652   wxString& replace(size_t nStart, size_t nLen,
1653                     const wxString& str, size_t nStart2, size_t nLen2)
1654     { return (wxString&)wxStringBase::replace(nStart, nLen, str,
1655                                               nStart2, nLen2); }
1656      // replaces the substring with first nCount chars of sz
1657   wxString& replace(size_t nStart, size_t nLen,
1658                     const wxChar* sz, size_t nCount)
1659     { return (wxString&)wxStringBase::replace(nStart, nLen, sz, nCount); }
1660   wxString& replace(iterator first, iterator last, const_pointer s)
1661     { return (wxString&)wxStringBase::replace(first, last, s); }
1662   wxString& replace(iterator first, iterator last, const_pointer s,
1663                     size_type n)
1664     { return (wxString&)wxStringBase::replace(first, last, s, n); }
1665   wxString& replace(iterator first, iterator last, const wxString& s)
1666     { return (wxString&)wxStringBase::replace(first, last, s); }
1667   wxString& replace(iterator first, iterator last, size_type n, wxUniChar c)
1668     { return (wxString&)wxStringBase::replace(first, last, n, c); }
1669   wxString& replace(iterator first, iterator last,
1670                     const_iterator first1, const_iterator last1)
1671     { return (wxString&)wxStringBase::replace(first, last, first1, last1); }
1672
1673       // string += string
1674   wxString& operator+=(const wxString& s)
1675     { return (wxString&)wxStringBase::operator+=(s); }
1676       // string += C string
1677   wxString& operator+=(const wxChar *psz)
1678     { return (wxString&)wxStringBase::operator+=(psz); }
1679   wxString& operator+=(const wxCStrData& s)
1680     { return (wxString&)wxStringBase::operator+=(s.AsString()); }
1681       // string += char
1682   wxString& operator+=(wxUniChar ch)
1683     { return (wxString&)wxStringBase::operator+=(ch); }
1684   wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); }
1685   wxString& operator+=(char ch) { return *this += wxUniChar(ch); }
1686   wxString& operator+=(unsigned char ch) { return *this += wxUniChar(ch); }
1687   wxString& operator+=(wchar_t ch) { return *this += wxUniChar(ch); }
1688
1689 private:
1690 #if !wxUSE_STL_BASED_WXSTRING
1691   // helpers for wxStringBuffer and wxStringBufferLength
1692   wxChar *DoGetWriteBuf(size_t nLen);
1693   void DoUngetWriteBuf();
1694   void DoUngetWriteBuf(size_t nLen);
1695
1696   friend class WXDLLIMPEXP_BASE wxStringBuffer;
1697   friend class WXDLLIMPEXP_BASE wxStringBufferLength;
1698 #endif
1699
1700 #ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
1701   int DoPrintf(const wxChar *format, ...) ATTRIBUTE_PRINTF_2;
1702   static wxString DoFormat(const wxChar *format, ...) ATTRIBUTE_PRINTF_1;
1703 #endif
1704 };
1705
1706 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
1707     #pragma warning (default:4275)
1708 #endif
1709
1710 // notice that even though for many compilers the friend declarations above are
1711 // enough, from the point of view of C++ standard we must have the declarations
1712 // here as friend ones are not injected in the enclosing namespace and without
1713 // them the code fails to compile with conforming compilers such as xlC or g++4
1714 wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
1715 wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
1716 wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
1717
1718 wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxUniChar ch);
1719 wxString WXDLLIMPEXP_BASE operator+(wxUniChar ch, const wxString& string);
1720
1721 inline wxString operator+(const wxString& string, wxUniCharRef ch)
1722     { return string + (wxUniChar)ch; }
1723 inline wxString operator+(const wxString& string, char ch)
1724     { return string + wxUniChar(ch); }
1725 inline wxString operator+(const wxString& string, wchar_t ch)
1726     { return string + wxUniChar(ch); }
1727 inline wxString operator+(wxUniCharRef ch, const wxString& string)
1728     { return (wxUniChar)ch + string; }
1729 inline wxString operator+(char ch, const wxString& string)
1730     { return wxUniChar(ch) + string; }
1731 inline wxString operator+(wchar_t ch, const wxString& string)
1732     { return wxUniChar(ch) + string; }
1733
1734
1735 #if wxUSE_STL_BASED_WXSTRING
1736     // return an empty wxString (not very useful with wxUSE_STL == 1)
1737     inline const wxString wxGetEmptyString() { return wxString(); }
1738 #else // !wxUSE_STL_BASED_WXSTRING
1739     // return an empty wxString (more efficient than wxString() here)
1740     inline const wxString& wxGetEmptyString()
1741     {
1742         return *(wxString *)&wxEmptyString;
1743     }
1744 #endif // wxUSE_STL_BASED_WXSTRING/!wxUSE_STL_BASED_WXSTRING
1745
1746 // ----------------------------------------------------------------------------
1747 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
1748 // ----------------------------------------------------------------------------
1749
1750 #if wxUSE_STL_BASED_WXSTRING
1751
1752 class WXDLLIMPEXP_BASE wxStringBuffer
1753 {
1754 public:
1755     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
1756         : m_str(str), m_buf(lenWanted)
1757         { }
1758
1759     ~wxStringBuffer() { m_str.assign(m_buf.data(), wxStrlen(m_buf.data())); }
1760
1761     operator wxChar*() { return m_buf.data(); }
1762
1763 private:
1764     wxString& m_str;
1765 #if wxUSE_UNICODE
1766     wxWCharBuffer m_buf;
1767 #else
1768     wxCharBuffer m_buf;
1769 #endif
1770
1771     DECLARE_NO_COPY_CLASS(wxStringBuffer)
1772 };
1773
1774 class WXDLLIMPEXP_BASE wxStringBufferLength
1775 {
1776 public:
1777     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
1778         : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false)
1779         { }
1780
1781     ~wxStringBufferLength()
1782     {
1783         wxASSERT(m_lenSet);
1784         m_str.assign(m_buf.data(), m_len);
1785     }
1786
1787     operator wxChar*() { return m_buf.data(); }
1788     void SetLength(size_t length) { m_len = length; m_lenSet = true; }
1789
1790 private:
1791     wxString& m_str;
1792 #if wxUSE_UNICODE
1793     wxWCharBuffer m_buf;
1794 #else
1795     wxCharBuffer  m_buf;
1796 #endif
1797     size_t        m_len;
1798     bool          m_lenSet;
1799
1800     DECLARE_NO_COPY_CLASS(wxStringBufferLength)
1801 };
1802
1803 #else // if !wxUSE_STL_BASED_WXSTRING
1804
1805 class WXDLLIMPEXP_BASE wxStringBuffer
1806 {
1807 public:
1808     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
1809         : m_str(str), m_buf(NULL)
1810         { m_buf = m_str.DoGetWriteBuf(lenWanted); }
1811
1812     ~wxStringBuffer() { m_str.DoUngetWriteBuf(); }
1813
1814     operator wxChar*() const { return m_buf; }
1815
1816 private:
1817     wxString& m_str;
1818     wxChar   *m_buf;
1819
1820     DECLARE_NO_COPY_CLASS(wxStringBuffer)
1821 };
1822
1823 class WXDLLIMPEXP_BASE wxStringBufferLength
1824 {
1825 public:
1826     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
1827         : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
1828     {
1829         m_buf = m_str.DoGetWriteBuf(lenWanted);
1830         wxASSERT(m_buf != NULL);
1831     }
1832
1833     ~wxStringBufferLength()
1834     {
1835         wxASSERT(m_lenSet);
1836         m_str.DoUngetWriteBuf(m_len);
1837     }
1838
1839     operator wxChar*() const { return m_buf; }
1840     void SetLength(size_t length) { m_len = length; m_lenSet = true; }
1841
1842 private:
1843     wxString& m_str;
1844     wxChar   *m_buf;
1845     size_t    m_len;
1846     bool      m_lenSet;
1847
1848     DECLARE_NO_COPY_CLASS(wxStringBufferLength)
1849 };
1850
1851 #endif // !wxUSE_STL_BASED_WXSTRING
1852
1853 // ---------------------------------------------------------------------------
1854 // wxString comparison functions: operator versions are always case sensitive
1855 // ---------------------------------------------------------------------------
1856
1857 // note that when wxUSE_STL_BASED_WXSTRING == 1 the comparison operators taking
1858 // std::string are used and defining them also for wxString would only result
1859 // in compilation ambiguities when comparing std::string and wxString
1860 #if !wxUSE_STL_BASED_WXSTRING
1861
1862 inline bool operator==(const wxString& s1, const wxString& s2)
1863     { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
1864 inline bool operator==(const wxString& s1, const wxChar  * s2)
1865     { return s1.Cmp(s2) == 0; }
1866 inline bool operator==(const wxChar  * s1, const wxString& s2)
1867     { return s2.Cmp(s1) == 0; }
1868 inline bool operator!=(const wxString& s1, const wxString& s2)
1869     { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
1870 inline bool operator!=(const wxString& s1, const wxChar  * s2)
1871     { return s1.Cmp(s2) != 0; }
1872 inline bool operator!=(const wxChar  * s1, const wxString& s2)
1873     { return s2.Cmp(s1) != 0; }
1874 inline bool operator< (const wxString& s1, const wxString& s2)
1875     { return s1.Cmp(s2) < 0; }
1876 inline bool operator< (const wxString& s1, const wxChar  * s2)
1877     { return s1.Cmp(s2) <  0; }
1878 inline bool operator< (const wxChar  * s1, const wxString& s2)
1879     { return s2.Cmp(s1) >  0; }
1880 inline bool operator> (const wxString& s1, const wxString& s2)
1881     { return s1.Cmp(s2) >  0; }
1882 inline bool operator> (const wxString& s1, const wxChar  * s2)
1883     { return s1.Cmp(s2) >  0; }
1884 inline bool operator> (const wxChar  * s1, const wxString& s2)
1885     { return s2.Cmp(s1) <  0; }
1886 inline bool operator<=(const wxString& s1, const wxString& s2)
1887     { return s1.Cmp(s2) <= 0; }
1888 inline bool operator<=(const wxString& s1, const wxChar  * s2)
1889     { return s1.Cmp(s2) <= 0; }
1890 inline bool operator<=(const wxChar  * s1, const wxString& s2)
1891     { return s2.Cmp(s1) >= 0; }
1892 inline bool operator>=(const wxString& s1, const wxString& s2)
1893     { return s1.Cmp(s2) >= 0; }
1894 inline bool operator>=(const wxString& s1, const wxChar  * s2)
1895     { return s1.Cmp(s2) >= 0; }
1896 inline bool operator>=(const wxChar  * s1, const wxString& s2)
1897     { return s2.Cmp(s1) <= 0; }
1898
1899 #if wxUSE_UNICODE
1900 inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
1901     { return (s1.Cmp((const wchar_t *)s2) == 0); }
1902 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
1903     { return (s2.Cmp((const wchar_t *)s1) == 0); }
1904 inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
1905     { return (s1.Cmp((const wchar_t *)s2) != 0); }
1906 inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
1907     { return (s2.Cmp((const wchar_t *)s1) != 0); }
1908 #else // !wxUSE_UNICODE
1909 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
1910     { return (s1.Cmp((const char *)s2) == 0); }
1911 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
1912     { return (s2.Cmp((const char *)s1) == 0); }
1913 inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
1914     { return (s1.Cmp((const char *)s2) != 0); }
1915 inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
1916     { return (s2.Cmp((const char *)s1) != 0); }
1917 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1918
1919 #if wxUSE_UNICODE
1920 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
1921     { return string + (const wchar_t *)buf; }
1922 inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
1923     { return (const wchar_t *)buf + string; }
1924 #else // !wxUSE_UNICODE
1925 inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
1926     { return string + (const char *)buf; }
1927 inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
1928     { return (const char *)buf + string; }
1929 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1930
1931 #endif // !wxUSE_STL_BASED_WXSTRING
1932
1933 // comparison with char (those are not defined by std::[w]string and so should
1934 // be always available)
1935 inline bool operator==(const wxUniChar& c, const wxString& s) { return s.IsSameAs(c); }
1936 inline bool operator==(const wxUniCharRef& c, const wxString& s) { return s.IsSameAs(c); }
1937 inline bool operator==(char c, const wxString& s) { return s.IsSameAs(c); }
1938 inline bool operator==(wchar_t c, const wxString& s) { return s.IsSameAs(c); }
1939 inline bool operator==(int c, const wxString& s) { return s.IsSameAs(c); }
1940 inline bool operator==(const wxString& s, const wxUniChar& c) { return s.IsSameAs(c); }
1941 inline bool operator==(const wxString& s, const wxUniCharRef& c) { return s.IsSameAs(c); }
1942 inline bool operator==(const wxString& s, char c) { return s.IsSameAs(c); }
1943 inline bool operator==(const wxString& s, wchar_t c) { return s.IsSameAs(c); }
1944 inline bool operator!=(const wxUniChar& c, const wxString& s) { return !s.IsSameAs(c); }
1945 inline bool operator!=(const wxUniCharRef& c, const wxString& s) { return !s.IsSameAs(c); }
1946 inline bool operator!=(char c, const wxString& s) { return !s.IsSameAs(c); }
1947 inline bool operator!=(wchar_t c, const wxString& s) { return !s.IsSameAs(c); }
1948 inline bool operator!=(int c, const wxString& s) { return !s.IsSameAs(c); }
1949 inline bool operator!=(const wxString& s, const wxUniChar& c) { return !s.IsSameAs(c); }
1950 inline bool operator!=(const wxString& s, const wxUniCharRef& c) { return !s.IsSameAs(c); }
1951 inline bool operator!=(const wxString& s, char c) { return !s.IsSameAs(c); }
1952 inline bool operator!=(const wxString& s, wchar_t c) { return !s.IsSameAs(c); }
1953
1954 // comparison with C string in Unicode build
1955 #if wxUSE_UNICODE
1956 inline bool operator==(const wxString& s1, const char* s2)
1957     { return s1 == wxString(s2); }
1958 inline bool operator==(const char* s1, const wxString& s2)
1959     { return wxString(s1) == s2; }
1960 inline bool operator!=(const wxString& s1, const char* s2)
1961     { return s1 != wxString(s2); }
1962 inline bool operator!=(const char* s1, const wxString& s2)
1963     { return wxString(s1) != s2; }
1964 inline bool operator< (const wxString& s1, const char* s2)
1965     { return s1 < wxString(s2); }
1966 inline bool operator< (const char* s1, const wxString& s2)
1967     { return wxString(s1) < s2; }
1968 inline bool operator> (const wxString& s1, const char* s2)
1969     { return s1 > wxString(s2); }
1970 inline bool operator> (const char* s1, const wxString& s2)
1971     { return wxString(s1) > s2; }
1972 inline bool operator<=(const wxString& s1, const char* s2)
1973     { return s1 <= wxString(s2); }
1974 inline bool operator<=(const char* s1, const wxString& s2)
1975     { return wxString(s1) <= s2; }
1976 inline bool operator>=(const wxString& s1, const char* s2)
1977     { return s1 >= wxString(s2); }
1978 inline bool operator>=(const char* s1, const wxString& s2)
1979     { return wxString(s1) >= s2; }
1980 #endif // wxUSE_UNICODE
1981
1982 // ---------------------------------------------------------------------------
1983 // Implementation only from here until the end of file
1984 // ---------------------------------------------------------------------------
1985
1986 // don't pollute the library user's name space
1987 #undef wxASSERT_VALID_INDEX
1988
1989 #if wxUSE_STD_IOSTREAM
1990
1991 #include "wx/iosfwrap.h"
1992
1993 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
1994 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&);
1995
1996 #endif  // wxSTD_STRING_COMPATIBILITY
1997
1998 // ---------------------------------------------------------------------------
1999 // wxCStrData implementation
2000 // ---------------------------------------------------------------------------
2001
2002 inline wxCStrData::wxCStrData(char *buf)
2003     : m_str(new wxString(buf)), m_offset(0), m_owned(true) {}
2004 inline wxCStrData::wxCStrData(wchar_t *buf)
2005     : m_str(new wxString(buf)), m_offset(0), m_owned(true) {}
2006
2007 inline wxCStrData::~wxCStrData()
2008 {
2009     if ( m_owned )
2010         delete m_str;
2011 }
2012
2013 #if wxUSE_UNICODE
2014 inline const wchar_t* wxCStrData::AsWChar() const
2015 #else
2016 inline const char* wxCStrData::AsChar() const
2017 #endif
2018 {
2019     if ( m_offset == 0 )
2020         return m_str->wx_str(); // FIXME
2021     else
2022         return (const wxChar*)(m_str->begin() + m_offset);
2023 }
2024
2025 inline wxString wxCStrData::AsString() const
2026 {
2027     if ( m_offset == 0 )
2028         return *m_str;
2029     else
2030         return m_str->Mid(m_offset);
2031 }
2032
2033 inline wxCStrData::operator wxString() const { return AsString(); }
2034
2035 inline wxUniChar wxCStrData::operator*() const
2036 {
2037     if ( m_str->empty() )
2038         return wxUniChar(_T('\0'));
2039     else
2040         return (*m_str)[m_offset];
2041 }
2042
2043 inline wxUniChar wxCStrData::operator[](size_t n) const
2044 {
2045     return m_str->at(m_offset + n);
2046 }
2047
2048 // ----------------------------------------------------------------------------
2049 // implementation of wxString inline methods using wxCStrData
2050 // ----------------------------------------------------------------------------
2051
2052 inline wxString& wxString::operator=(const wxCStrData& cstr)
2053 {
2054     return *this = cstr.AsString();
2055 }
2056
2057 // ----------------------------------------------------------------------------
2058 // implementation of wx[W]CharBuffer inline methods using wxCStrData
2059 // ----------------------------------------------------------------------------
2060
2061 #if wxUSE_UNICODE
2062
2063 inline wxWCharBuffer::wxWCharBuffer(const wxCStrData& cstr)
2064     : m_str(wxStrdupW(cstr))
2065 {
2066 }
2067
2068 #else // !wxUSE_UNICODE
2069
2070 inline wxCharBuffer::wxCharBuffer(const wxCStrData& cstr)
2071     : m_str(wxStrdupA(cstr))
2072 {
2073 }
2074
2075 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
2076
2077 #endif  // _WX_WXSTRINGH__