include/wx/string.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        string.h
   3 // Purpose:     wxString and wxArrayString classes
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 /*
  13     Efficient string class [more or less] compatible with MFC CString,
  14     wxWindows version 1 wxString and std::string and some handy functions
  15     missing from string.h.
  16 */
  17
  18 #ifndef _WX_WXSTRINGH__
  19 #define _WX_WXSTRINGH__
  20
  21 #if defined(__GNUG__) && !defined(__APPLE__)
  22     #pragma interface "string.h"
  23 #endif
  24
  25 // ----------------------------------------------------------------------------
  26 // 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 extern WXDLLIMPEXP_DATA_BASE(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 // return an empty wxString
 169 class WXDLLIMPEXP_BASE wxString; // not yet defined
 170 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
 171
 172 // ---------------------------------------------------------------------------
 173 // string data prepended with some housekeeping info (used by wxString class),
 174 // is never used directly (but had to be put here to allow inlining)
 175 // ---------------------------------------------------------------------------
 176
 177 struct WXDLLIMPEXP_BASE wxStringData
 178 {
 179   int     nRefs;        // reference count
 180   size_t  nDataLength,  // actual string length
 181           nAllocLength; // allocated memory size
 182
 183   // mimics declaration 'wxChar data[nAllocLength]'
 184   wxChar* data() const { return (wxChar*)(this + 1); }
 185
 186   // empty string has a special ref count so it's never deleted
 187   bool  IsEmpty()   const { return (nRefs == -1); }
 188   bool  IsShared()  const { return (nRefs > 1);   }
 189
 190   // lock/unlock
 191   void  Lock()   { if ( !IsEmpty() ) nRefs++;                    }
 192
 193   // VC++ will refuse to inline Unlock but profiling shows that it is wrong
 194 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
 195   __forceinline
 196 #endif
 197   // VC++ free must take place in same DLL as allocation when using non dll
 198   // run-time library (e.g. Multithreaded instead of Multithreaded DLL)
 199 #if defined(__VISUALC__) && defined(_MT) && !defined(_DLL)
 200   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) Free();  }
 201   // we must not inline deallocation since allocation is not inlined
 202   void  Free();
 203 #else
 204   void  Unlock() { if ( !IsEmpty() && --nRefs == 0) free(this);  }
 205 #endif
 206
 207   // if we had taken control over string memory (GetWriteBuf), it's
 208   // intentionally put in invalid state
 209   void  Validate(bool b)  { nRefs = (b ? 1 : 0); }
 210   bool  IsValid() const   { return (nRefs != 0); }
 211 };
 212
 213 // ---------------------------------------------------------------------------
 214 // This is (yet another one) String class for C++ programmers. It doesn't use
 215 // any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)
 216 // thus you should be able to compile it with practicaly any C++ compiler.
 217 // This class uses copy-on-write technique, i.e. identical strings share the
 218 // same memory as long as neither of them is changed.
 219 //
 220 // This class aims to be as compatible as possible with the new standard
 221 // std::string class, but adds some additional functions and should be at
 222 // least as efficient than the standard implementation.
 223 //
 224 // Performance note: it's more efficient to write functions which take "const
 225 // String&" arguments than "const char *" if you assign the argument to
 226 // another string.
 227 //
 228 // It was compiled and tested under Win32, Linux (libc 5 & 6), Solaris 5.5.
 229 //
 230 // To do:
 231 //  - ressource support (string tables in ressources)
 232 //  - more wide character (UNICODE) support
 233 //  - regular expressions support
 234 // ---------------------------------------------------------------------------
 235
 236 class WXDLLIMPEXP_BASE wxString
 237 {
 238 #if !wxUSE_STL
 239 friend class WXDLLIMPEXP_BASE wxArrayString;
 240 #endif
 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(size_t 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, 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
 459     // explicit conversion to C string (use this with printf()!)
 460     const wxChar* c_str()   const { return m_pchData; }
 461     // identical to c_str(), for wxWin 1.6x compatibility
 462     const wxChar* wx_str()  const { return m_pchData; }
 463     // identical to c_str(), for MFC compatibility
 464     const wxChar* GetData() const { return m_pchData; }
 465
 466     // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
 467     // converting numbers or strings which are certain not to contain special
 468     // chars (typically system functions, X atoms, environment variables etc.)
 469     //
 470     // the behaviour of these functions with the strings containing anything
 471     // else than 7 bit ASCII characters is undefined, use at your own risk.
 472 #if wxUSE_UNICODE
 473     static wxString FromAscii(const char *ascii);  // string
 474     static wxString FromAscii(const char ascii);   // char
 475     const wxCharBuffer ToAscii() const;
 476 #else // ANSI
 477     static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
 478     static wxString FromAscii(const char ascii) { return wxString( ascii ); }
 479     const char *ToAscii() const { return c_str(); }
 480 #endif // Unicode/!Unicode
 481
 482     // conversions with (possible) format conversions: have to return a
 483     // buffer with temporary data
 484     //
 485     // the functions defined (in either Unicode or ANSI) mode are mb_str() to
 486     // return an ANSI (multibyte) string, wc_str() to return a wide string and
 487     // fn_str() to return a string which should be used with the OS APIs
 488     // accepting the file names. The return value is always the same, but the
 489     // type differs because a function may either return pointer to the buffer
 490     // directly or have to use intermediate buffer for translation.
 491 #if wxUSE_UNICODE
 492     const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
 493         { return conv.cWC2MB(m_pchData); }
 494
 495     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 496
 497     const wxChar* wc_str() const { return m_pchData; }
 498
 499     // for compatibility with !wxUSE_UNICODE version
 500     const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
 501
 502 #if wxMBFILES
 503     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
 504 #else // !wxMBFILES
 505     const wxChar* fn_str() const { return m_pchData; }
 506 #endif // wxMBFILES/!wxMBFILES
 507 #else // ANSI
 508     const wxChar* mb_str() const { return m_pchData; }
 509
 510     // for compatibility with wxUSE_UNICODE version
 511     const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
 512
 513     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 514
 515 #if wxUSE_WCHAR_T
 516     const wxWCharBuffer wc_str(wxMBConv& conv) const
 517         { return conv.cMB2WC(m_pchData); }
 518 #endif // wxUSE_WCHAR_T
 519
 520     const wxChar* fn_str() const { return m_pchData; }
 521 #endif // Unicode/ANSI
 522
 523   // overloaded assignment
 524     // from another wxString
 525   wxString& operator=(const wxString& stringSrc);
 526     // from a character
 527   wxString& operator=(wxChar ch);
 528     // from a C string
 529   wxString& operator=(const wxChar *psz);
 530 #if wxUSE_UNICODE
 531     // from wxWCharBuffer
 532   wxString& operator=(const wxWCharBuffer& psz)
 533   { (void) operator=((const wchar_t *)psz); return *this; }
 534 #else // ANSI
 535     // from another kind of C string
 536   wxString& operator=(const unsigned char* psz);
 537 #if wxUSE_WCHAR_T
 538     // from a wide string
 539   wxString& operator=(const wchar_t *pwz);
 540 #endif
 541     // from wxCharBuffer
 542   wxString& operator=(const wxCharBuffer& psz)
 543   { (void) operator=((const char *)psz); return *this; }
 544 #endif // Unicode/ANSI
 545
 546   // string concatenation
 547     // in place concatenation
 548     /*
 549         Concatenate and return the result. Note that the left to right
 550         associativity of << allows to write things like "str << str1 << str2
 551         << ..." (unlike with +=)
 552      */
 553       // string += string
 554   wxString& operator<<(const wxString& s)
 555   {
 556     wxASSERT_MSG( s.GetStringData()->IsValid(),
 557                   _T("did you forget to call UngetWriteBuf()?") );
 558
 559     ConcatSelf(s.Len(), s);
 560     return *this;
 561   }
 562       // string += C string
 563   wxString& operator<<(const wxChar *psz)
 564     { ConcatSelf(wxStrlen(psz), psz); return *this; }
 565       // string += char
 566   wxString& operator<<(wxChar ch) { ConcatSelf(1, &ch); return *this; }
 567
 568       // string += string
 569   void operator+=(const wxString& s) { (void)operator<<(s); }
 570       // string += C string
 571   void operator+=(const wxChar *psz) { (void)operator<<(psz); }
 572       // string += char
 573   void operator+=(wxChar ch) { (void)operator<<(ch); }
 574
 575       // string += buffer (i.e. from wxGetString)
 576 #if wxUSE_UNICODE
 577   wxString& operator<<(const wxWCharBuffer& s)
 578     { (void)operator<<((const wchar_t *)s); return *this; }
 579   void operator+=(const wxWCharBuffer& s)
 580     { (void)operator<<((const wchar_t *)s); }
 581 #else // !wxUSE_UNICODE
 582   wxString& operator<<(const wxCharBuffer& s)
 583     { (void)operator<<((const char *)s); return *this; }
 584   void operator+=(const wxCharBuffer& s)
 585     { (void)operator<<((const char *)s); }
 586 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 587
 588     // string += C string
 589   wxString& Append(const wxString& s)
 590     {
 591         // test for IsEmpty() to share the string if possible
 592         if ( IsEmpty() )
 593             *this = s;
 594         else
 595             ConcatSelf(s.Length(), s.c_str());
 596         return *this;
 597     }
 598   wxString& Append(const wxChar* psz)
 599     { ConcatSelf(wxStrlen(psz), psz); return *this; }
 600     // append count copies of given character
 601   wxString& Append(wxChar ch, size_t count = 1u)
 602     { wxString str(ch, count); return *this << str; }
 603   wxString& Append(const wxChar* psz, size_t nLen)
 604     { ConcatSelf(nLen, psz); return *this; }
 605
 606     // prepend a string, return the string itself
 607   wxString& Prepend(const wxString& str)
 608     { *this = str + *this; return *this; }
 609
 610     // non-destructive concatenation
 611       //
 612   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
 613       //
 614   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
 615       //
 616   friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
 617       //
 618   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
 619       //
 620   friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
 621
 622   // stream-like functions
 623       // insert an int into string
 624   wxString& operator<<(int i)
 625     { return (*this) << Format(_T("%d"), i); }
 626       // insert an unsigned int into string
 627   wxString& operator<<(unsigned int ui)
 628     { return (*this) << Format(_T("%u"), ui); }
 629       // insert a long into string
 630   wxString& operator<<(long l)
 631     { return (*this) << Format(_T("%ld"), l); }
 632       // insert an unsigned long into string
 633   wxString& operator<<(unsigned long ul)
 634     { return (*this) << Format(_T("%lu"), ul); }
 635       // insert a float into string
 636   wxString& operator<<(float f)
 637     { return (*this) << Format(_T("%f"), f); }
 638       // insert a double into string
 639   wxString& operator<<(double d)
 640     { return (*this) << Format(_T("%g"), d); }
 641
 642   // string comparison
 643     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
 644   int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
 645     // same as Cmp() but not case-sensitive
 646   int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }
 647     // test for the string equality, either considering case or not
 648     // (if compareWithCase then the case matters)
 649   bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
 650     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
 651     // comparison with a signle character: returns TRUE if equal
 652   bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
 653     {
 654       return (Len() == 1) && (compareWithCase ? GetChar(0u) == c
 655                               : wxToupper(GetChar(0u)) == wxToupper(c));
 656     }
 657
 658   // simple sub-string extraction
 659       // return substring starting at nFirst of length nCount (or till the end
 660       // if nCount = default value)
 661   wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
 662
 663       // operator version of Mid()
 664   wxString  operator()(size_t start, size_t len) const
 665     { return Mid(start, len); }
 666
 667       // check that the string starts with prefix and return the rest of the
 668       // string in the provided pointer if it is not NULL, otherwise return
 669       // FALSE
 670   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
 671
 672       // get first nCount characters
 673   wxString Left(size_t nCount) const;
 674       // get last nCount characters
 675   wxString Right(size_t nCount) const;
 676       // get all characters before the first occurance of ch
 677       // (returns the whole string if ch not found)
 678   wxString BeforeFirst(wxChar ch) const;
 679       // get all characters before the last occurence of ch
 680       // (returns empty string if ch not found)
 681   wxString BeforeLast(wxChar ch) const;
 682       // get all characters after the first occurence of ch
 683       // (returns empty string if ch not found)
 684   wxString AfterFirst(wxChar ch) const;
 685       // get all characters after the last occurence of ch
 686       // (returns the whole string if ch not found)
 687   wxString AfterLast(wxChar ch) const;
 688
 689     // for compatibility only, use more explicitly named functions above
 690   wxString Before(wxChar ch) const { return BeforeLast(ch); }
 691   wxString After(wxChar ch) const { return AfterFirst(ch); }
 692
 693   // case conversion
 694       // convert to upper case in place, return the string itself
 695   wxString& MakeUpper();
 696       // convert to upper case, return the copy of the string
 697       // Here's something to remember: BC++ doesn't like returns in inlines.
 698   wxString Upper() const ;
 699       // convert to lower case in place, return the string itself
 700   wxString& MakeLower();
 701       // convert to lower case, return the copy of the string
 702   wxString Lower() const ;
 703
 704   // trimming/padding whitespace (either side) and truncating
 705       // remove spaces from left or from right (default) side
 706   wxString& Trim(bool bFromRight = TRUE);
 707       // add nCount copies chPad in the beginning or at the end (default)
 708   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
 709
 710   // searching and replacing
 711       // searching (return starting index, or -1 if not found)
 712   int Find(wxChar ch, bool bFromEnd = FALSE) const;   // like strchr/strrchr
 713       // searching (return starting index, or -1 if not found)
 714   int Find(const wxChar *pszSub) const;               // like strstr
 715       // replace first (or all of bReplaceAll) occurences of substring with
 716       // another string, returns the number of replacements made
 717   size_t Replace(const wxChar *szOld,
 718                  const wxChar *szNew,
 719                  bool bReplaceAll = TRUE);
 720
 721     // check if the string contents matches a mask containing '*' and '?'
 722   bool Matches(const wxChar *szMask) const;
 723
 724     // conversion to numbers: all functions return TRUE only if the whole
 725     // string is a number and put the value of this number into the pointer
 726     // provided, the base is the numeric base in which the conversion should be
 727     // done and must be comprised between 2 and 36 or be 0 in which case the
 728     // standard C rules apply (leading '0' => octal, "0x" => hex)
 729         // convert to a signed integer
 730     bool ToLong(long *val, int base = 10) const;
 731         // convert to an unsigned integer
 732     bool ToULong(unsigned long *val, int base = 10) const;
 733         // convert to a double
 734     bool ToDouble(double *val) const;
 735
 736   // formated input/output
 737     // as sprintf(), returns the number of characters written or < 0 on error
 738     // (take 'this' into account in attribute parameter count)
 739   int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
 740     // as vprintf(), returns the number of characters written or < 0 on error
 741   int PrintfV(const wxChar* pszFormat, va_list argptr);
 742
 743     // returns the string containing the result of Printf() to it
 744   static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;
 745     // the same as above, but takes a va_list
 746   static wxString FormatV(const wxChar *pszFormat, va_list argptr);
 747
 748   // raw access to string memory
 749     // ensure that string has space for at least nLen characters
 750     // only works if the data of this string is not shared
 751   bool Alloc(size_t nLen);
 752     // minimize the string's memory
 753     // only works if the data of this string is not shared
 754   bool Shrink();
 755     // get writable buffer of at least nLen bytes. Unget() *must* be called
 756     // a.s.a.p. to put string back in a reasonable state!
 757   wxChar *GetWriteBuf(size_t nLen);
 758     // call this immediately after GetWriteBuf() has been used
 759   void UngetWriteBuf();
 760   void UngetWriteBuf(size_t nLen);
 761
 762   // wxWindows version 1 compatibility functions
 763
 764   // use Mid()
 765   wxString SubString(size_t from, size_t to) const
 766       { return Mid(from, (to - from + 1)); }
 767     // values for second parameter of CompareTo function
 768   enum caseCompare {exact, ignoreCase};
 769     // values for first parameter of Strip function
 770   enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
 771
 772   // use Printf()
 773   // (take 'this' into account in attribute parameter count)
 774   int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
 775
 776     // use Cmp()
 777   inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
 778     { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
 779
 780     // use Len
 781   size_t Length() const { return Len(); }
 782     // Count the number of characters
 783   int Freq(wxChar ch) const;
 784     // use MakeLower
 785   void LowerCase() { MakeLower(); }
 786     // use MakeUpper
 787   void UpperCase() { MakeUpper(); }
 788     // use Trim except that it doesn't change this string
 789   wxString Strip(stripType w = trailing) const;
 790
 791     // use Find (more general variants not yet supported)
 792   size_t Index(const wxChar* psz) const { return Find(psz); }
 793   size_t Index(wxChar ch)         const { return Find(ch);  }
 794     // use Truncate
 795   wxString& Remove(size_t pos) { return Truncate(pos); }
 796   wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); }
 797
 798   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
 799
 800     // use Find()
 801   int First( const wxChar ch ) const { return Find(ch); }
 802   int First( const wxChar* psz ) const { return Find(psz); }
 803   int First( const wxString &str ) const { return Find(str); }
 804   int Last( const wxChar ch ) const { return Find(ch, TRUE); }
 805   bool Contains(const wxString& str) const { return Find(str) != -1; }
 806
 807     // use IsEmpty()
 808   bool IsNull() const { return IsEmpty(); }
 809
 810 #ifdef  wxSTD_STRING_COMPATIBILITY
 811   // std::string compatibility functions
 812
 813   // standard types
 814   typedef wxChar value_type;
 815   typedef size_t size_type;
 816   typedef value_type *iterator;
 817   typedef const value_type *const_iterator;
 818
 819   // an 'invalid' value for string index
 820   static const size_t npos;
 821
 822   // constructors
 823     // take nLen chars starting at nPos
 824   wxString(const wxString& str, size_t nPos, size_t nLen)
 825       : m_pchData(NULL)
 826   {
 827     wxASSERT_MSG( str.GetStringData()->IsValid(),
 828                   _T("did you forget to call UngetWriteBuf()?") );
 829
 830     InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
 831   }
 832     // take all characters from pStart to pEnd
 833   wxString(const void *pStart, const void *pEnd);
 834
 835   // lib.string.capacity
 836     // return the length of the string
 837   size_t size() const { return Len(); }
 838     // return the length of the string
 839   size_t length() const { return Len(); }
 840     // return the maximum size of the string
 841   size_t max_size() const { return wxSTRING_MAXLEN; }
 842     // resize the string, filling the space with c if c != 0
 843   void resize(size_t nSize, wxChar ch = wxT('\0'));
 844     // delete the contents of the string
 845   void clear() { Empty(); }
 846     // returns true if the string is empty
 847   bool empty() const { return IsEmpty(); }
 848     // inform string about planned change in size
 849   void reserve(size_t sz) { Alloc(sz); }
 850
 851   // lib.string.access
 852     // return the character at position n
 853   wxChar at(size_t n) const { return GetChar(n); }
 854     // returns the writable character at position n
 855   wxChar& at(size_t n) { return GetWritableChar(n); }
 856
 857     // first valid index position
 858   const_iterator begin() const { return wx_str(); }
 859     // position one after the last valid one
 860   const_iterator end() const { return wx_str() + length(); }
 861
 862   // first valid index position
 863   iterator begin() { CopyBeforeWrite(); return m_pchData; }
 864   // position one after the last valid one
 865   iterator end() { CopyBeforeWrite(); return m_pchData + length(); }
 866
 867   // lib.string.modifiers
 868     // append a string
 869   wxString& append(const wxString& str)
 870     { *this += str; return *this; }
 871     // append elements str[pos], ..., str[pos+n]
 872   wxString& append(const wxString& str, size_t pos, size_t n)
 873     { ConcatSelf(n, str.c_str() + pos); return *this; }
 874     // append first n (or all if n == npos) characters of sz
 875   wxString& append(const wxChar *sz, size_t n = npos)
 876     { ConcatSelf(n == npos ? wxStrlen(sz) : n, sz); return *this; }
 877
 878     // append n copies of ch
 879   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
 880
 881     // same as `this_string = str'
 882   wxString& assign(const wxString& str)
 883     { return *this = str; }
 884     // same as ` = str[pos..pos + n]
 885   wxString& assign(const wxString& str, size_t pos, size_t n)
 886     { Empty(); return Append(str.c_str() + pos, n); }
 887     // same as `= first n (or all if n == npos) characters of sz'
 888   wxString& assign(const wxChar *sz, size_t n = npos)
 889     { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }
 890     // same as `= n copies of ch'
 891   wxString& assign(size_t n, wxChar ch)
 892     { Empty(); return Append(ch, n); }
 893
 894     // insert another string
 895   wxString& insert(size_t nPos, const wxString& str);
 896     // insert n chars of str starting at nStart (in str)
 897   wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
 898     { return insert(nPos, wxString((const wxChar *)str + nStart, n)); }
 899
 900     // insert first n (or all if n == npos) characters of sz
 901   wxString& insert(size_t nPos, const wxChar *sz, size_t n = npos)
 902     { return insert(nPos, wxString(sz, n)); }
 903     // insert n copies of ch
 904   wxString& insert(size_t nPos, size_t n, wxChar ch)
 905     { return insert(nPos, wxString(ch, n)); }
 906
 907     // delete characters from nStart to nStart + nLen
 908   wxString& erase(size_t nStart = 0, size_t nLen = npos);
 909
 910     // replaces the substring of length nLen starting at nStart
 911   wxString& replace(size_t nStart, size_t nLen, const wxChar* sz);
 912     // replaces the substring with nCount copies of ch
 913   wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch);
 914     // replaces a substring with another substring
 915   wxString& replace(size_t nStart, size_t nLen,
 916                     const wxString& str, size_t nStart2, size_t nLen2);
 917     // replaces the substring with first nCount chars of sz
 918   wxString& replace(size_t nStart, size_t nLen,
 919                     const wxChar* sz, size_t nCount);
 920
 921     // swap two strings
 922   void swap(wxString& str);
 923
 924     // All find() functions take the nStart argument which specifies the
 925     // position to start the search on, the default value is 0. All functions
 926     // return npos if there were no match.
 927
 928     // find a substring
 929   size_t find(const wxString& str, size_t nStart = 0) const;
 930
 931   // VC++ 1.5 can't cope with this syntax.
 932 #if !defined(__VISUALC__) || defined(__WIN32__)
 933     // find first n characters of sz
 934   size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
 935 #endif // VC++ 1.5
 936
 937   // Gives a duplicate symbol (presumably a case-insensitivity problem)
 938 #if !defined(__BORLANDC__)
 939     // find the first occurence of character ch after nStart
 940   size_t find(wxChar ch, size_t nStart = 0) const;
 941 #endif
 942     // rfind() family is exactly like find() but works right to left
 943
 944     // as find, but from the end
 945   size_t rfind(const wxString& str, size_t nStart = npos) const;
 946
 947   // VC++ 1.5 can't cope with this syntax.
 948 #if !defined(__VISUALC__) || defined(__WIN32__)
 949     // as find, but from the end
 950   size_t rfind(const wxChar* sz, size_t nStart = npos,
 951           size_t n = npos) const;
 952     // as find, but from the end
 953   size_t rfind(wxChar ch, size_t nStart = npos) const;
 954 #endif // VC++ 1.5
 955
 956     // find first/last occurence of any character in the set
 957
 958     // as strpbrk() but starts at nStart, returns npos if not found
 959   size_t find_first_of(const wxString& str, size_t nStart = 0) const
 960     { return find_first_of(str.c_str(), nStart); }
 961     // same as above
 962   size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;
 963     // same as find(char, size_t)
 964   size_t find_first_of(wxChar c, size_t nStart = 0) const
 965     { return find(c, nStart); }
 966     // find the last (starting from nStart) char from str in this string
 967   size_t find_last_of (const wxString& str, size_t nStart = npos) const
 968     { return find_last_of(str.c_str(), nStart); }
 969     // same as above
 970   size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;
 971     // same as above
 972   size_t find_last_of(wxChar c, size_t nStart = npos) const
 973     { return rfind(c, nStart); }
 974
 975     // find first/last occurence of any character not in the set
 976
 977     // as strspn() (starting from nStart), returns npos on failure
 978   size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
 979     { return find_first_not_of(str.c_str(), nStart); }
 980     // same as above
 981   size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;
 982     // same as above
 983   size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
 984     //  as strcspn()
 985   size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
 986     { return find_first_not_of(str.c_str(), nStart); }
 987     // same as above
 988   size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
 989     // same as above
 990   size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;
 991
 992     // All compare functions return -1, 0 or 1 if the [sub]string is less,
 993     // equal or greater than the compare() argument.
 994
 995     // just like strcmp()
 996   int compare(const wxString& str) const { return Cmp(str); }
 997     // comparison with a substring
 998   int compare(size_t nStart, size_t nLen, const wxString& str) const
 999     { return Mid(nStart, nLen).Cmp(str); }
1000     // comparison of 2 substrings
1001   int compare(size_t nStart, size_t nLen,
1002               const wxString& str, size_t nStart2, size_t nLen2) const
1003     { return Mid(nStart, nLen).Cmp(str.Mid(nStart2, nLen2)); }
1004     // just like strcmp()
1005   int compare(const wxChar* sz) const { return Cmp(sz); }
1006     // substring comparison with first nCount characters of sz
1007   int compare(size_t nStart, size_t nLen,
1008               const wxChar* sz, size_t nCount = npos) const
1009     { return Mid(nStart, nLen).Cmp(wxString(sz, nCount)); }
1010
1011   // substring extraction
1012   wxString substr(size_t nStart = 0, size_t nLen = npos) const
1013     { return Mid(nStart, nLen); }
1014 #endif // wxSTD_STRING_COMPATIBILITY
1015 };
1016
1017 // define wxArrayString, for compatibility
1018 #if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL
1019     #include "wx/arrstr.h"
1020 #endif
1021
1022 // ----------------------------------------------------------------------------
1023 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
1024 // ----------------------------------------------------------------------------
1025
1026 class WXDLLIMPEXP_BASE wxStringBuffer
1027 {
1028 public:
1029     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
1030         : m_str(str), m_buf(NULL)
1031         { m_buf = m_str.GetWriteBuf(lenWanted); }
1032
1033     ~wxStringBuffer() { m_str.UngetWriteBuf(); }
1034
1035     operator wxChar*() const { return m_buf; }
1036
1037 private:
1038     wxString& m_str;
1039     wxChar   *m_buf;
1040
1041     DECLARE_NO_COPY_CLASS(wxStringBuffer)
1042 };
1043
1044 // ---------------------------------------------------------------------------
1045 // wxString comparison functions: operator versions are always case sensitive
1046 // ---------------------------------------------------------------------------
1047
1048 inline bool operator==(const wxString& s1, const wxString& s2)
1049     { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
1050 inline bool operator==(const wxString& s1, const wxChar  * s2)
1051     { return s1.Cmp(s2) == 0; }
1052 inline bool operator==(const wxChar  * s1, const wxString& s2)
1053     { return s2.Cmp(s1) == 0; }
1054 inline bool operator!=(const wxString& s1, const wxString& s2)
1055     { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
1056 inline bool operator!=(const wxString& s1, const wxChar  * s2)
1057     { return s1.Cmp(s2) != 0; }
1058 inline bool operator!=(const wxChar  * s1, const wxString& s2)
1059     { return s2.Cmp(s1) != 0; }
1060 inline bool operator< (const wxString& s1, const wxString& s2)
1061     { return s1.Cmp(s2) < 0; }
1062 inline bool operator< (const wxString& s1, const wxChar  * s2)
1063     { return s1.Cmp(s2) <  0; }
1064 inline bool operator< (const wxChar  * s1, const wxString& s2)
1065     { return s2.Cmp(s1) >  0; }
1066 inline bool operator> (const wxString& s1, const wxString& s2)
1067     { return s1.Cmp(s2) >  0; }
1068 inline bool operator> (const wxString& s1, const wxChar  * s2)
1069     { return s1.Cmp(s2) >  0; }
1070 inline bool operator> (const wxChar  * s1, const wxString& s2)
1071     { return s2.Cmp(s1) <  0; }
1072 inline bool operator<=(const wxString& s1, const wxString& s2)
1073     { return s1.Cmp(s2) <= 0; }
1074 inline bool operator<=(const wxString& s1, const wxChar  * s2)
1075     { return s1.Cmp(s2) <= 0; }
1076 inline bool operator<=(const wxChar  * s1, const wxString& s2)
1077     { return s2.Cmp(s1) >= 0; }
1078 inline bool operator>=(const wxString& s1, const wxString& s2)
1079     { return s1.Cmp(s2) >= 0; }
1080 inline bool operator>=(const wxString& s1, const wxChar  * s2)
1081     { return s1.Cmp(s2) >= 0; }
1082 inline bool operator>=(const wxChar  * s1, const wxString& s2)
1083     { return s2.Cmp(s1) <= 0; }
1084
1085 // comparison with char
1086 inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
1087 inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
1088 inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
1089 inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
1090
1091 #if wxUSE_UNICODE
1092 inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
1093     { return (s1.Cmp((const wchar_t *)s2) == 0); }
1094 inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
1095     { return (s2.Cmp((const wchar_t *)s1) == 0); }
1096 inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
1097     { return (s1.Cmp((const wchar_t *)s2) != 0); }
1098 inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
1099     { return (s2.Cmp((const wchar_t *)s1) != 0); }
1100 #else // !wxUSE_UNICODE
1101 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
1102     { return (s1.Cmp((const char *)s2) == 0); }
1103 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
1104     { return (s2.Cmp((const char *)s1) == 0); }
1105 inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
1106     { return (s1.Cmp((const char *)s2) != 0); }
1107 inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
1108     { return (s2.Cmp((const char *)s1) != 0); }
1109 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1110
1111 wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
1112 wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
1113 wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
1114 wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
1115 wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
1116 #if wxUSE_UNICODE
1117 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
1118     { return string + (const wchar_t *)buf; }
1119 inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
1120     { return (const wchar_t *)buf + string; }
1121 #else // !wxUSE_UNICODE
1122 inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
1123     { return string + (const char *)buf; }
1124 inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
1125     { return (const char *)buf + string; }
1126 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1127
1128 // ---------------------------------------------------------------------------
1129 // Implementation only from here until the end of file
1130 // ---------------------------------------------------------------------------
1131
1132 // don't pollute the library user's name space
1133 #undef wxASSERT_VALID_INDEX
1134
1135 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
1136
1137 #include "wx/iosfwrap.h"
1138
1139 WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);
1140 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
1141
1142 #endif  // wxSTD_STRING_COMPATIBILITY
1143
1144 #endif  // _WX_WXSTRINGH__