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