include/wx/string.h

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