source id type is unsigned; minor cleanup

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

diff --git a/include/wx/string.h b/include/wx/string.h
index 08d45448101524a2092c4a7536d4fc3b3f1f6dbf..6733c24b2a8eb667fcd78dd1a7055e05a449b4a7 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -76,9 +76,15 @@ class WXDLLIMPEXP_BASE wxString;
 // constants
 // ----------------------------------------------------------------------------
 
 // constants
 // ----------------------------------------------------------------------------
 

+#if WXWIN_COMPATIBILITY_2_6
+
+// deprecated in favour of wxString::npos, don't use in new code
+//

 // maximum possible length for a string means "take all string" everywhere
 #define wxSTRING_MAXLEN wxStringBase::npos
 
 // maximum possible length for a string means "take all string" everywhere
 #define wxSTRING_MAXLEN wxStringBase::npos
 

+#endif // WXWIN_COMPATIBILITY_2_6
+

 // ----------------------------------------------------------------------------
 // global data
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // global data
 // ----------------------------------------------------------------------------


@@ -164,7 +170,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
 // ----------------------------------------------------------------------------
 
 // in both cases we need to define wxStdString
 // ----------------------------------------------------------------------------
 
 // in both cases we need to define wxStdString

-#if wxUSE_STL || defined(wxUSE_STD_STRING)
+#if wxUSE_STL || wxUSE_STD_STRING

 
 #include "wx/beforestd.h"
 #include <string>
 
 #include "wx/beforestd.h"
 #include <string>


@@ -187,6 +193,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
     // we don't need an extra ctor from std::string when copy ctor already does
     // the work
     #undef wxUSE_STD_STRING
     // we don't need an extra ctor from std::string when copy ctor already does
     // the work
     #undef wxUSE_STD_STRING

+    #define wxUSE_STD_STRING 0

 
     #if (defined(__GNUG__) && (__GNUG__ < 3)) || \
         (defined(_MSC_VER) && (_MSC_VER <= 1200))
 
     #if (defined(__GNUG__) && (__GNUG__ < 3)) || \
         (defined(_MSC_VER) && (_MSC_VER <= 1200))


@@ -196,7 +203,8 @@ inline int Stricmp(const char *psz1, const char *psz2)
     typedef wxStdString wxStringBase;
 #else // if !wxUSE_STL
 
     typedef wxStdString wxStringBase;
 #else // if !wxUSE_STL
 

-#ifndef HAVE_STD_STRING_COMPARE
+#if !defined(HAVE_STD_STRING_COMPARE) && \
+    (!defined(__WX_SETUP_H__) || wxUSE_STL == 0)

     #define HAVE_STD_STRING_COMPARE
 #endif
 
     #define HAVE_STD_STRING_COMPARE
 #endif
 


@@ -260,7 +268,7 @@ protected:
     // initializes the string to the empty value (must be called only from
     // ctors, use Reinit() otherwise)
   void Init() { m_pchData = (wxChar *)wxEmptyString; }
     // initializes the string to the empty value (must be called only from
     // ctors, use Reinit() otherwise)
   void Init() { m_pchData = (wxChar *)wxEmptyString; }

-    // initializaes the string with (a part of) C-string
+    // initializes the string with (a part of) C-string

   void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos);
     // as Init, but also frees old data
   void Reinit() { GetStringData()->Unlock(); Init(); }
   void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos);
     // as Init, but also frees old data
   void Reinit() { GetStringData()->Unlock(); Init(); }


@@ -297,6 +305,43 @@ public:
   typedef value_type *iterator;
   typedef const value_type *const_iterator;
 
   typedef value_type *iterator;
   typedef const value_type *const_iterator;
 

+#define wxSTRING_REVERSE_ITERATOR(name, const_or_not)                         \
+  class name                                                                  \
+  {                                                                           \
+  public:                                                                     \
+      typedef wxChar value_type;                                              \
+      typedef const_or_not value_type& reference;                             \
+      typedef const_or_not value_type *pointer;                               \
+      typedef const_or_not value_type *iterator_type;                         \
+                                                                              \
+      name(iterator_type i) : m_cur(i) { }                                    \
+      name(const name& ri) : m_cur(ri.m_cur) { }                              \
+                                                                              \
+      iterator_type base() const { return m_cur; }                            \
+                                                                              \
+      reference operator*() const { return *(m_cur - 1); }                    \
+                                                                              \
+      name& operator++() { --m_cur; return *this; }                           \
+      name operator++(int) { name tmp = *this; --m_cur; return tmp; }         \
+      name& operator--() { ++m_cur; return *this; }                           \
+      name operator--(int) { name tmp = *this; ++m_cur; return tmp; }         \
+                                                                              \
+      bool operator==(name ri) const { return m_cur == ri.m_cur; }            \
+      bool operator!=(name ri) const { return !(*this == ri); }               \
+                                                                              \
+  private:                                                                    \
+      iterator_type m_cur;                                                    \
+  }
+
+  wxSTRING_REVERSE_ITERATOR(const_reverse_iterator, const);
+
+  #define wxSTRING_CONST
+  wxSTRING_REVERSE_ITERATOR(reverse_iterator, wxSTRING_CONST);
+  #undef wxSTRING_CONST
+
+  #undef wxSTRING_REVERSE_ITERATOR
+
+

   // constructors and destructor
     // ctor for an empty string
   wxStringBase() { Init(); }
   // constructors and destructor
     // ctor for an empty string
   wxStringBase() { Init(); }


@@ -323,7 +368,9 @@ public:
       { InitWith(psz, 0, npos); }
   wxStringBase(const wxChar *psz, size_t nLength)
       { InitWith(psz, 0, nLength); }
       { InitWith(psz, 0, npos); }
   wxStringBase(const wxChar *psz, size_t nLength)
       { InitWith(psz, 0, nLength); }

-  wxStringBase(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
+  wxStringBase(const wxChar *psz,
+               const wxMBConv& WXUNUSED(conv),
+               size_t nLength = npos)

       { InitWith(psz, 0, nLength); }
     // take nLen chars starting at nPos
   wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen)
       { InitWith(psz, 0, nLength); }
     // take nLen chars starting at nPos
   wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen)


@@ -362,17 +409,17 @@ public:
   wxStringBase& operator=(const wxChar *psz);
 
     // return the length of the string
   wxStringBase& operator=(const wxChar *psz);
 
     // return the length of the string

-  size_type size() const { return GetStringData()->nDataLength; }
+  size_type length() const { return GetStringData()->nDataLength; }

     // return the length of the string
     // return the length of the string

-  size_type length() const { return size(); }
+  size_type size() const { return length(); }

     // return the maximum size of the string
     // return the maximum size of the string

-  size_type max_size() const { return wxSTRING_MAXLEN; }
+  size_type max_size() const { return npos; }

     // resize the string, filling the space with c if c != 0
   void resize(size_t nSize, wxChar ch = wxT('\0'));
     // delete the contents of the string
   void clear() { erase(0, npos); }
     // returns true if the string is empty
     // resize the string, filling the space with c if c != 0
   void resize(size_t nSize, wxChar ch = wxT('\0'));
     // delete the contents of the string
   void clear() { erase(0, npos); }
     // returns true if the string is empty

-  bool empty() const { return size() == 0; }
+  bool empty() const { return length() == 0; }

     // inform string about planned change in size
   void reserve(size_t sz) { Alloc(sz); }
   size_type capacity() const { return GetStringData()->nAllocLength; }
     // inform string about planned change in size
   void reserve(size_t sz) { Alloc(sz); }
   size_type capacity() const { return GetStringData()->nAllocLength; }


@@ -427,14 +474,18 @@ public:
 
     // first valid index position
   const_iterator begin() const { return m_pchData; }
 
     // first valid index position
   const_iterator begin() const { return m_pchData; }

+  iterator begin();

     // position one after the last valid one
   const_iterator end() const { return m_pchData + length(); }
     // position one after the last valid one
   const_iterator end() const { return m_pchData + length(); }

-
-  // first valid index position
-  iterator begin();
-  // position one after the last valid one

   iterator end();
 
   iterator end();
 

+    // first element of the reversed string
+  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+    // one beyond the end of the reversed string
+  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+

     // insert another string
   wxStringBase& insert(size_t nPos, const wxStringBase& str)
   {
     // insert another string
   wxStringBase& insert(size_t nPos, const wxStringBase& str)
   {


@@ -613,7 +664,7 @@ friend class WXDLLIMPEXP_BASE wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order
   //     that all inline functions can be effectively inlined, verify that all
 
   // NB: special care was taken in arranging the member functions in such order
   //     that all inline functions can be effectively inlined, verify that all

-  //     performace critical functions are still inlined if you change order!
+  //     performance critical functions are still inlined if you change order!

 private:
   // 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
 private:
   // 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


@@ -648,33 +699,42 @@ public:
       : wxStringBase(psz ? psz : wxT("")) { }
   wxString(const wxChar *psz, size_t nLength)
       : wxStringBase(psz, nLength) { }
       : wxStringBase(psz ? psz : wxT("")) { }
   wxString(const wxChar *psz, size_t nLength)
       : wxStringBase(psz, nLength) { }

-  wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
+  wxString(const wxChar *psz,
+           const wxMBConv& WXUNUSED(conv),
+           size_t nLength = npos)

       : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
 
       : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
 

-  // even we're not build with wxUSE_STL == 1 it is very convenient to allow
+  // even if we're not built with wxUSE_STL == 1 it is very convenient to allow

   // implicit conversions from std::string to wxString as this allows to use
   // the same strings in non-GUI and GUI code, however we don't want to
   // unconditionally add this ctor as it would make wx lib dependent on
   // libstdc++ on some Linux versions which is bad, so instead we ask the
   // client code to define this wxUSE_STD_STRING symbol if they need it
   // implicit conversions from std::string to wxString as this allows to use
   // the same strings in non-GUI and GUI code, however we don't want to
   // unconditionally add this ctor as it would make wx lib dependent on
   // libstdc++ on some Linux versions which is bad, so instead we ask the
   // client code to define this wxUSE_STD_STRING symbol if they need it

-#ifdef wxUSE_STD_STRING
+#if wxUSE_STD_STRING

   wxString(const wxStdString& s)
       : wxStringBase(s.c_str()) { }
 #endif // wxUSE_STD_STRING
 
 #if wxUSE_UNICODE
     // from multibyte string
   wxString(const wxStdString& s)
       : wxStringBase(s.c_str()) { }
 #endif // wxUSE_STD_STRING
 
 #if wxUSE_UNICODE
     // from multibyte string

-  wxString(const char *psz, wxMBConv& conv, size_t nLength = npos);
+  wxString(const char *psz,
+           const wxMBConv& conv = wxConvLibc,
+           size_t nLength = npos);

     // from wxWCharBuffer (i.e. return from wxGetString)
   wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { }
 #else // ANSI
     // from C string (for compilers using unsigned char)
     // from wxWCharBuffer (i.e. return from wxGetString)
   wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { }
 #else // ANSI
     // from C string (for compilers using unsigned char)

-  wxString(const unsigned char* psz, size_t nLength = npos)
+  wxString(const unsigned char* psz)
+      : wxStringBase((const char*)psz) { }
+    // from part of C string (for compilers using unsigned char)
+  wxString(const unsigned char* psz, size_t nLength)

       : wxStringBase((const char*)psz, nLength) { }
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string
       : wxStringBase((const char*)psz, nLength) { }
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string

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

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


@@ -688,7 +748,7 @@ public:
     // string contains any characters?
   bool IsEmpty() const { return empty(); }
     // empty string is "false", so !str will return true
     // string contains any characters?
   bool IsEmpty() const { return empty(); }
     // empty string is "false", so !str will return true

-  bool operator!() const { return IsEmpty(); }
+  bool operator!() const { return empty(); }

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


@@ -804,14 +864,14 @@ public:
     // type differs because a function may either return pointer to the buffer
     // directly or have to use intermediate buffer for translation.
 #if wxUSE_UNICODE
     // type differs because a function may either return pointer to the buffer
     // directly or have to use intermediate buffer for translation.
 #if wxUSE_UNICODE

-    const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const;
+    const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;

 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
     const wxChar* wc_str() const { return c_str(); }
 
     // for compatibility with !wxUSE_UNICODE version
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
     const wxChar* wc_str() const { return c_str(); }
 
     // for compatibility with !wxUSE_UNICODE version

-    const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+    const wxChar* wc_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }

 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }


@@ -822,12 +882,12 @@ public:
     const wxChar* mb_str() const { return c_str(); }
 
     // for compatibility with wxUSE_UNICODE version
     const wxChar* mb_str() const { return c_str(); }
 
     // for compatibility with wxUSE_UNICODE version

-    const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+    const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }

 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
 #if wxUSE_WCHAR_T
 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
 #if wxUSE_WCHAR_T

-    const wxWCharBuffer wc_str(wxMBConv& conv) const;
+    const wxWCharBuffer wc_str(const wxMBConv& conv) const;

 #endif // wxUSE_WCHAR_T
 #ifdef __WXOSX__
     const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLocal ) ); }
 #endif // wxUSE_WCHAR_T
 #ifdef __WXOSX__
     const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLocal ) ); }


@@ -843,13 +903,23 @@ public:
     // from a character
   wxString& operator=(wxChar ch)
     { return (wxString&)wxStringBase::operator=(ch); }
     // from a character
   wxString& operator=(wxChar ch)
     { return (wxString&)wxStringBase::operator=(ch); }

-    // from a C string
+    // from a C string - STL probably will crash on NULL,
+    // so we need to compensate in that case
+#if wxUSE_STL
+  wxString& operator=(const wxChar *psz)
+    { if(psz) wxStringBase::operator=(psz); else Clear(); return *this; }
+#else

   wxString& operator=(const wxChar *psz)
     { return (wxString&)wxStringBase::operator=(psz); }
   wxString& operator=(const wxChar *psz)
     { return (wxString&)wxStringBase::operator=(psz); }

+#endif
+

 #if wxUSE_UNICODE
     // from wxWCharBuffer
   wxString& operator=(const wxWCharBuffer& psz)
     { (void) operator=((const wchar_t *)psz); return *this; }
 #if wxUSE_UNICODE
     // from wxWCharBuffer
   wxString& operator=(const wxWCharBuffer& psz)
     { (void) operator=((const wchar_t *)psz); return *this; }

+    // from C string
+  wxString& operator=(const char* psz)
+    {  return operator=(wxString(psz)); }

 #else // ANSI
     // from another kind of C string
   wxString& operator=(const unsigned char* psz);
 #else // ANSI
     // from another kind of C string
   wxString& operator=(const unsigned char* psz);


@@ -872,7 +942,7 @@ public:
       // string += string
   wxString& operator<<(const wxString& s)
   {
       // string += string
   wxString& operator<<(const wxString& s)
   {

-#if !wxUSE_STL
+#if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL

     wxASSERT_MSG( s.GetStringData()->IsValid(),
                   _T("did you forget to call UngetWriteBuf()?") );
 #endif
     wxASSERT_MSG( s.GetStringData()->IsValid(),
                   _T("did you forget to call UngetWriteBuf()?") );
 #endif


@@ -889,16 +959,24 @@ public:
       // string += buffer (i.e. from wxGetString)
 #if wxUSE_UNICODE
   wxString& operator<<(const wxWCharBuffer& s)
       // string += buffer (i.e. from wxGetString)
 #if wxUSE_UNICODE
   wxString& operator<<(const wxWCharBuffer& s)

-    { (void)operator<<((const wchar_t *)s); return *this; }
-  void operator+=(const wxWCharBuffer& s)
-    { (void)operator<<((const wchar_t *)s); }
+    { return operator<<((const wchar_t *)s); }
+  wxString& operator+=(const wxWCharBuffer& s)
+    { return operator<<((const wchar_t *)s); }

 #else // !wxUSE_UNICODE
   wxString& operator<<(const wxCharBuffer& s)
 #else // !wxUSE_UNICODE
   wxString& operator<<(const wxCharBuffer& s)

-    { (void)operator<<((const char *)s); return *this; }
-  void operator+=(const wxCharBuffer& s)
-    { (void)operator<<((const char *)s); }
+    { return operator<<((const char *)s); }
+  wxString& operator+=(const wxCharBuffer& s)
+    { return operator<<((const char *)s); }

 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 

+#if wxUSE_UNICODE
+    // string += C string in Unicode build (with conversion)
+  wxString& operator<<(const char *s)
+    { return operator<<(wxString(s)); }
+  wxString& operator+=(const char *s)
+    { return operator+=(wxString(s)); }
+#endif // wxUSE_UNICODE
+

     // string += C string
   wxString& Append(const wxString& s)
     {
     // string += C string
   wxString& Append(const wxString& s)
     {


@@ -922,16 +1000,19 @@ public:
     { *this = str + *this; return *this; }
 
     // non-destructive concatenation
     { *this = str + *this; return *this; }
 
     // non-destructive concatenation

-      //
-  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
-      //
+      // two strings
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,
+                                             const wxString& string2);
+      // string with a single char

   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
   friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);

-      //
+      // char with a string

   friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
   friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);

-      //
-  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
-      //
-  friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
+      // string with C string
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string,
+                                             const wxChar *psz);
+      // C string with string
+  friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz,
+                                             const wxString& string);

 
   // stream-like functions
       // insert an int into string
 
   // stream-like functions
       // insert an int into string


@@ -946,6 +1027,20 @@ public:
       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)
     { return (*this) << Format(_T("%lu"), ul); }
       // insert an unsigned long into string
   wxString& operator<<(unsigned long ul)
     { return (*this) << Format(_T("%lu"), ul); }

+#if defined wxLongLong_t && !defined wxLongLongIsLong
+      // insert a long long if they exist and aren't longs
+  wxString& operator<<(wxLongLong_t ll)
+    {
+      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d");
+      return (*this) << Format(fmt, ll);
+    }
+      // insert an unsigned long long
+  wxString& operator<<(wxULongLong_t ull)
+    {
+      const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
+      return (*this) << Format(fmt , ull);
+    }
+#endif

       // insert a float into string
   wxString& operator<<(float f)
     { return (*this) << Format(_T("%f"), f); }
       // insert a float into string
   wxString& operator<<(float f)
     { return (*this) << Format(_T("%f"), f); }


@@ -964,7 +1059,7 @@ public:
     // (if compareWithCase then the case matters)
   bool IsSameAs(const wxChar *psz, bool compareWithCase = true) const
     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
     // (if compareWithCase then the case matters)
   bool IsSameAs(const wxChar *psz, bool compareWithCase = true) const
     { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }

-    // comparison with a signle character: returns true if equal
+    // comparison with a single character: returns true if equal

   bool IsSameAs(wxChar c, bool compareWithCase = true) const
     {
       return (length() == 1) && (compareWithCase ? GetChar(0u) == c
   bool IsSameAs(wxChar c, bool compareWithCase = true) const
     {
       return (length() == 1) && (compareWithCase ? GetChar(0u) == c


@@ -980,10 +1075,14 @@ 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 string starts with prefix and return the rest of the
-      // string in the provided pointer if it is not NULL, otherwise return
-      // false
+      // check if the string starts with the given 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;
   bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;

+      // check if the string ends with the given suffix and return the
+      // beginning of the string before the suffix in the provided pointer if
+      // it is not NULL; otherwise return false
+  bool EndsWith(const wxChar *suffix, wxString *rest = NULL) const;

 
       // get first nCount characters
   wxString Left(size_t nCount) const;
 
       // get first nCount characters
   wxString Left(size_t nCount) const;


@@ -1046,10 +1145,18 @@ public:
     bool ToLong(long *val, int base = 10) const;
         // convert to an unsigned integer
     bool ToULong(unsigned long *val, int base = 10) const;
     bool ToLong(long *val, int base = 10) const;
         // convert to an unsigned integer
     bool ToULong(unsigned long *val, int base = 10) const;

+        // convert to wxLongLong
+#if defined(wxLongLong_t)
+    bool ToLongLong(wxLongLong_t *val, int base = 10) const;
+        // convert to wxULongLong
+    bool ToULongLong(wxULongLong_t *val, int base = 10) const;
+#endif // wxLongLong_t

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

-  // formated input/output
+
+
+  // formatted input/output

     // as sprintf(), returns the number of characters written or < 0 on error
     // (take 'this' into account in attribute parameter count)
   int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
     // as sprintf(), returns the number of characters written or < 0 on error
     // (take 'this' into account in attribute parameter count)
   int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;


@@ -1068,14 +1175,16 @@ public:
     // minimize the string's memory
     // only works if the data of this string is not shared
   bool Shrink();
     // minimize the string's memory
     // only works if the data of this string is not shared
   bool Shrink();

-#if !wxUSE_STL
+#if WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL
+    // These are deprecated, use wxStringBuffer or wxStringBufferLength instead
+    //

     // get writable buffer of at least nLen bytes. Unget() *must* be called
     // a.s.a.p. to put string back in a reasonable state!
     // get writable buffer of at least nLen bytes. Unget() *must* be called
     // a.s.a.p. to put string back in a reasonable state!

-  wxChar *GetWriteBuf(size_t nLen);
+  wxDEPRECATED( wxChar *GetWriteBuf(size_t nLen) );

     // call this immediately after GetWriteBuf() has been used
     // call this immediately after GetWriteBuf() has been used

-  void UngetWriteBuf();
-  void UngetWriteBuf(size_t nLen);
-#endif
+  wxDEPRECATED( void UngetWriteBuf() );
+  wxDEPRECATED( void UngetWriteBuf(size_t nLen) );
+#endif // WXWIN_COMPATIBILITY_2_8 && !wxUSE_STL

 
   // wxWidgets version 1 compatibility functions
 
 
   // wxWidgets version 1 compatibility functions
 


@@ -1177,7 +1286,7 @@ public:
     { return (wxString&)wxStringBase::assign(first, last); }
 
     // string comparison
     { return (wxString&)wxStringBase::assign(first, last); }
 
     // string comparison

-#ifndef HAVE_STD_STRING_COMPARE
+#if !defined(HAVE_STD_STRING_COMPARE)

   int compare(const wxStringBase& str) const;
     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
   int compare(const wxStringBase& str) const;
     // comparison with a substring
   int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;


@@ -1264,12 +1373,29 @@ public:
       // string += char
   wxString& operator+=(wxChar ch)
     { return (wxString&)wxStringBase::operator+=(ch); }
       // string += char
   wxString& operator+=(wxChar ch)
     { return (wxString&)wxStringBase::operator+=(ch); }

-};

 
 

-// define wxArrayString, for compatibility
-#if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL
-    #include "wx/arrstr.h"
+private:
+#if !wxUSE_STL
+  // helpers for wxStringBuffer and wxStringBufferLength
+  wxChar *DoGetWriteBuf(size_t nLen);
+  void DoUngetWriteBuf();
+  void DoUngetWriteBuf(size_t nLen);
+
+  friend class WXDLLIMPEXP_BASE wxStringBuffer;
+  friend class WXDLLIMPEXP_BASE wxStringBufferLength;

 #endif
 #endif

+};
+
+// notice that even though for many compilers the friend declarations above are
+// enough, from the point of view of C++ standard we must have the declarations
+// here as friend ones are not injected in the enclosing namespace and without
+// them the code fails to compile with conforming compilers such as xlC or g++4
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
+wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
+wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
+

 
 #if wxUSE_STL
     // return an empty wxString (not very useful with wxUSE_STL == 1)
 
 #if wxUSE_STL
     // return an empty wxString (not very useful with wxUSE_STL == 1)


@@ -1346,9 +1472,9 @@ class WXDLLIMPEXP_BASE wxStringBuffer
 public:
     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(NULL)
 public:
     wxStringBuffer(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(NULL)

-        { m_buf = m_str.GetWriteBuf(lenWanted); }
+        { m_buf = m_str.DoGetWriteBuf(lenWanted); }

 
 

-    ~wxStringBuffer() { m_str.UngetWriteBuf(); }
+    ~wxStringBuffer() { m_str.DoUngetWriteBuf(); }

 
     operator wxChar*() const { return m_buf; }
 
 
     operator wxChar*() const { return m_buf; }
 


@@ -1365,14 +1491,14 @@ public:
     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
     {
     wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
     {

-        m_buf = m_str.GetWriteBuf(lenWanted);
+        m_buf = m_str.DoGetWriteBuf(lenWanted);

         wxASSERT(m_buf != NULL);
     }
 
     ~wxStringBufferLength()
     {
         wxASSERT(m_lenSet);
         wxASSERT(m_buf != NULL);
     }
 
     ~wxStringBufferLength()
     {
         wxASSERT(m_lenSet);

-        m_str.UngetWriteBuf(m_len);
+        m_str.DoUngetWriteBuf(m_len);

     }
 
     operator wxChar*() const { return m_buf; }
     }
 
     operator wxChar*() const { return m_buf; }


@@ -1455,12 +1581,6 @@ inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
     { return (s2.Cmp((const char *)s1) != 0); }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 
     { return (s2.Cmp((const char *)s1) != 0); }
 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
 

-wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,  const wxString& string2);
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
-wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
-wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
-

 #if wxUSE_UNICODE
 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
     { return string + (const wchar_t *)buf; }
 #if wxUSE_UNICODE
 inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
     { return string + (const wchar_t *)buf; }


@@ -1482,6 +1602,34 @@ inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
 inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
 inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
 
 inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
 inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
 

+// comparison with C string in Unicode build
+#if wxUSE_UNICODE
+inline bool operator==(const wxString& s1, const char* s2)
+    { return s1 == wxString(s2); }
+inline bool operator==(const char* s1, const wxString& s2)
+    { return wxString(s1) == s2; }
+inline bool operator!=(const wxString& s1, const char* s2)
+    { return s1 != wxString(s2); }
+inline bool operator!=(const char* s1, const wxString& s2)
+    { return wxString(s1) != s2; }
+inline bool operator< (const wxString& s1, const char* s2)
+    { return s1 < wxString(s2); }
+inline bool operator< (const char* s1, const wxString& s2)
+    { return wxString(s1) < s2; }
+inline bool operator> (const wxString& s1, const char* s2)
+    { return s1 > wxString(s2); }
+inline bool operator> (const char* s1, const wxString& s2)
+    { return wxString(s1) > s2; }
+inline bool operator<=(const wxString& s1, const char* s2)
+    { return s1 <= wxString(s2); }
+inline bool operator<=(const char* s1, const wxString& s2)
+    { return wxString(s1) <= s2; }
+inline bool operator>=(const wxString& s1, const char* s2)
+    { return s1 >= wxString(s2); }
+inline bool operator>=(const char* s1, const wxString& s2)
+    { return wxString(s1) >= s2; }
+#endif // wxUSE_UNICODE
+

 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Implementation only from here until the end of file
 // ---------------------------------------------------------------------------


@@ -1493,7 +1641,6 @@ inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
 
 #include "wx/iosfwrap.h"
 
 
 #include "wx/iosfwrap.h"
 

-WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);

 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
 
 #endif  // wxSTD_STRING_COMPATIBILITY
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
 
 #endif  // wxSTD_STRING_COMPATIBILITY