home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / include / wx / string.h < prev    next >
C/C++ Source or Header  |  2002-08-31  |  51KB  |  1,270 lines
  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: string.h,v 1.146 2002/08/31 11:29:11 GD Exp $
  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. #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(int 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 = wxConvLibc, 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);
  465.     const wxCharBuffer ToAscii() const;
  466. #else // ANSI
  467.     static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
  468.     const char *ToAscii() const { return c_str(); }
  469. #endif // Unicode/!Unicode
  470.  
  471.     // conversions with (possible) format convertions: have to return a
  472.     // buffer with temporary data
  473.     //
  474.     // the functions defined (in either Unicode or ANSI) mode are mb_str() to
  475.     // return an ANSI (multibyte) string, wc_str() to return a wide string and
  476.     // fn_str() to return a string which should be used with the OS APIs
  477.     // accepting the file names. The return value is always the same, but the
  478.     // type differs because a function may either return pointer to the buffer
  479.     // directly or have to use intermediate buffer for translation.
  480. #if wxUSE_UNICODE
  481.     const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
  482.         { return conv.cWC2MB(m_pchData); }
  483.  
  484.     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
  485.  
  486.     const wxChar* wc_str() const { return m_pchData; }
  487.  
  488.     // for compatibility with !wxUSE_UNICODE version
  489.     const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
  490.  
  491. #if wxMBFILES
  492.     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
  493. #else // !wxMBFILES
  494.     const wxChar* fn_str() const { return m_pchData; }
  495. #endif // wxMBFILES/!wxMBFILES
  496. #else // ANSI
  497.     const wxChar* mb_str() const { return m_pchData; }
  498.  
  499.     // for compatibility with wxUSE_UNICODE version
  500.     const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return m_pchData; }
  501.  
  502.     const wxWX2MBbuf mbc_str() const { return mb_str(); }
  503.  
  504. #if wxUSE_WCHAR_T
  505.     const wxWCharBuffer wc_str(wxMBConv& conv) const
  506.         { return conv.cMB2WC(m_pchData); }
  507. #endif // wxUSE_WCHAR_T
  508.  
  509.     const wxChar* fn_str() const { return m_pchData; }
  510. #endif // Unicode/ANSI
  511.  
  512.   // overloaded assignment
  513.     // from another wxString
  514.   wxString& operator=(const wxString& stringSrc);
  515.     // from a character
  516.   wxString& operator=(wxChar ch);
  517.     // from a C string
  518.   wxString& operator=(const wxChar *psz);
  519. #if wxUSE_UNICODE
  520.     // from wxWCharBuffer
  521.   wxString& operator=(const wxWCharBuffer& psz)
  522.   { (void) operator=((const wchar_t *)psz); return *this; }
  523. #else // ANSI
  524.     // from another kind of C string
  525.   wxString& operator=(const unsigned char* psz);
  526. #if wxUSE_WCHAR_T
  527.     // from a wide string
  528.   wxString& operator=(const wchar_t *pwz);
  529. #endif
  530.     // from wxCharBuffer
  531.   wxString& operator=(const wxCharBuffer& psz)
  532.   { (void) operator=((const char *)psz); return *this; }
  533. #endif // Unicode/ANSI
  534.  
  535.   // string concatenation
  536.     // in place concatenation
  537.     /*
  538.         Concatenate and return the result. Note that the left to right
  539.         associativity of << allows to write things like "str << str1 << str2
  540.         << ..." (unlike with +=)
  541.      */
  542.       // string += string
  543.   wxString& operator<<(const wxString& s)
  544.   {
  545.     wxASSERT_MSG( s.GetStringData()->IsValid(),
  546.                   _T("did you forget to call UngetWriteBuf()?") );
  547.  
  548.     ConcatSelf(s.Len(), s);
  549.     return *this;
  550.   }
  551.       // string += C string
  552.   wxString& operator<<(const wxChar *psz)
  553.     { ConcatSelf(wxStrlen(psz), psz); return *this; }
  554.       // string += char
  555.   wxString& operator<<(wxChar ch) { ConcatSelf(1, &ch); return *this; }
  556.  
  557.       // string += string
  558.   void operator+=(const wxString& s) { (void)operator<<(s); }
  559.       // string += C string
  560.   void operator+=(const wxChar *psz) { (void)operator<<(psz); }
  561.       // string += char
  562.   void operator+=(wxChar ch) { (void)operator<<(ch); }
  563.  
  564.       // string += buffer (i.e. from wxGetString)
  565. #if wxUSE_UNICODE
  566.   wxString& operator<<(const wxWCharBuffer& s)
  567.     { (void)operator<<((const wchar_t *)s); return *this; }
  568.   void operator+=(const wxWCharBuffer& s)
  569.     { (void)operator<<((const wchar_t *)s); }
  570. #else // !wxUSE_UNICODE
  571.   wxString& operator<<(const wxCharBuffer& s)
  572.     { (void)operator<<((const char *)s); return *this; }
  573.   void operator+=(const wxCharBuffer& s)
  574.     { (void)operator<<((const char *)s); }
  575. #endif // wxUSE_UNICODE/!wxUSE_UNICODE
  576.  
  577.     // string += C string
  578.   wxString& Append(const wxString& s)
  579.     {
  580.         // test for IsEmpty() to share the string if possible
  581.         if ( IsEmpty() )
  582.             *this = s;
  583.         else
  584.             ConcatSelf(s.Length(), s.c_str());
  585.         return *this;
  586.     }
  587.   wxString& Append(const wxChar* psz)
  588.     { ConcatSelf(wxStrlen(psz), psz); return *this; }
  589.     // append count copies of given character
  590.   wxString& Append(wxChar ch, size_t count = 1u)
  591.     { wxString str(ch, count); return *this << str; }
  592.   wxString& Append(const wxChar* psz, size_t nLen)
  593.     { ConcatSelf(nLen, psz); return *this; }
  594.  
  595.     // prepend a string, return the string itself
  596.   wxString& Prepend(const wxString& str)
  597.     { *this = str + *this; return *this; }
  598.  
  599.     // non-destructive concatenation
  600.       //
  601.   friend wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
  602.       //
  603.   friend wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
  604.       //
  605.   friend wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
  606.       //
  607.   friend wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
  608.       //
  609.   friend wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
  610.  
  611.   // stream-like functions
  612.       // insert an int into string
  613.   wxString& operator<<(int i)
  614.     { return (*this) << Format(_T("%d"), i); }
  615.       // insert an unsigned int into string
  616.   wxString& operator<<(unsigned int ui)
  617.     { return (*this) << Format(_T("%u"), ui); }
  618.       // insert a long into string
  619.   wxString& operator<<(long l)
  620.     { return (*this) << Format(_T("%ld"), l); }
  621.       // insert an unsigned long into string
  622.   wxString& operator<<(unsigned long ul)
  623.     { return (*this) << Format(_T("%lu"), ul); }
  624.       // insert a float into string
  625.   wxString& operator<<(float f)
  626.     { return (*this) << Format(_T("%f"), f); }
  627.       // insert a double into string
  628.   wxString& operator<<(double d)
  629.     { return (*this) << Format(_T("%g"), d); }
  630.  
  631.   // string comparison
  632.     // case-sensitive comparison (returns a value < 0, = 0 or > 0)
  633.   int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
  634.     // same as Cmp() but not case-sensitive
  635.   int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }
  636.     // test for the string equality, either considering case or not
  637.     // (if compareWithCase then the case matters)
  638.   bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
  639.     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
  640.     // comparison with a signle character: returns TRUE if equal
  641.   bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
  642.     {
  643.       return (Len() == 1) && (compareWithCase ? GetChar(0u) == c
  644.                               : wxToupper(GetChar(0u)) == wxToupper(c));
  645.     }
  646.  
  647.   // simple sub-string extraction
  648.       // return substring starting at nFirst of length nCount (or till the end
  649.       // if nCount = default value)
  650.   wxString Mid(size_t nFirst, size_t nCount = wxSTRING_MAXLEN) const;
  651.  
  652.       // operator version of Mid()
  653.   wxString  operator()(size_t start, size_t len) const
  654.     { return Mid(start, len); }
  655.  
  656.       // check that the string starts with prefix and return the rest of the
  657.       // string in the provided pointer if it is not NULL, otherwise return
  658.       // FALSE
  659.   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
  660.  
  661.       // get first nCount characters
  662.   wxString Left(size_t nCount) const;
  663.       // get last nCount characters
  664.   wxString Right(size_t nCount) const;
  665.       // get all characters before the first occurance of ch
  666.       // (returns the whole string if ch not found)
  667.   wxString BeforeFirst(wxChar ch) const;
  668.       // get all characters before the last occurence of ch
  669.       // (returns empty string if ch not found)
  670.   wxString BeforeLast(wxChar ch) const;
  671.       // get all characters after the first occurence of ch
  672.       // (returns empty string if ch not found)
  673.   wxString AfterFirst(wxChar ch) const;
  674.       // get all characters after the last occurence of ch
  675.       // (returns the whole string if ch not found)
  676.   wxString AfterLast(wxChar ch) const;
  677.  
  678.     // for compatibility only, use more explicitly named functions above
  679.   wxString Before(wxChar ch) const { return BeforeLast(ch); }
  680.   wxString After(wxChar ch) const { return AfterFirst(ch); }
  681.  
  682.   // case conversion
  683.       // convert to upper case in place, return the string itself
  684.   wxString& MakeUpper();
  685.       // convert to upper case, return the copy of the string
  686.       // Here's something to remember: BC++ doesn't like returns in inlines.
  687.   wxString Upper() const ;
  688.       // convert to lower case in place, return the string itself
  689.   wxString& MakeLower();
  690.       // convert to lower case, return the copy of the string
  691.   wxString Lower() const ;
  692.  
  693.   // trimming/padding whitespace (either side) and truncating
  694.       // remove spaces from left or from right (default) side
  695.   wxString& Trim(bool bFromRight = TRUE);
  696.       // add nCount copies chPad in the beginning or at the end (default)
  697.   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
  698.  
  699.   // searching and replacing
  700.       // searching (return starting index, or -1 if not found)
  701.   int Find(wxChar ch, bool bFromEnd = FALSE) const;   // like strchr/strrchr
  702.       // searching (return starting index, or -1 if not found)
  703.   int Find(const wxChar *pszSub) const;               // like strstr
  704.       // replace first (or all of bReplaceAll) occurences of substring with
  705.       // another string, returns the number of replacements made
  706.   size_t Replace(const wxChar *szOld,
  707.                  const wxChar *szNew,
  708.                  bool bReplaceAll = TRUE);
  709.  
  710.     // check if the string contents matches a mask containing '*' and '?'
  711.   bool Matches(const wxChar *szMask) const;
  712.  
  713.     // conversion to numbers: all functions return TRUE only if the whole
  714.     // string is a number and put the value of this number into the pointer
  715.     // provided, the base is the numeric base in which the conversion should be
  716.     // done and must be comprised between 2 and 36 or be 0 in which case the
  717.     // standard C rules apply (leading '0' => octal, "0x" => hex)
  718.         // convert to a signed integer
  719.     bool ToLong(long *val, int base = 10) const;
  720.         // convert to an unsigned integer
  721.     bool ToULong(unsigned long *val, int base = 10) const;
  722.         // convert to a double
  723.     bool ToDouble(double *val) const;
  724.  
  725.   // formated input/output
  726.     // as sprintf(), returns the number of characters written or < 0 on error
  727.     // (take 'this' into account in attribute parameter count)
  728.   int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
  729.     // as vprintf(), returns the number of characters written or < 0 on error
  730.   int PrintfV(const wxChar* pszFormat, va_list argptr);
  731.  
  732.     // returns the string containing the result of Printf() to it
  733.   static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;
  734.     // the same as above, but takes a va_list
  735.   static wxString FormatV(const wxChar *pszFormat, va_list argptr);
  736.  
  737.   // raw access to string memory
  738.     // ensure that string has space for at least nLen characters
  739.     // only works if the data of this string is not shared
  740.   bool Alloc(size_t nLen);
  741.     // minimize the string's memory
  742.     // only works if the data of this string is not shared
  743.   bool Shrink();
  744.     // get writable buffer of at least nLen bytes. Unget() *must* be called
  745.     // a.s.a.p. to put string back in a reasonable state!
  746.   wxChar *GetWriteBuf(size_t nLen);
  747.     // call this immediately after GetWriteBuf() has been used
  748.   void UngetWriteBuf();
  749.   void UngetWriteBuf(size_t nLen);
  750.  
  751.   // wxWindows version 1 compatibility functions
  752.  
  753.   // use Mid()
  754.   wxString SubString(size_t from, size_t to) const
  755.       { return Mid(from, (to - from + 1)); }
  756.     // values for second parameter of CompareTo function
  757.   enum caseCompare {exact, ignoreCase};
  758.     // values for first parameter of Strip function
  759.   enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
  760.  
  761.   // use Printf()
  762.   // (take 'this' into account in attribute parameter count)
  763.   int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
  764.  
  765.     // use Cmp()
  766.   inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
  767.     { return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
  768.  
  769.     // use Len
  770.   size_t Length() const { return Len(); }
  771.     // Count the number of characters
  772.   int Freq(wxChar ch) const;
  773.     // use MakeLower
  774.   void LowerCase() { MakeLower(); }
  775.     // use MakeUpper
  776.   void UpperCase() { MakeUpper(); }
  777.     // use Trim except that it doesn't change this string
  778.   wxString Strip(stripType w = trailing) const;
  779.  
  780.     // use Find (more general variants not yet supported)
  781.   size_t Index(const wxChar* psz) const { return Find(psz); }
  782.   size_t Index(wxChar ch)         const { return Find(ch);  }
  783.     // use Truncate
  784.   wxString& Remove(size_t pos) { return Truncate(pos); }
  785.   wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); }
  786.  
  787.   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
  788.  
  789.     // use Find()
  790.   int First( const wxChar ch ) const { return Find(ch); }
  791.   int First( const wxChar* psz ) const { return Find(psz); }
  792.   int First( const wxString &str ) const { return Find(str); }
  793.   int Last( const wxChar ch ) const { return Find(ch, TRUE); }
  794.   bool Contains(const wxString& str) const { return Find(str) != -1; }
  795.  
  796.     // use IsEmpty()
  797.   bool IsNull() const { return IsEmpty(); }
  798.  
  799. #ifdef  wxSTD_STRING_COMPATIBILITY
  800.   // std::string compatibility functions
  801.  
  802.   // standard types
  803.   typedef wxChar value_type;
  804.   typedef const value_type *const_iterator;
  805.  
  806.   // an 'invalid' value for string index
  807.   static const size_t npos;
  808.  
  809.   // constructors
  810.     // take nLen chars starting at nPos
  811.   wxString(const wxString& str, size_t nPos, size_t nLen)
  812.       : m_pchData(NULL)
  813.   {
  814.     wxASSERT_MSG( str.GetStringData()->IsValid(),
  815.                   _T("did you forget to call UngetWriteBuf()?") );
  816.  
  817.     InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
  818.   }
  819.     // take all characters from pStart to pEnd
  820.   wxString(const void *pStart, const void *pEnd);
  821.  
  822.   // lib.string.capacity
  823.     // return the length of the string
  824.   size_t size() const { return Len(); }
  825.     // return the length of the string
  826.   size_t length() const { return Len(); }
  827.     // return the maximum size of the string
  828.   size_t max_size() const { return wxSTRING_MAXLEN; }
  829.     // resize the string, filling the space with c if c != 0
  830.   void resize(size_t nSize, wxChar ch = wxT('\0'));
  831.     // delete the contents of the string
  832.   void clear() { Empty(); }
  833.     // returns true if the string is empty
  834.   bool empty() const { return IsEmpty(); }
  835.     // inform string about planned change in size
  836.   void reserve(size_t size) { Alloc(size); }
  837.  
  838.   // lib.string.access
  839.     // return the character at position n
  840.   wxChar at(size_t n) const { return GetChar(n); }
  841.     // returns the writable character at position n
  842.   wxChar& at(size_t n) { return GetWritableChar(n); }
  843.  
  844.     // first valid index position
  845.   const_iterator begin() const { return wx_str(); }
  846.     // position one after the last valid one
  847.   const_iterator end() const { return wx_str() + length(); }
  848.  
  849.   // lib.string.modifiers
  850.     // append a string
  851.   wxString& append(const wxString& str)
  852.     { *this += str; return *this; }
  853.     // append elements str[pos], ..., str[pos+n]
  854.   wxString& append(const wxString& str, size_t pos, size_t n)
  855.     { ConcatSelf(n, str.c_str() + pos); return *this; }
  856.     // append first n (or all if n == npos) characters of sz
  857.   wxString& append(const wxChar *sz, size_t n = npos)
  858.     { ConcatSelf(n == npos ? wxStrlen(sz) : n, sz); return *this; }
  859.  
  860.     // append n copies of ch
  861.   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
  862.  
  863.     // same as `this_string = str'
  864.   wxString& assign(const wxString& str)
  865.     { return *this = str; }
  866.     // same as ` = str[pos..pos + n]
  867.   wxString& assign(const wxString& str, size_t pos, size_t n)
  868.     { Empty(); return Append(str.c_str() + pos, n); }
  869.     // same as `= first n (or all if n == npos) characters of sz'
  870.   wxString& assign(const wxChar *sz, size_t n = npos)
  871.     { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }
  872.     // same as `= n copies of ch'
  873.   wxString& assign(size_t n, wxChar ch)
  874.     { Empty(); return Append(ch, n); }
  875.  
  876.     // insert another string
  877.   wxString& insert(size_t nPos, const wxString& str);
  878.     // insert n chars of str starting at nStart (in str)
  879.   wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
  880.     { return insert(nPos, wxString((const wxChar *)str + nStart, n)); }
  881.  
  882.     // insert first n (or all if n == npos) characters of sz
  883.   wxString& insert(size_t nPos, const wxChar *sz, size_t n = npos)
  884.     { return insert(nPos, wxString(sz, n)); }
  885.     // insert n copies of ch
  886.   wxString& insert(size_t nPos, size_t n, wxChar ch)
  887.     { return insert(nPos, wxString(ch, n)); }
  888.  
  889.     // delete characters from nStart to nStart + nLen
  890.   wxString& erase(size_t nStart = 0, size_t nLen = npos);
  891.  
  892.     // replaces the substring of length nLen starting at nStart
  893.   wxString& replace(size_t nStart, size_t nLen, const wxChar* sz);
  894.     // replaces the substring with nCount copies of ch
  895.   wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxChar ch);
  896.     // replaces a substring with another substring
  897.   wxString& replace(size_t nStart, size_t nLen,
  898.                     const wxString& str, size_t nStart2, size_t nLen2);
  899.     // replaces the substring with first nCount chars of sz
  900.   wxString& replace(size_t nStart, size_t nLen,
  901.                     const wxChar* sz, size_t nCount);
  902.  
  903.     // swap two strings
  904.   void swap(wxString& str);
  905.  
  906.     // All find() functions take the nStart argument which specifies the
  907.     // position to start the search on, the default value is 0. All functions
  908.     // return npos if there were no match.
  909.  
  910.     // find a substring
  911.   size_t find(const wxString& str, size_t nStart = 0) const;
  912.  
  913.   // VC++ 1.5 can't cope with this syntax.
  914. #if !defined(__VISUALC__) || defined(__WIN32__)
  915.     // find first n characters of sz
  916.   size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
  917. #endif // VC++ 1.5
  918.  
  919.   // Gives a duplicate symbol (presumably a case-insensitivity problem)
  920. #if !defined(__BORLANDC__)
  921.     // find the first occurence of character ch after nStart
  922.   size_t find(wxChar ch, size_t nStart = 0) const;
  923. #endif
  924.     // rfind() family is exactly like find() but works right to left
  925.  
  926.     // as find, but from the end
  927.   size_t rfind(const wxString& str, size_t nStart = npos) const;
  928.  
  929.   // VC++ 1.5 can't cope with this syntax.
  930. #if !defined(__VISUALC__) || defined(__WIN32__)
  931.     // as find, but from the end
  932.   size_t rfind(const wxChar* sz, size_t nStart = npos,
  933.           size_t n = npos) const;
  934.     // as find, but from the end
  935.   size_t rfind(wxChar ch, size_t nStart = npos) const;
  936. #endif // VC++ 1.5
  937.  
  938.     // find first/last occurence of any character in the set
  939.  
  940.     // as strpbrk() but starts at nStart, returns npos if not found
  941.   size_t find_first_of(const wxString& str, size_t nStart = 0) const
  942.     { return find_first_of(str.c_str(), nStart); }
  943.     // same as above
  944.   size_t find_first_of(const wxChar* sz, size_t nStart = 0) const;
  945.     // same as find(char, size_t)
  946.   size_t find_first_of(wxChar c, size_t nStart = 0) const
  947.     { return find(c, nStart); }
  948.     // find the last (starting from nStart) char from str in this string
  949.   size_t find_last_of (const wxString& str, size_t nStart = npos) const
  950.     { return find_last_of(str.c_str(), nStart); }
  951.     // same as above
  952.   size_t find_last_of (const wxChar* sz, size_t nStart = npos) const;
  953.     // same as above
  954.   size_t find_last_of(wxChar c, size_t nStart = npos) const
  955.     { return rfind(c, nStart); }
  956.  
  957.     // find first/last occurence of any character not in the set
  958.  
  959.     // as strspn() (starting from nStart), returns npos on failure
  960.   size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
  961.     { return find_first_not_of(str.c_str(), nStart); }
  962.     // same as above
  963.   size_t find_first_not_of(const wxChar* sz, size_t nStart = 0) const;
  964.     // same as above
  965.   size_t find_first_not_of(wxChar ch, size_t nStart = 0) const;
  966.     //  as strcspn()
  967.   size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
  968.     { return find_first_not_of(str.c_str(), nStart); }
  969.     // same as above
  970.   size_t find_last_not_of(const wxChar* sz, size_t nStart = npos) const;
  971.     // same as above
  972.   size_t find_last_not_of(wxChar ch, size_t nStart = npos) const;
  973.  
  974.     // All compare functions return -1, 0 or 1 if the [sub]string is less,
  975.     // equal or greater than the compare() argument.
  976.  
  977.     // just like strcmp()
  978.   int compare(const wxString& str) const { return Cmp(str); }
  979.     // comparison with a substring
  980.   int compare(size_t nStart, size_t nLen, const wxString& str) const
  981.     { return Mid(nStart, nLen).Cmp(str); }
  982.     // comparison of 2 substrings
  983.   int compare(size_t nStart, size_t nLen,
  984.               const wxString& str, size_t nStart2, size_t nLen2) const
  985.     { return Mid(nStart, nLen).Cmp(str.Mid(nStart2, nLen2)); }
  986.     // just like strcmp()
  987.   int compare(const wxChar* sz) const { return Cmp(sz); }
  988.     // substring comparison with first nCount characters of sz
  989.   int compare(size_t nStart, size_t nLen,
  990.               const wxChar* sz, size_t nCount = npos) const
  991.     { return Mid(nStart, nLen).Cmp(wxString(sz, nCount)); }
  992.  
  993.   // substring extraction
  994.   wxString substr(size_t nStart = 0, size_t nLen = npos) const
  995.     { return Mid(nStart, nLen); }
  996. #endif // wxSTD_STRING_COMPATIBILITY
  997. };
  998.  
  999. // ----------------------------------------------------------------------------
  1000. // The string array uses it's knowledge of internal structure of the wxString
  1001. // class to optimize string storage. Normally, we would store pointers to
  1002. // string, but as wxString is, in fact, itself a pointer (sizeof(wxString) is
  1003. // sizeof(char *)) we store these pointers instead. The cast to "wxString *" is
  1004. // really all we need to turn such pointer into a string!
  1005. //
  1006. // Of course, it can be called a dirty hack, but we use twice less memory and
  1007. // this approach is also more speed efficient, so it's probably worth it.
  1008. //
  1009. // Usage notes: when a string is added/inserted, a new copy of it is created,
  1010. // so the original string may be safely deleted. When a string is retrieved
  1011. // from the array (operator[] or Item() method), a reference is returned.
  1012. // ----------------------------------------------------------------------------
  1013.  
  1014. class WXDLLEXPORT wxArrayString
  1015. {
  1016. public:
  1017.   // type of function used by wxArrayString::Sort()
  1018.   typedef int (*CompareFunction)(const wxString& first,
  1019.                                  const wxString& second);
  1020.  
  1021.   // constructors and destructor
  1022.     // default ctor
  1023.   wxArrayString()
  1024.       : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
  1025.       { Init(FALSE); }
  1026.     // if autoSort is TRUE, the array is always sorted (in alphabetical order)
  1027.     //
  1028.     // NB: the reason for using int and not bool is that like this we can avoid
  1029.     //     using this ctor for implicit conversions from "const char *" (which
  1030.     //     we'd like to be implicitly converted to wxString instead!)
  1031.     //
  1032.     //     of course, using explicit would be even better - if all compilers
  1033.     //     supported it...
  1034.   wxArrayString(int autoSort)
  1035.       : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
  1036.       { Init(autoSort != 0); }
  1037.     // copy ctor
  1038.   wxArrayString(const wxArrayString& array);
  1039.     // assignment operator
  1040.   wxArrayString& operator=(const wxArrayString& src);
  1041.     // not virtual, this class should not be derived from
  1042.  ~wxArrayString();
  1043.  
  1044.   // memory management
  1045.     // empties the list, but doesn't release memory
  1046.   void Empty();
  1047.     // empties the list and releases memory
  1048.   void Clear();
  1049.     // preallocates memory for given number of items
  1050.   void Alloc(size_t nCount);
  1051.     // minimzes the memory usage (by freeing all extra memory)
  1052.   void Shrink();
  1053.  
  1054.   // simple accessors
  1055.     // number of elements in the array
  1056.   size_t GetCount() const { return m_nCount; }
  1057.     // is it empty?
  1058.   bool IsEmpty() const { return m_nCount == 0; }
  1059.     // number of elements in the array (GetCount is preferred API)
  1060.   size_t Count() const { return m_nCount; }
  1061.  
  1062.   // items access (range checking is done in debug version)
  1063.     // get item at position uiIndex
  1064.   wxString& Item(size_t nIndex) const
  1065.     {
  1066.         wxASSERT_MSG( nIndex < m_nCount,
  1067.                       _T("wxArrayString: index out of bounds") );
  1068.  
  1069.         return *(wxString *)&(m_pItems[nIndex]);
  1070.     }
  1071.  
  1072.     // same as Item()
  1073.   wxString& operator[](size_t nIndex) const { return Item(nIndex); }
  1074.     // get last item
  1075.   wxString& Last() const
  1076.   {
  1077.       wxASSERT_MSG( !IsEmpty(),
  1078.                     _T("wxArrayString: index out of bounds") );
  1079.       return Item(Count() - 1);
  1080.   }
  1081.  
  1082.     // return a wxString[], useful for the controls which
  1083.     // take one in their ctor.  You must delete[] it yourself
  1084.     // once you are done with it.  Will return NULL if the
  1085.     // ArrayString was empty.
  1086.   wxString* GetStringArray() const;
  1087.  
  1088.   // item management
  1089.     // Search the element in the array, starting from the beginning if
  1090.     // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case
  1091.     // sensitive (default). Returns index of the first item matched or
  1092.     // wxNOT_FOUND
  1093.   int  Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const;
  1094.     // add new element at the end (if the array is not sorted), return its
  1095.     // index
  1096.   size_t Add(const wxString& str, size_t nInsert = 1);
  1097.     // add new element at given position
  1098.   void Insert(const wxString& str, size_t uiIndex, size_t nInsert = 1);
  1099.     // expand the array to have count elements
  1100.   void SetCount(size_t count);
  1101.     // remove first item matching this value
  1102.   void Remove(const wxChar *sz);
  1103.     // remove item by index
  1104.   void Remove(size_t nIndex, size_t nRemove = 1);
  1105.   void RemoveAt(size_t nIndex, size_t nRemove = 1) { Remove(nIndex, nRemove); }
  1106.  
  1107.   // sorting
  1108.     // sort array elements in alphabetical order (or reversed alphabetical
  1109.     // order if reverseOrder parameter is TRUE)
  1110.   void Sort(bool reverseOrder = FALSE);
  1111.     // sort array elements using specified comparaison function
  1112.   void Sort(CompareFunction compareFunction);
  1113.  
  1114.   // comparison
  1115.     // compare two arrays case sensitively
  1116.   bool operator==(const wxArrayString& a) const;
  1117.     // compare two arrays case sensitively
  1118.   bool operator!=(const wxArrayString& a) const { return !(*this == a); }
  1119.  
  1120. protected:
  1121.   void Init(bool autoSort);             // common part of all ctors
  1122.   void Copy(const wxArrayString& src);  // copies the contents of another array
  1123.  
  1124. private:
  1125.   void Grow(size_t nIncrement = 0);     // makes array bigger if needed
  1126.   void Free();                          // free all the strings stored
  1127.  
  1128.   void DoSort();                        // common part of all Sort() variants
  1129.  
  1130.   size_t  m_nSize,    // current size of the array
  1131.           m_nCount;   // current number of elements
  1132.  
  1133.   wxChar  **m_pItems; // pointer to data
  1134.  
  1135.   bool    m_autoSort; // if TRUE, keep the array always sorted
  1136. };
  1137.  
  1138. class WXDLLEXPORT wxSortedArrayString : public wxArrayString
  1139. {
  1140. public:
  1141.   wxSortedArrayString() : wxArrayString(TRUE)
  1142.     { }
  1143.   wxSortedArrayString(const wxArrayString& array) : wxArrayString(TRUE)
  1144.     { Copy(array); }
  1145. };
  1146.  
  1147. // ----------------------------------------------------------------------------
  1148. // wxStringBuffer: a tiny class allowing to get a writable pointer into string
  1149. // ----------------------------------------------------------------------------
  1150.  
  1151. class WXDLLEXPORT wxStringBuffer
  1152. {
  1153. public:
  1154.     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
  1155.         : m_str(str), m_buf(NULL)
  1156.         { m_buf = m_str.GetWriteBuf(lenWanted); }
  1157.  
  1158.     ~wxStringBuffer() { m_str.UngetWriteBuf(); }
  1159.  
  1160.     operator wxChar*() const { return m_buf; }
  1161.  
  1162. private:
  1163.     wxString& m_str;
  1164.     wxChar   *m_buf;
  1165.  
  1166.     DECLARE_NO_COPY_CLASS(wxStringBuffer)
  1167. };
  1168.  
  1169. // ---------------------------------------------------------------------------
  1170. // wxString comparison functions: operator versions are always case sensitive
  1171. // ---------------------------------------------------------------------------
  1172.  
  1173. inline bool operator==(const wxString& s1, const wxString& s2)
  1174.     { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
  1175. inline bool operator==(const wxString& s1, const wxChar  * s2)
  1176.     { return s1.Cmp(s2) == 0; }
  1177. inline bool operator==(const wxChar  * s1, const wxString& s2)
  1178.     { return s2.Cmp(s1) == 0; }
  1179. inline bool operator!=(const wxString& s1, const wxString& s2)
  1180.     { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
  1181. inline bool operator!=(const wxString& s1, const wxChar  * s2)
  1182.     { return s1.Cmp(s2) != 0; }
  1183. inline bool operator!=(const wxChar  * s1, const wxString& s2)
  1184.     { return s2.Cmp(s1) != 0; }
  1185. inline bool operator< (const wxString& s1, const wxString& s2)
  1186.     { return s1.Cmp(s2) < 0; }
  1187. inline bool operator< (const wxString& s1, const wxChar  * s2)
  1188.     { return s1.Cmp(s2) <  0; }
  1189. inline bool operator< (const wxChar  * s1, const wxString& s2)
  1190.     { return s2.Cmp(s1) >  0; }
  1191. inline bool operator> (const wxString& s1, const wxString& s2)
  1192.     { return s1.Cmp(s2) >  0; }
  1193. inline bool operator> (const wxString& s1, const wxChar  * s2)
  1194.     { return s1.Cmp(s2) >  0; }
  1195. inline bool operator> (const wxChar  * s1, const wxString& s2)
  1196.     { return s2.Cmp(s1) <  0; }
  1197. inline bool operator<=(const wxString& s1, const wxString& s2)
  1198.     { return 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.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.  
  1210. // comparison with char
  1211. inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
  1212. inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
  1213. inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
  1214. inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
  1215.  
  1216. #if wxUSE_UNICODE
  1217. inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
  1218.     { return (s1.Cmp((const wchar_t *)s2) == 0); }
  1219. inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
  1220.     { return (s2.Cmp((const wchar_t *)s1) == 0); }
  1221. inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
  1222.     { return (s1.Cmp((const wchar_t *)s2) != 0); }
  1223. inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
  1224.     { return (s2.Cmp((const wchar_t *)s1) != 0); }
  1225. #else // !wxUSE_UNICODE
  1226. inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
  1227.     { return (s1.Cmp((const char *)s2) == 0); }
  1228. inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
  1229.     { return (s2.Cmp((const char *)s1) == 0); }
  1230. inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
  1231.     { return (s1.Cmp((const char *)s2) != 0); }
  1232. inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
  1233.     { return (s2.Cmp((const char *)s1) != 0); }
  1234. #endif // wxUSE_UNICODE/!wxUSE_UNICODE
  1235.  
  1236. wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
  1237. wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
  1238. wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
  1239. wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
  1240. wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
  1241. #if wxUSE_UNICODE
  1242. inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
  1243.     { return string + (const wchar_t *)buf; }
  1244. inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
  1245.     { return (const wchar_t *)buf + string; }
  1246. #else // !wxUSE_UNICODE
  1247. inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
  1248.     { return string + (const char *)buf; }
  1249. inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
  1250.     { return (const char *)buf + string; }
  1251. #endif // wxUSE_UNICODE/!wxUSE_UNICODE
  1252.  
  1253. // ---------------------------------------------------------------------------
  1254. // Implementation only from here until the end of file
  1255. // ---------------------------------------------------------------------------
  1256.  
  1257. // don't pollute the library user's name space
  1258. #undef wxASSERT_VALID_INDEX
  1259.  
  1260. #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
  1261.  
  1262. #include "wx/ioswrap.h"
  1263.  
  1264. WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
  1265. WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
  1266.  
  1267. #endif  // wxSTD_STRING_COMPATIBILITY
  1268.  
  1269. #endif  // _WX_WXSTRINGH__
  1270.