wxCursor(wxImage) added (Chris Elliott, patch 517439)

[wxWidgets.git] / include / wx / string.h

diff --git a/include/wx/string.h b/include/wx/string.h
index bb7bf7071e2fb6857a6a7bd866aabd94d51f5a91..51583c89a355333cd55a87df7654b7e1b8cf11b8 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -29,15 +29,12 @@
 // compile the std::string compatibility functions if defined
 #define   wxSTD_STRING_COMPATIBILITY
 
 // compile the std::string compatibility functions if defined
 #define   wxSTD_STRING_COMPATIBILITY
 

-// define to derive wxString from wxObject (deprecated!)
-#ifdef WXSTRING_IS_WXOBJECT
-    #undef WXSTRING_IS_WXOBJECT
-#endif
-

 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 

+#include "wx/defs.h"        // everybody should include this
+

 #if defined(__WXMAC__) || defined(__VISAGECPP__)
     #include <ctype.h>
 #endif
 #if defined(__WXMAC__) || defined(__VISAGECPP__)
     #include <ctype.h>
 #endif


@@ -63,31 +60,26 @@
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()

-#endif // AIX
+#endif // HAVE_STRINGS_H

 
 

-#include "wx/defs.h"        // everybody should include this

 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
 
 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
 

-#ifndef  WX_PRECOMP
-  #ifdef    WXSTRING_IS_WXOBJECT
-    #include "wx/object.h" // base class
-  #endif
-#endif // !PCH
-

 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------
 

-// 'naughty' cast
+// casts [unfortunately!] needed to call some broken functions which require
+// "char *" instead of "const char *"

 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxCSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxMBSTRINGCAST (char *)(const char *)
 #define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
 
 // implementation only
 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxCSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxMBSTRINGCAST (char *)(const char *)
 #define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
 
 // implementation only

-#define   ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() )
+#define   wxASSERT_VALID_INDEX(i) \
+    wxASSERT_MSG( (size_t)(i) <= Len(), _T("invaid index in wxString") )

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -120,14 +112,14 @@ WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
 // backwards compatibility only.
 
 // checks whether the passed in pointer is NULL and if the string is empty
 // backwards compatibility only.
 
 // checks whether the passed in pointer is NULL and if the string is empty

-inline bool WXDLLEXPORT IsEmpty(const char *p) { return (!p || !*p); }
+inline bool IsEmpty(const char *p) { return (!p || !*p); }

 
 // safe version of strlen() (returns 0 if passed NULL pointer)
 
 // safe version of strlen() (returns 0 if passed NULL pointer)

-inline size_t WXDLLEXPORT Strlen(const char *psz)
+inline size_t Strlen(const char *psz)

   { return psz ? strlen(psz) : 0; }
 
 // portable strcasecmp/_stricmp
   { return psz ? strlen(psz) : 0; }
 
 // portable strcasecmp/_stricmp

-inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
+inline int Stricmp(const char *psz1, const char *psz2)

 {
 #if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
   return _stricmp(psz1, psz2);
 {
 #if defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
   return _stricmp(psz1, psz2);


@@ -139,6 +131,8 @@ inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);

+#elif defined(__DJGPP__)
+  return stricmp(psz1, psz2);

 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)
 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)


@@ -241,15 +235,8 @@ struct WXDLLEXPORT wxStringData
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 

-#ifdef  WXSTRING_IS_WXOBJECT
-class WXDLLEXPORT wxString : public wxObject
-{
-    DECLARE_DYNAMIC_CLASS(wxString)
-#else   //WXSTRING_IS_WXOBJECT

 class WXDLLEXPORT wxString
 {
 class WXDLLEXPORT wxString
 {

-#endif  //WXSTRING_IS_WXOBJECT
-

 friend class WXDLLEXPORT wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order
 friend class WXDLLEXPORT wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order


@@ -287,14 +274,20 @@ private:
   void CopyBeforeWrite();
   void AllocBeforeWrite(size_t);
 
   void CopyBeforeWrite();
   void AllocBeforeWrite(size_t);
 

-  // this method is not implemented - there is _no_ conversion from int to
+  // if we hadn't made these operators private, it would be possible to
+  // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
+  // converted to char in C and we do have operator=(char)
+  //
+  // NB: we don't need other versions (short/long and unsigned) as attempt
+  //     to assign another numeric type to wxString will now result in
+  //     ambiguity between operator=(char) and operator=(int)
+  wxString& operator=(int);
+
+  // these methods are not implemented - there is _no_ conversion from int to

   // string, you're doing something wrong if the compiler wants to call it!
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);
   // string, you're doing something wrong if the compiler wants to call it!
   //
   // try `s << i' or `s.Printf("%d", i)' instead
   wxString(int);

-  wxString(unsigned int);
-  wxString(long);
-  wxString(unsigned long);

 
 public:
   // constructors and destructor
 
 public:
   // constructors and destructor


@@ -338,7 +331,7 @@ public:
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string

-  wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc);
+  wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);

 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer
 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer


@@ -356,14 +349,14 @@ public:
   bool IsEmpty() const { return Len() == 0; }
     // empty string is "FALSE", so !str will return TRUE
   bool operator!() const { return IsEmpty(); }
   bool IsEmpty() const { return Len() == 0; }
     // empty string is "FALSE", so !str will return TRUE
   bool operator!() const { return IsEmpty(); }

+    // truncate the string to given length
+  wxString& Truncate(size_t uiLen);

     // empty string contents
   void Empty()
   {
     // empty string contents
   void Empty()
   {

-    if ( !IsEmpty() )
-      Reinit();
+    Truncate(0);

 
 

-    // should be empty
-    wxASSERT( GetStringData()->nDataLength == 0 );
+    wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );

   }
     // empty the string and free memory
   void Clear()
   }
     // empty the string and free memory
   void Clear()


@@ -386,13 +379,13 @@ public:
   // data access (all indexes are 0 based)
     // read access
     wxChar  GetChar(size_t n) const
   // data access (all indexes are 0 based)
     // read access
     wxChar  GetChar(size_t n) const

-      { ASSERT_VALID_INDEX( n );  return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n );  return m_pchData[n]; }

     // read/write access
     wxChar& GetWritableChar(size_t n)
     // read/write access
     wxChar& GetWritableChar(size_t n)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

     // write access
     void  SetChar(size_t n, wxChar ch)
     // write access
     void  SetChar(size_t n, wxChar ch)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }

 
     // get last character
     wxChar  Last() const
 
     // get last character
     wxChar  Last() const


@@ -401,27 +394,49 @@ public:
     wxChar& Last()
       { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
 
     wxChar& Last()
       { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
 

+    /*
+        So why do we have all these overloaded operator[]s? A bit of history:
+        initially there was only one of them, taking size_t. Then people
+        started complaining because they wanted to use ints as indices (I
+        wonder why) and compilers were giving warnings about it, so we had to
+        add the operator[](int). Then it became apparent that you couldn't
+        write str[0] any longer because there was ambiguity between two
+        overloads and so you now had to write str[0u] (or, of course, use the
+        explicit casts to either int or size_t but nobody did this).
+
+        Finally, someone decided to compile wxWin on an Alpha machine and got
+        a surprize: str[0u] didn't compile there because it is of type
+        unsigned int and size_t is unsigned _long_ on Alpha and so there was
+        ambiguity between converting uint to int or ulong. To fix this one we
+        now add operator[](uint) for the machines where size_t is not already
+        the same as unsigned int - hopefully this fixes the problem (for some
+        time)
+
+        The only real fix is, of course, to remove all versions but the one
+        taking size_t...
+     */
+

     // operator version of GetChar
     wxChar  operator[](size_t n) const
     // operator version of GetChar
     wxChar  operator[](size_t n) const

-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

 
     // operator version of GetChar
     wxChar  operator[](int n) const
 
     // operator version of GetChar
     wxChar  operator[](int n) const

-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
-#ifdef __alpha__
-    // operator version of GetChar
-    wxChar  operator[](unsigned int n) const
-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
-#endif
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)
 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
-#ifdef __alpha__
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+
+#ifndef wxSIZE_T_IS_UINT
+    // operator version of GetChar
+    wxChar operator[](unsigned int n) const
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+

     // operator version of GetWriteableChar
     // operator version of GetWriteableChar

-    wxChar&  operator[](unsigned int n)
-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
-#endif
+    wxChar& operator[](unsigned int n)
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+#endif // size_t != unsigned int

 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }
 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }


@@ -601,7 +616,7 @@ public:
   wxString  operator()(size_t start, size_t len) const
     { return Mid(start, len); }
 
   wxString  operator()(size_t start, size_t len) const
     { return Mid(start, len); }
 

-      // check that the tring starts with prefix and return the rest of the
+      // check that the string starts with prefix and return the rest of the

       // string in the provided pointer if it is not NULL, otherwise return
       // FALSE
   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
       // string in the provided pointer if it is not NULL, otherwise return
       // FALSE
   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;


@@ -610,7 +625,7 @@ public:
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;
   wxString Left(size_t nCount) const;
       // get last nCount characters
   wxString Right(size_t nCount) const;

-      // get all characters before the first occurence of ch
+      // get all characters before the first occurance of ch

       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxChar ch) const;
       // get all characters before the last occurence of ch
       // (returns the whole string if ch not found)
   wxString BeforeFirst(wxChar ch) const;
       // get all characters before the last occurence of ch


@@ -643,8 +658,6 @@ public:
   wxString& Trim(bool bFromRight = TRUE);
       // add nCount copies chPad in the beginning or at the end (default)
   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
   wxString& Trim(bool bFromRight = TRUE);
       // add nCount copies chPad in the beginning or at the end (default)
   wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);

-      // truncate string to given length
-  wxString& Truncate(size_t uiLen);

 
   // searching and replacing
       // searching (return starting index, or -1 if not found)
 
   // searching and replacing
       // searching (return starting index, or -1 if not found)


@@ -660,12 +673,15 @@ public:
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 

-    // conversion to numbers: all functions return TRUE only if the whole string
-    // is a number and put the value of this number into the pointer provided
+    // conversion to numbers: all functions return TRUE only if the whole
+    // string is a number and put the value of this number into the pointer
+    // provided, the base is the numeric base in which the conversion should be
+    // done and must be comprised between 2 and 36 or be 0 in which case the
+    // standard C rules apply (leading '0' => octal, "0x" => hex)

         // convert to a signed integer
         // convert to a signed integer

-    bool ToLong(long *val) const;
+    bool ToLong(long *val, int base = 10) const;

         // convert to an unsigned integer
         // convert to an unsigned integer

-    bool ToULong(unsigned long *val) const;
+    bool ToULong(unsigned long *val, int base = 10) const;

         // convert to a double
     bool ToDouble(double *val) const;
 
         // convert to a double
     bool ToDouble(double *val) const;
 


@@ -727,7 +743,7 @@ public:
   size_t Index(wxChar ch)         const { return Find(ch);  }
     // use Truncate
   wxString& Remove(size_t pos) { return Truncate(pos); }
   size_t Index(wxChar ch)         const { return Find(ch);  }
     // use Truncate
   wxString& Remove(size_t pos) { return Truncate(pos); }

-  wxString& RemoveLast() { return Truncate(Len() - 1); }
+  wxString& RemoveLast(size_t n = 1) { return Truncate(Len() - n); }

 
   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
 
 
   wxString& Remove(size_t nStart, size_t nLen) { return erase( nStart, nLen ); }
 


@@ -803,16 +819,17 @@ public:
   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
 
     // same as `this_string = str'
   wxString& append(size_t n, wxChar ch) { return Pad(n, ch); }
 
     // same as `this_string = str'

-  wxString& assign(const wxString& str) { return (*this) = str; }
+  wxString& assign(const wxString& str)
+    { return *this = str; }

     // same as ` = str[pos..pos + n]
   wxString& assign(const wxString& str, size_t pos, size_t n)
     // same as ` = str[pos..pos + n]
   wxString& assign(const wxString& str, size_t pos, size_t n)

-    { return *this = wxString((const wxChar *)str + pos, n); }
+    { Empty(); return Append(str.c_str() + pos, n); }

     // same as `= first n (or all if n == npos) characters of sz'
   wxString& assign(const wxChar *sz, size_t n = npos)
     // same as `= first n (or all if n == npos) characters of sz'
   wxString& assign(const wxChar *sz, size_t n = npos)

-    { return *this = wxString(sz, n); }
+    { Empty(); return Append(sz, n == npos ? wxStrlen(sz) : n); }

     // same as `= n copies of ch'
   wxString& assign(size_t n, wxChar ch)
     // same as `= n copies of ch'
   wxString& assign(size_t n, wxChar ch)

-    { return *this = wxString(ch, n); }
+    { Empty(); return Append(ch, n); }

 
     // insert another string
   wxString& insert(size_t nPos, const wxString& str);
 
     // insert another string
   wxString& insert(size_t nPos, const wxString& str);


@@ -960,9 +977,17 @@ public:
                                  const wxString& second);
 
   // constructors and destructor
                                  const wxString& second);
 
   // constructors and destructor

-    // default ctor: if autoSort is TRUE, the array is always sorted (in
-    // alphabetical order)
-  wxArrayString(bool autoSort = FALSE);
+    // default ctor
+  wxArrayString() { Init(FALSE); }
+    // if autoSort is TRUE, the array is always sorted (in alphabetical order)
+    //
+    // NB: the reason for using int and not bool is that like this we can avoid
+    //     using this ctor for implicit conversions from "const char *" (which
+    //     we'd like to be implicitly converted to wxString instead!)
+    //
+    //     of course, using explicit would be even better - if all compilers
+    //     supported it...
+  wxArrayString(int autoSort) { Init(autoSort != 0); }

     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator
     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator


@@ -997,6 +1022,12 @@ public:
     // get last item
   wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
 
     // get last item
   wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
 

+    // return a wxString[], useful for the controls which
+    // take one in their ctor.  You must delete[] it yourself
+    // once you are done with it.  Will return NULL if the
+    // ArrayString was empty.
+  wxString* GetStringArray() const;
+

   // item management
     // Search the element in the array, starting from the beginning if
     // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case
   // item management
     // Search the element in the array, starting from the beginning if
     // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case


@@ -1008,6 +1039,8 @@ public:
   size_t Add(const wxString& str);
     // add new element at given position
   void Insert(const wxString& str, size_t uiIndex);
   size_t Add(const wxString& str);
     // add new element at given position
   void Insert(const wxString& str, size_t uiIndex);

+    // expand the array to have count elements
+  void SetCount(size_t count);

     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index
     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index


@@ -1028,6 +1061,7 @@ public:
   bool operator!=(const wxArrayString& a) const { return !(*this == a); }
 
 protected:
   bool operator!=(const wxArrayString& a) const { return !(*this == a); }
 
 protected:

+  void Init(bool autoSort);             // common part of all ctors

   void Copy(const wxArrayString& src);  // copies the contents of another array
 
 private:
   void Copy(const wxArrayString& src);  // copies the contents of another array
 
 private:


@@ -1053,46 +1087,65 @@ public:
     { Copy(array); }
 };
 
     { Copy(array); }
 };
 

+// ----------------------------------------------------------------------------
+// wxStringBuffer: a tiny class allowing to get a writable pointer into string
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStringBuffer
+{
+public:
+    wxStringBuffer(wxString& str, size_t lenWanted = 1024)
+        : m_str(str) { m_buf = m_str.GetWriteBuf(lenWanted); }
+
+    ~wxStringBuffer() { m_str.UngetWriteBuf(); }
+
+    operator wxChar*() const { return m_buf; }
+
+private:
+    wxString& m_str;
+    wxChar   *m_buf;
+};
+

 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 

-//
-inline bool operator==(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) == 0); }
-//
-inline bool operator==(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) == 0); }
-//
-inline bool operator==(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) == 0); }
-//
-inline bool operator!=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) != 0); }
-//
-inline bool operator!=(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) != 0); }
-//
-inline bool operator!=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) != 0); }
-//
-inline bool operator< (const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) < 0); }
-//
-inline bool operator< (const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) <  0); }
-//
-inline bool operator< (const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) >  0); }
-//
-inline bool operator> (const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) >  0); }
-//
-inline bool operator> (const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) >  0); }
-//
-inline bool operator> (const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) <  0); }
-//
-inline bool operator<=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) <= 0); }
-//
-inline bool operator<=(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) <= 0); }
-//
-inline bool operator<=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) >= 0); }
-//
-inline bool operator>=(const wxString& s1, const wxString& s2) { return (s1.Cmp(s2) >= 0); }
-//
-inline bool operator>=(const wxString& s1, const wxChar  * s2) { return (s1.Cmp(s2) >= 0); }
-//
-inline bool operator>=(const wxChar  * s1, const wxString& s2) { return (s2.Cmp(s1) <= 0); }
+inline bool operator==(const wxString& s1, const wxString& s2)
+    { return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
+inline bool operator==(const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) == 0; }
+inline bool operator==(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) == 0; }
+inline bool operator!=(const wxString& s1, const wxString& s2)
+    { return (s1.Len() != s2.Len()) || (s1.Cmp(s2) != 0); }
+inline bool operator!=(const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) != 0; }
+inline bool operator!=(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) != 0; }
+inline bool operator< (const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) < 0; }
+inline bool operator< (const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) <  0; }
+inline bool operator< (const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) >  0; }
+inline bool operator> (const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) >  0; }
+inline bool operator> (const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) >  0; }
+inline bool operator> (const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) <  0; }
+inline bool operator<=(const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) <= 0; }
+inline bool operator<=(const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) <= 0; }
+inline bool operator<=(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) >= 0; }
+inline bool operator>=(const wxString& s1, const wxString& s2)
+    { return s1.Cmp(s2) >= 0; }
+inline bool operator>=(const wxString& s1, const wxChar  * s2)
+    { return s1.Cmp(s2) >= 0; }
+inline bool operator>=(const wxChar  * s1, const wxString& s2)
+    { return s2.Cmp(s1) <= 0; }

 
 // comparison with char
 inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
 
 // comparison with char
 inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }


@@ -1109,7 +1162,7 @@ inline bool operator!=(const wxString& s1, const wxWCharBuffer& s2)
     { return (s1.Cmp((const wchar_t *)s2) != 0); }
 inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const wchar_t *)s1) != 0); }
     { return (s1.Cmp((const wchar_t *)s2) != 0); }
 inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const wchar_t *)s1) != 0); }

-#else
+#else // !wxUSE_UNICODE

 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
     { return (s1.Cmp((const char *)s2) == 0); }
 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
 inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
     { return (s1.Cmp((const char *)s2) == 0); }
 inline bool operator==(const wxCharBuffer& s1, const wxString& s2)


@@ -1118,7 +1171,7 @@ inline bool operator!=(const wxString& s1, const wxCharBuffer& s2)
     { return (s1.Cmp((const char *)s2) != 0); }
 inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const char *)s1) != 0); }
     { return (s1.Cmp((const char *)s2) != 0); }
 inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const char *)s1) != 0); }

-#endif
+#endif // wxUSE_UNICODE/!wxUSE_UNICODE

 
 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);
 
 wxString WXDLLEXPORT operator+(const wxString& string1,  const wxString& string2);
 wxString WXDLLEXPORT operator+(const wxString& string, wxChar ch);


@@ -1126,30 +1179,30 @@ wxString WXDLLEXPORT operator+(wxChar ch, const wxString& string);
 wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
 wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
 #if wxUSE_UNICODE
 wxString WXDLLEXPORT operator+(const wxString& string, const wxChar *psz);
 wxString WXDLLEXPORT operator+(const wxChar *psz, const wxString& string);
 #if wxUSE_UNICODE

-inline wxString WXDLLEXPORT operator+(const wxString& string, const wxWCharBuffer& buf)
+inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)

     { return string + (const wchar_t *)buf; }
     { return string + (const wchar_t *)buf; }

-inline wxString WXDLLEXPORT operator+(const wxWCharBuffer& buf, const wxString& string)
+inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)

     { return (const wchar_t *)buf + string; }
     { return (const wchar_t *)buf + string; }

-#else
-inline wxString WXDLLEXPORT operator+(const wxString& string, const wxCharBuffer& buf)
+#else // !wxUSE_UNICODE
+inline wxString operator+(const wxString& string, const wxCharBuffer& buf)

     { return string + (const char *)buf; }
     { return string + (const char *)buf; }

-inline wxString WXDLLEXPORT operator+(const wxCharBuffer& buf, const wxString& string)
+inline wxString operator+(const wxCharBuffer& buf, const wxString& string)

     { return (const char *)buf + string; }
     { return (const char *)buf + string; }

-#endif
+#endif // wxUSE_UNICODE/!wxUSE_UNICODE

 
 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 
 // don't pollute the library user's name space
 
 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 
 // don't pollute the library user's name space

-#undef ASSERT_VALID_INDEX
+#undef wxASSERT_VALID_INDEX

 
 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
 
 #include "wx/ioswrap.h"
 
 
 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
 
 #include "wx/ioswrap.h"
 

-WXDLLEXPORT istream& operator>>(istream&, wxString&);
-WXDLLEXPORT ostream& operator<<(ostream&, const wxString&);
+WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
+WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);

 
 #endif  // wxSTD_STRING_COMPATIBILITY
 
 
 #endif  // wxSTD_STRING_COMPATIBILITY