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