Big wxGL classes refactoring/cleanup:

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

diff --git a/include/wx/string.h b/include/wx/string.h
index e0f58918e884a80309cdd84ee0692b3688a66243..3cb68a0df4ae5b22893537a6d9f8f1cdf31e06dc 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -169,7 +169,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
 
 // Lightweight object returned by wxString::c_str() and implicitly convertible
 // to either const char* or const wchar_t*.
 
 // Lightweight object returned by wxString::c_str() and implicitly convertible
 // to either const char* or const wchar_t*.

-class wxCStrData
+class WXDLLIMPEXP_BASE wxCStrData

 {
 private:
     // Ctors; for internal use by wxString and wxCStrData only
 {
 private:
     // Ctors; for internal use by wxString and wxCStrData only


@@ -182,29 +182,35 @@ public:
     wxCStrData(char *buf);
     wxCStrData(wchar_t *buf);
 
     wxCStrData(char *buf);
     wxCStrData(wchar_t *buf);
 

-    ~wxCStrData();
+    inline ~wxCStrData();

 
 

-    // FIXME: we'll need convertors for both char* and wchar_t* and NONE
-    //        for wxChar*, but that's after completing the transition to
-    //        "smart" wxUniChar class. For now, just have conversion to
-    //        char* in ANSI build and wchar_t in Unicode build.
-#if wxUSE_UNICODE
+    // methods defined inline below must be declared inline or mingw32 3.4.5
+    // warns about "<symbol> defined locally after being referenced with
+    // dllimport linkage"
+#if wxUSE_UNICODE_WCHAR
+    inline
+#endif

     const wchar_t* AsWChar() const;
     operator const wchar_t*() const { return AsWChar(); }
     const wchar_t* AsWChar() const;
     operator const wchar_t*() const { return AsWChar(); }

-#else
+
+    inline operator bool() const;
+
+#if !wxUSE_UNICODE
+    inline
+#endif

     const char* AsChar() const;
     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }
     const char* AsChar() const;
     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }

-    operator const void*() const { return AsChar(); }

     operator const char*() const { return AsChar(); }
     operator const unsigned char*() const { return AsUnsignedChar(); }
     operator const char*() const { return AsChar(); }
     operator const unsigned char*() const { return AsUnsignedChar(); }

-#endif

 
 

-    wxString AsString() const;
+    operator const void*() const { return AsChar(); }
+
+    inline wxString AsString() const;

 
     // allow expressions like "c_str()[0]":
 
     // allow expressions like "c_str()[0]":

+    inline wxUniChar operator[](size_t n) const;

     wxUniChar operator[](int n) const { return operator[](size_t(n)); }
     wxUniChar operator[](int n) const { return operator[](size_t(n)); }

-    wxUniChar operator[](size_t n) const;

     wxUniChar operator[](long n) const { return operator[](size_t(n)); }
 #ifndef wxSIZE_T_IS_UINT
     wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }
     wxUniChar operator[](long n) const { return operator[](size_t(n)); }
 #ifndef wxSIZE_T_IS_UINT
     wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }


@@ -242,7 +248,7 @@ public:
 
     // this operator is needed to make expressions like "*c_str()" or
     // "*(c_str() + 2)" work
 
     // this operator is needed to make expressions like "*c_str()" or
     // "*(c_str() + 2)" work

-    wxUniChar operator*() const;
+    inline wxUniChar operator*() const;

 
 private:
     const wxString *m_str;
 
 private:
     const wxString *m_str;


@@ -399,18 +405,22 @@ private:
   // returns C string encoded as the implementation expects:
   #if wxUSE_UNICODE
   static const wchar_t* ImplStr(const wchar_t* str)
   // returns C string encoded as the implementation expects:
   #if wxUSE_UNICODE
   static const wchar_t* ImplStr(const wchar_t* str)

-    { return str; }
+    { return str ? str : wxT(""); }

   static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
   static const SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)

-    { return SubstrBufFromWC(str, n == npos ? wxWcslen(str) : n); }
-  static wxWCharBuffer ImplStr(const char* str)
-    { return ConvertStr(str, npos, wxConvLibc).data; }
-  static SubstrBufFromMB ImplStr(const char* str, size_t n)
-    { return ConvertStr(str, n, wxConvLibc); }
+    { return SubstrBufFromWC(str, (str && n == npos) ? wxWcslen(str) : n); }
+  static wxWCharBuffer ImplStr(const char* str,
+                               const wxMBConv& conv = wxConvLibc)
+    { return ConvertStr(str, npos, conv).data; }
+  static SubstrBufFromMB ImplStr(const char* str, size_t n,
+                                 const wxMBConv& conv = wxConvLibc)
+    { return ConvertStr(str, n, conv); }

   #else
   #else

-  static const char* ImplStr(const char* str)
-    { return str; }
-  static const SubstrBufFromMB ImplStr(const char* str, size_t n)
-    { return SubstrBufFromMB(str, n == npos ? wxStrlen(str) : n); }
+  static const char* ImplStr(const char* str,
+                             const wxMBConv& WXUNUSED(conv) = wxConvLibc)
+    { return str ? str : ""; }
+  static const SubstrBufFromMB ImplStr(const char* str, size_t n,
+                                       const wxMBConv& WXUNUSED(conv) = wxConvLibc)
+    { return SubstrBufFromMB(str, (str && n == npos) ? wxStrlen(str) : n); }

   static wxCharBuffer ImplStr(const wchar_t* str)
     { return ConvertStr(str, npos, wxConvLibc).data; }
   static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
   static wxCharBuffer ImplStr(const wchar_t* str)
     { return ConvertStr(str, npos, wxConvLibc).data; }
   static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)


@@ -444,6 +454,7 @@ private:
   static void PosLenToImpl(size_t pos, size_t len,
                            size_t *implPos, size_t *implLen)
     { *implPos = pos; *implLen = len; }
   static void PosLenToImpl(size_t pos, size_t len,
                            size_t *implPos, size_t *implLen)
     { *implPos = pos; *implLen = len; }

+  static size_t LenToImpl(size_t len) { return len; }

   static size_t PosFromImpl(size_t pos) { return pos; }
 
 #else // wxUSE_UNICODE_UTF8
   static size_t PosFromImpl(size_t pos) { return pos; }
 
 #else // wxUSE_UNICODE_UTF8


@@ -483,78 +494,69 @@ public:
   // constructors and destructor
     // ctor for an empty string
   wxString() {}
   // constructors and destructor
     // ctor for an empty string
   wxString() {}

+

     // copy ctor
   wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { }
     // copy ctor
   wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { }

-  wxString(const wxString& stringSrc) : m_impl(stringSrc) { }
+  wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { }
+

     // string containing nRepeat copies of ch
   wxString(wxUniChar ch, size_t nRepeat = 1)
     // string containing nRepeat copies of ch
   wxString(wxUniChar ch, size_t nRepeat = 1)

-      : m_impl(nRepeat, ch) { }
+    { assign(nRepeat, ch); }

   wxString(size_t nRepeat, wxUniChar ch)
   wxString(size_t nRepeat, wxUniChar ch)

-      : m_impl(nRepeat, ch) { }
+    { assign(nRepeat, ch); }

   wxString(wxUniCharRef ch, size_t nRepeat = 1)
   wxString(wxUniCharRef ch, size_t nRepeat = 1)

-      : m_impl(nRepeat, ch) { }
+    { assign(nRepeat, ch); }

   wxString(size_t nRepeat, wxUniCharRef ch)
   wxString(size_t nRepeat, wxUniCharRef ch)

-      : m_impl(nRepeat, ch) { }
+    { assign(nRepeat, ch); }

   wxString(char ch, size_t nRepeat = 1)
   wxString(char ch, size_t nRepeat = 1)

-      : m_impl(nRepeat, ch) { }
+    { assign(nRepeat, ch); }

   wxString(size_t nRepeat, char ch)
   wxString(size_t nRepeat, char ch)

-      : m_impl(nRepeat, ch) { }
+    { assign(nRepeat, ch); }

   wxString(wchar_t ch, size_t nRepeat = 1)
   wxString(wchar_t ch, size_t nRepeat = 1)

-      : m_impl(nRepeat, ch) { }
+    { assign(nRepeat, ch); }

   wxString(size_t nRepeat, wchar_t ch)
   wxString(size_t nRepeat, wchar_t ch)

-      : m_impl(nRepeat, ch) { }
-    // ctor takes first nLength characters from C string
-    // (default value of npos means take all the string)
-  wxString(const wxChar *psz)
-      : m_impl(psz ? psz : wxT("")) { }
-  wxString(const wxChar *psz, size_t nLength)
-      : m_impl(psz, nLength) { }
-  wxString(const wxChar *psz,
-           const wxMBConv& WXUNUSED(conv),
-           size_t nLength = npos)
-      : m_impl(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
-
-  // 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
-#if wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING
-  wxString(const wxStdString& s)
-      : m_impl(s.c_str()) { } // FIXME-UTF8: this is broken for embedded 0s
-#endif // wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING
-
-#if wxUSE_UNICODE
-    // from multibyte string
-  wxString(const char *psz,
-           const wxMBConv& conv = wxConvLibc,
-           size_t nLength = npos);
-    // from multibyte string for ANSI compatibility, with wxConvLibc
-  wxString(const char *psz, size_t nLength);
-    // from wxWCharBuffer (i.e. return from wxGetString)
-  wxString(const wxWCharBuffer& psz) : m_impl(psz.data()) { }
-#else // ANSI
-    // from C string (for compilers using unsigned char)
-  wxString(const unsigned char* psz)
-      : m_impl((const char*)psz) { }
-    // from part of C string (for compilers using unsigned char)
-  wxString(const unsigned char* psz, size_t nLength)
-      : m_impl((const char*)psz, nLength) { }
+    { assign(nRepeat, ch); }
+
+    // ctors from char* strings:
+  wxString(const char *psz)
+    : m_impl(ImplStr(psz)) {}
+  wxString(const char *psz, const wxMBConv& conv)
+    : m_impl(ImplStr(psz, conv)) {}
+  wxString(const char *psz, size_t nLength)
+    { assign(psz, nLength); }
+  wxString(const char *psz, const wxMBConv& conv, size_t nLength)
+  {
+    SubstrBufFromMB str(ImplStr(psz, nLength, conv));
+    m_impl.assign(str.data, str.len);
+  }

 
 

-#if wxUSE_WCHAR_T
-    // from wide (Unicode) string
-  wxString(const wchar_t *pwz,
-           const wxMBConv& conv = wxConvLibc,
-           size_t nLength = npos);
-    // from wide string for Unicode compatibility, with wxConvLibc
-  wxString(const wchar_t *pwz, size_t nLength);
-#endif // !wxUSE_WCHAR_T
+    // and unsigned char*:
+  wxString(const unsigned char *psz)
+    : m_impl(ImplStr((const char*)psz)) {}
+  wxString(const unsigned char *psz, const wxMBConv& conv)
+    : m_impl(ImplStr((const char*)psz, conv)) {}
+  wxString(const unsigned char *psz, size_t nLength)
+    { assign((const char*)psz, nLength); }
+  wxString(const unsigned char *psz, const wxMBConv& conv, size_t nLength)
+  {
+    SubstrBufFromMB str(ImplStr((const char*)psz, nLength, conv));
+    m_impl.assign(str.data, str.len);
+  }

 
 

-    // from wxCharBuffer
-  wxString(const wxCharBuffer& psz)
-      : m_impl(psz) { }
-#endif // Unicode/ANSI
+    // ctors from wchar_t* strings:
+  wxString(const wchar_t *pwz)
+    : m_impl(ImplStr(pwz)) {}
+  wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv))
+    : m_impl(ImplStr(pwz)) {}
+  wxString(const wchar_t *pwz, size_t nLength)
+    { assign(pwz, nLength); }
+  wxString(const wchar_t *pwz, const wxMBConv& WXUNUSED(conv), size_t nLength)
+    { assign(pwz, nLength); }
+
+  wxString(const wxCharBuffer& buf)
+    { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
+  wxString(const wxWCharBuffer& buf)
+    { assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length

 
   wxString(const wxCStrData& cstr)
       : m_impl(cstr.AsString().m_impl) { }
 
   wxString(const wxCStrData& cstr)
       : m_impl(cstr.AsString().m_impl) { }


@@ -562,12 +564,12 @@ public:
     // as we provide both ctors with this signature for both char and unsigned
     // char string, we need to provide one for wxCStrData to resolve ambiguity
   wxString(const wxCStrData& cstr, size_t nLength)
     // as we provide both ctors with this signature for both char and unsigned
     // char string, we need to provide one for wxCStrData to resolve ambiguity
   wxString(const wxCStrData& cstr, size_t nLength)

-    { assign(cstr.AsString(), nLength); }
+      : m_impl(cstr.AsString().Mid(0, nLength).m_impl) {}

 
     // and because wxString is convertible to wxCStrData and const wxChar *
     // we also need to provide this one
   wxString(const wxString& str, size_t nLength)
 
     // and because wxString is convertible to wxCStrData and const wxChar *
     // we also need to provide this one
   wxString(const wxString& str, size_t nLength)

-    { assign(str, nLength); }
+      : m_impl(str.Mid(0, nLength).m_impl) {}

 
 public:
   // standard types
 
 public:
   // standard types


@@ -627,19 +629,19 @@ public:
             { return iterator_name(wxString::AddToIter(m_cur, -n)); }       \
           iterator_name operator-(size_t n) const                           \
             { return iterator_name(wxString::AddToIter(m_cur, -(int)n)); }  \
             { return iterator_name(wxString::AddToIter(m_cur, -n)); }       \
           iterator_name operator-(size_t n) const                           \
             { return iterator_name(wxString::AddToIter(m_cur, -(int)n)); }  \

-          iterator_name operator+=(int n)                                   \
+          iterator_name& operator+=(int n)                                  \

             { m_cur = wxString::AddToIter(m_cur, n); return *this; }        \
             { m_cur = wxString::AddToIter(m_cur, n); return *this; }        \

-          iterator_name operator+=(size_t n)                                \
+          iterator_name& operator+=(size_t n)                               \

             { m_cur = wxString::AddToIter(m_cur, (int)n); return *this; }   \
             { m_cur = wxString::AddToIter(m_cur, (int)n); return *this; }   \

-          iterator_name operator-=(int n)                                   \
+          iterator_name& operator-=(int n)                                  \

             { m_cur = wxString::AddToIter(m_cur, -n); return *this; }       \
             { m_cur = wxString::AddToIter(m_cur, -n); return *this; }       \

-          iterator_name operator-=(size_t n)                                \
+          iterator_name& operator-=(size_t n)                               \

             { m_cur = wxString::AddToIter(m_cur, -(int)n); return *this; }  \
                                                                             \
             { m_cur = wxString::AddToIter(m_cur, -(int)n); return *this; }  \
                                                                             \

-          unsigned operator-(const iterator_name& i) const                  \
+          difference_type operator-(const iterator_name& i) const           \

             { return wxString::DiffIters(m_cur, i.m_cur); }                 \
                                                                             \
             { return wxString::DiffIters(m_cur, i.m_cur); }                 \
                                                                             \

-          bool operator==(const iterator_name&i) const                      \
+          bool operator==(const iterator_name& i) const                     \

             { return m_cur == i.m_cur; }                                    \
           bool operator!=(const iterator_name& i) const                     \
             { return m_cur != i.m_cur; }                                    \
             { return m_cur == i.m_cur; }                                    \
           bool operator!=(const iterator_name& i) const                     \
             { return m_cur != i.m_cur; }                                    \


@@ -662,14 +664,14 @@ public:
           friend class WXDLLIMPEXP_BASE wxCStrData;                         \
                                                                             \
       private:                                                              \
           friend class WXDLLIMPEXP_BASE wxCStrData;                         \
                                                                             \
       private:                                                              \

-          underlying_iterator m_cur;
+          underlying_iterator m_cur

 
   class const_iterator;
 
   class iterator
   {
       WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,
 
   class const_iterator;
 
   class iterator
   {
       WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,

-                           wxUniCharRef::CreateForString(m_cur))
+                           wxUniCharRef::CreateForString(m_cur));

 
       friend class const_iterator;
   };
 
       friend class const_iterator;
   };


@@ -679,7 +681,7 @@ public:
       // NB: reference_type is intentionally value, not reference, the character
       //     may be encoded differently in wxString data:
       WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar,
       // NB: reference_type is intentionally value, not reference, the character
       //     may be encoded differently in wxString data:
       WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar,

-                           wxUniChar(*m_cur))
+                           wxUniChar(*m_cur));

 
   public:
       const_iterator(const iterator& i) : m_cur(i.m_cur) {}
 
   public:
       const_iterator(const iterator& i) : m_cur(i.m_cur) {}


@@ -721,14 +723,15 @@ public:
       reverse_iterator_impl operator--(int)
         { reverse_iterator_impl tmp = *this; ++m_cur; return tmp; }
 
       reverse_iterator_impl operator--(int)
         { reverse_iterator_impl tmp = *this; ++m_cur; return tmp; }
 

+      // NB: explicit <T> in the functions below is to keep BCC 5.5 happy

       reverse_iterator_impl operator+(int n) const
       reverse_iterator_impl operator+(int n) const

-        { return reverse_iterator_impl(m_cur - n); }
+        { return reverse_iterator_impl<T>(m_cur - n); }

       reverse_iterator_impl operator+(size_t n) const
       reverse_iterator_impl operator+(size_t n) const

-        { return reverse_iterator_impl(m_cur - n); }
+        { return reverse_iterator_impl<T>(m_cur - n); }

       reverse_iterator_impl operator-(int n) const
       reverse_iterator_impl operator-(int n) const

-        { return reverse_iterator_impl(m_cur + n); }
+        { return reverse_iterator_impl<T>(m_cur + n); }

       reverse_iterator_impl operator-(size_t n) const
       reverse_iterator_impl operator-(size_t n) const

-        { return reverse_iterator_impl(m_cur + n); }
+        { return reverse_iterator_impl<T>(m_cur + n); }

       reverse_iterator_impl operator+=(int n)
         { m_cur -= n; return *this; }
       reverse_iterator_impl operator+=(size_t n)
       reverse_iterator_impl operator+=(int n)
         { m_cur -= n; return *this; }
       reverse_iterator_impl operator+=(size_t n)


@@ -914,7 +917,8 @@ public:
 
     // implicit conversion to C string
     operator wxCStrData() const { return c_str(); }
 
     // implicit conversion to C string
     operator wxCStrData() const { return c_str(); }

-    operator const wxChar*() const { return c_str(); }
+    operator const char*() const { return c_str(); }
+    operator const wchar_t*() const { return c_str(); }

 
     // identical to c_str(), for MFC compatibility
     const wxCStrData GetData() const { return c_str(); }
 
     // identical to c_str(), for MFC compatibility
     const wxCStrData GetData() const { return c_str(); }


@@ -923,6 +927,12 @@ public:
     // wchar_t*, UTF-8-encoded char*, depending on the build):
     const_pointer wx_str() const { return m_impl.c_str(); }
 
     // wchar_t*, UTF-8-encoded char*, depending on the build):
     const_pointer wx_str() const { return m_impl.c_str(); }
 

+    // conversion to *non-const* multibyte or widestring buffer; modifying
+    // returned buffer won't affect the string, these methods are only useful
+    // for passing values to const-incorrect functions
+    wxWritableCharBuffer char_str() const { return mb_str(); }
+    wxWritableWCharBuffer wchar_str() const { return wc_str(); }
+

     // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
     // converting numbers or strings which are certain not to contain special
     // chars (typically system functions, X atoms, environment variables etc.)
     // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
     // converting numbers or strings which are certain not to contain special
     // chars (typically system functions, X atoms, environment variables etc.)


@@ -972,7 +982,7 @@ public:
     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(const wxMBConv& conv) const;
+    const wxWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) 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 ) ); }


@@ -983,8 +993,8 @@ public:
 
   // overloaded assignment
     // from another wxString
 
   // overloaded assignment
     // from another wxString

-  wxString& operator=(const wxStringImpl& stringSrc)
-    { m_impl = stringSrc; return *this; }
+  wxString& operator=(const wxString& stringSrc)
+    { m_impl = stringSrc.m_impl; return *this; }

   wxString& operator=(const wxCStrData& cstr)
     { return *this = cstr.AsString(); }
     // from a character
   wxString& operator=(const wxCStrData& cstr)
     { return *this = cstr.AsString(); }
     // from a character


@@ -994,36 +1004,32 @@ public:
     { return operator=((wxUniChar)ch); }
   wxString& operator=(char ch)
     { return operator=(wxUniChar(ch)); }
     { return operator=((wxUniChar)ch); }
   wxString& operator=(char ch)
     { return operator=(wxUniChar(ch)); }

+  wxString& operator=(unsigned char ch)
+    { return operator=(wxUniChar(ch)); }

   wxString& operator=(wchar_t ch)
     { return operator=(wxUniChar(ch)); }
     // from a C string - STL probably will crash on NULL,
     // so we need to compensate in that case
 #if wxUSE_STL_BASED_WXSTRING
   wxString& operator=(wchar_t ch)
     { return operator=(wxUniChar(ch)); }
     // from a C string - STL probably will crash on NULL,
     // so we need to compensate in that case
 #if wxUSE_STL_BASED_WXSTRING

-  wxString& operator=(const wxChar *psz)
-    { if(psz) m_impl = psz; else Clear(); return *this; }
+  wxString& operator=(const char *psz)
+    { if (psz) m_impl = ImplStr(psz); else Clear(); return *this; }
+  wxString& operator=(const wchar_t *pwz)
+    { if (pwz) m_impl = ImplStr(pwz); else Clear(); return *this; }

 #else
 #else

-  wxString& operator=(const wxChar *psz)
-    { m_impl = psz; return *this; }
+  wxString& operator=(const char *psz)
+    { m_impl = ImplStr(psz); return *this; }
+  wxString& operator=(const wchar_t *pwz)
+    { m_impl = ImplStr(pwz); return *this; }

 #endif
 #endif

+  wxString& operator=(const unsigned char *psz)
+    { return operator=((const char*)psz); }

 
 

-#if wxUSE_UNICODE

     // from wxWCharBuffer
   wxString& operator=(const wxWCharBuffer& s)
     // from wxWCharBuffer
   wxString& operator=(const wxWCharBuffer& s)

-    { (void) operator=((const wchar_t *)s); 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);
-#if wxUSE_WCHAR_T
-    // from a wide string
-  wxString& operator=(const wchar_t *pwz);
-#endif
+    { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs

     // from wxCharBuffer
     // from wxCharBuffer

-  wxString& operator=(const wxCharBuffer& psz)
-    { (void) operator=((const char *)psz); return *this; }
-#endif // Unicode/ANSI
+  wxString& operator=(const wxCharBuffer& s)
+    { return operator=(s.data()); } // FIXME-UTF8: fix for embedded NULs

 
   // string concatenation
     // in place concatenation
 
   // string concatenation
     // in place concatenation


@@ -1054,6 +1060,7 @@ public:
   wxString& operator<<(wxUniChar ch) { append(1, ch); return *this; }
   wxString& operator<<(wxUniCharRef ch) { append(1, ch); return *this; }
   wxString& operator<<(char ch) { append(1, ch); return *this; }
   wxString& operator<<(wxUniChar ch) { append(1, ch); return *this; }
   wxString& operator<<(wxUniCharRef ch) { append(1, ch); return *this; }
   wxString& operator<<(char ch) { append(1, ch); return *this; }

+  wxString& operator<<(unsigned char ch) { append(1, ch); return *this; }

   wxString& operator<<(wchar_t ch) { append(1, ch); return *this; }
 
       // string += buffer (i.e. from wxGetString)
   wxString& operator<<(wchar_t ch) { append(1, ch); return *this; }
 
       // string += buffer (i.e. from wxGetString)


@@ -1090,6 +1097,8 @@ public:
     { append(count, ch); return *this; }
   wxString& Append(char ch, size_t count = 1u)
     { append(count, ch); return *this; }
     { append(count, ch); return *this; }
   wxString& Append(char ch, size_t count = 1u)
     { append(count, ch); return *this; }

+  wxString& Append(unsigned char ch, size_t count = 1u)
+    { append(count, ch); return *this; }

   wxString& Append(wchar_t ch, size_t count = 1u)
     { append(count, ch); return *this; }
   wxString& Append(const char* psz, size_t nLen)
   wxString& Append(wchar_t ch, size_t count = 1u)
     { append(count, ch); return *this; }
   wxString& Append(const char* psz, size_t nLen)


@@ -1170,16 +1179,29 @@ public:
     { return CmpNoCase(wxString(pwz)); }
     // test for the string equality, either considering case or not
     // (if compareWithCase then the case matters)
     { return CmpNoCase(wxString(pwz)); }
     // test for the string equality, either considering case or not
     // (if compareWithCase then the case matters)

-  bool IsSameAs(const char *psz, bool compareWithCase = true) const
-    { return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
-  bool IsSameAs(const wchar_t *pwz, bool compareWithCase = true) const
-    { return (compareWithCase ? Cmp(pwz) : CmpNoCase(pwz)) == 0; }
+  bool IsSameAs(const wxString& str, bool compareWithCase = true) const
+    { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; }
+  bool IsSameAs(const char *str, bool compareWithCase = true) const
+    { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; }
+  bool IsSameAs(const wchar_t *str, bool compareWithCase = true) const
+    { return (compareWithCase ? Cmp(str) : CmpNoCase(str)) == 0; }

     // comparison with a single character: returns true if equal
   bool IsSameAs(wxUniChar c, bool compareWithCase = true) const
     {
       return (length() == 1) && (compareWithCase ? GetChar(0u) == c
                               : wxToupper(GetChar(0u)) == wxToupper(c));
     }
     // comparison with a single character: returns true if equal
   bool IsSameAs(wxUniChar c, bool compareWithCase = true) const
     {
       return (length() == 1) && (compareWithCase ? GetChar(0u) == c
                               : wxToupper(GetChar(0u)) == wxToupper(c));
     }

+  // FIXME-UTF8: remove these overloads
+  bool IsSameAs(wxUniCharRef c, bool compareWithCase = true) const
+    { return IsSameAs(wxUniChar(c), compareWithCase); }
+  bool IsSameAs(char c, bool compareWithCase = true) const
+    { return IsSameAs(wxUniChar(c), compareWithCase); }
+  bool IsSameAs(unsigned char c, bool compareWithCase = true) const
+    { return IsSameAs(wxUniChar(c), compareWithCase); }
+  bool IsSameAs(wchar_t c, bool compareWithCase = true) const
+    { return IsSameAs(wxUniChar(c), compareWithCase); }
+  bool IsSameAs(int c, bool compareWithCase = true) const
+    { return IsSameAs(wxUniChar(c), compareWithCase); }

 
   // simple sub-string extraction
       // return substring starting at nFirst of length nCount (or till the end
 
   // simple sub-string extraction
       // return substring starting at nFirst of length nCount (or till the end


@@ -1240,16 +1262,40 @@ public:
   // searching and replacing
       // searching (return starting index, or -1 if not found)
   int Find(wxUniChar ch, bool bFromEnd = false) const;   // like strchr/strrchr
   // searching and replacing
       // searching (return starting index, or -1 if not found)
   int Find(wxUniChar ch, bool bFromEnd = false) const;   // like strchr/strrchr

+  int Find(wxUniCharRef ch, bool bFromEnd = false) const
+    { return Find(wxUniChar(ch), bFromEnd); }
+  int Find(char ch, bool bFromEnd = false) const
+    { return Find(wxUniChar(ch), bFromEnd); }
+  int Find(unsigned char ch, bool bFromEnd = false) const
+    { return Find(wxUniChar(ch), bFromEnd); }
+  int Find(wchar_t ch, bool bFromEnd = false) const
+    { return Find(wxUniChar(ch), bFromEnd); }

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

-  int Find(const wxChar *pszSub) const;               // like strstr
+  // FIXME-UTF8: keep wxString overload only
+  int Find(const wxString& sub) const               // like strstr
+  {
+    size_type idx = find(sub);
+    return (idx == npos) ? wxNOT_FOUND : (int)idx;
+  }
+  int Find(const char *sub) const               // like strstr
+  {
+    size_type idx = find(sub);
+    return (idx == npos) ? wxNOT_FOUND : (int)idx;
+  }
+  int Find(const wchar_t *sub) const               // like strstr
+  {
+    size_type idx = find(sub);
+    return (idx == npos) ? wxNOT_FOUND : (int)idx;
+  }
+

       // replace first (or all of bReplaceAll) occurences of substring with
       // another string, returns the number of replacements made
       // replace first (or all of bReplaceAll) occurences of substring with
       // another string, returns the number of replacements made

-  size_t Replace(const wxChar *szOld,
-                 const wxChar *szNew,
+  size_t Replace(const wxString& strOld,
+                 const wxString& strNew,

                  bool bReplaceAll = true);
 
     // check if the string contents matches a mask containing '*' and '?'
                  bool bReplaceAll = true);
 
     // check if the string contents matches a mask containing '*' and '?'

-  bool Matches(const wxChar *szMask) const;
+  bool Matches(const wxString& mask) 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
 
     // 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


@@ -1350,10 +1396,12 @@ public:
 
     // use Find()
   int First( wxUniChar ch ) const { return Find(ch); }
 
     // use Find()
   int First( wxUniChar ch ) const { return Find(ch); }

+  int First( wxUniCharRef ch ) const { return Find(ch); }

   int First( char ch ) const { return Find(ch); }
   int First( char ch ) const { return Find(ch); }

+  int First( unsigned char ch ) const { return Find(ch); }

   int First( wchar_t ch ) const { return Find(ch); }
   int First( const wxChar* psz ) const { return Find(psz); }
   int First( wchar_t ch ) const { return Find(ch); }
   int First( const wxChar* psz ) const { return Find(psz); }

-  int First( const wxString &str ) const { return Find(str); }
+  int First( const wxString& str ) const { return Find(str); }

   int Last( wxUniChar ch ) const { return Find(ch, true); }
   bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; }
 
   int Last( wxUniChar ch ) const { return Find(ch, true); }
   bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; }
 


@@ -1365,13 +1413,19 @@ public:
     // take nLen chars starting at nPos
   wxString(const wxString& str, size_t nPos, size_t nLen)
       : m_impl(str.m_impl, nPos, nLen) { }
     // take nLen chars starting at nPos
   wxString(const wxString& str, size_t nPos, size_t nLen)
       : m_impl(str.m_impl, nPos, nLen) { }

-    // take all characters from pStart to pEnd
-  wxString(const void *pStart, const void *pEnd)
-      : m_impl((const wxChar*)pStart, (const wxChar*)pEnd) { }
+    // take all characters from first to last

   wxString(const_iterator first, const_iterator last)
       : m_impl(first, last) { }
   wxString(const_iterator first, const_iterator last)
       : m_impl(first, last) { }

-  wxString(iterator first, iterator last)
-      : m_impl(first, last) { }
+  wxString(const char *first, const char *last)
+  {
+      SubstrBufFromMB str(ImplStr(first, last - first));
+      m_impl.assign(str.data, str.len);
+  }
+  wxString(const wchar_t *first, const wchar_t *last)
+  {
+      SubstrBufFromWC str(ImplStr(first, last - first));
+      m_impl.assign(str.data, str.len);
+  }

 
   // lib.string.modifiers
     // append elements str[pos], ..., str[pos+n]
 
   // lib.string.modifiers
     // append elements str[pos], ..., str[pos+n]


@@ -1418,10 +1472,19 @@ public:
     // append from first to last
   wxString& append(const_iterator first, const_iterator last)
     { m_impl.append(first, last); return *this; }
     // append from first to last
   wxString& append(const_iterator first, const_iterator last)
     { m_impl.append(first, last); return *this; }

+  wxString& append(const char *first, const char *last)
+    { return append(first, last - first); }
+  wxString& append(const wchar_t *first, const wchar_t *last)
+    { return append(first, last - first); }

 
     // same as `this_string = str'
   wxString& assign(const wxString& str)
     { m_impl = str.m_impl; return *this; }
 
     // same as `this_string = str'
   wxString& assign(const wxString& str)
     { m_impl = str.m_impl; return *this; }

+  wxString& assign(const wxString& str, size_t len)
+  {
+    m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
+    return *this;
+  }

     // 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)
   {


@@ -1458,9 +1521,23 @@ public:
         m_impl.assign(n, (wxStringCharType)ch);
     return *this;
   }
         m_impl.assign(n, (wxStringCharType)ch);
     return *this;
   }

+
+  wxString& assign(size_t n, wxUniCharRef ch)
+    { return assign(n, wxUniChar(ch)); }
+  wxString& assign(size_t n, char ch)
+    { return assign(n, wxUniChar(ch)); }
+  wxString& assign(size_t n, unsigned char ch)
+    { return assign(n, wxUniChar(ch)); }
+  wxString& assign(size_t n, wchar_t ch)
+    { return assign(n, wxUniChar(ch)); }
+

     // assign from first to last
   wxString& assign(const_iterator first, const_iterator last)
     { m_impl.assign(first, last); return *this; }
     // assign from first to last
   wxString& assign(const_iterator first, const_iterator last)
     { m_impl.assign(first, last); return *this; }

+  wxString& assign(const char *first, const char *last)
+    { return assign(first, last - first); }
+  wxString& assign(const wchar_t *first, const wchar_t *last)
+    { return assign(first, last - first); }

 
     // string comparison
   int compare(const wxString& str) const;
 
     // string comparison
   int compare(const wxString& str) const;


@@ -1521,6 +1598,10 @@ public:
     { return iterator(m_impl.insert(it, EncodeChar(ch))); }
   void insert(iterator it, const_iterator first, const_iterator last)
     { m_impl.insert(it, first, last); }
     { return iterator(m_impl.insert(it, EncodeChar(ch))); }
   void insert(iterator it, const_iterator first, const_iterator last)
     { m_impl.insert(it, first, last); }

+  void insert(iterator it, const char *first, const char *last)
+    { insert(it - begin(), first, last - first); }
+  void append(iterator it, const wchar_t *first, const wchar_t *last)
+    { insert(it - begin(), first, last - first); }

   void insert(iterator it, size_type n, wxUniChar ch)
   {
 #if wxUSE_UNICODE_UTF8
   void insert(iterator it, size_type n, wxUniChar ch)
   {
 #if wxUSE_UNICODE_UTF8


@@ -1539,6 +1620,7 @@ public:
     m_impl.erase(from, len);
     return *this;
   }
     m_impl.erase(from, len);
     return *this;
   }

+    // delete characters from first up to last

   iterator erase(iterator first, iterator last)
     { return iterator(m_impl.erase(first, last)); }
   iterator erase(iterator first)
   iterator erase(iterator first, iterator last)
     { return iterator(m_impl.erase(first, last)); }
   iterator erase(iterator first)


@@ -1622,6 +1704,15 @@ public:
     m_impl.replace(from, len, str.data, str.len);
     return *this;
   }
     m_impl.replace(from, len, str.data, str.len);
     return *this;
   }

+  wxString& replace(size_t nStart, size_t nLen,
+                    const wxString& s, size_t nCount)
+  {
+    size_t from, len;
+    PosLenToImpl(nStart, nLen, &from, &len);
+    m_impl.replace(from, len, s.m_impl.c_str(), s.LenToImpl(nCount));
+    return *this;
+  }
+

   wxString& replace(iterator first, iterator last, const char* s)
     { m_impl.replace(first, last, ImplStr(s)); return *this; }
   wxString& replace(iterator first, iterator last, const wchar_t* s)
   wxString& replace(iterator first, iterator last, const char* s)
     { m_impl.replace(first, last, ImplStr(s)); return *this; }
   wxString& replace(iterator first, iterator last, const wchar_t* s)


@@ -1653,6 +1744,12 @@ public:
   wxString& replace(iterator first, iterator last,
                     const_iterator first1, const_iterator last1)
     { m_impl.replace(first, last, first1, last1); return *this; }
   wxString& replace(iterator first, iterator last,
                     const_iterator first1, const_iterator last1)
     { m_impl.replace(first, last, first1, last1); return *this; }

+  wxString& replace(iterator first, iterator last,
+                    const char *first1, const char *last1)
+    { replace(first, last, first1, last1 - first1); return *this; }
+  wxString& replace(iterator first, iterator last,
+                    const wchar_t *first1, const wchar_t *last1)
+    { replace(first, last, first1, last1 - first1); return *this; }

 
   // swap two strings
   void swap(wxString& str)
 
   // swap two strings
   void swap(wxString& str)


@@ -1681,6 +1778,8 @@ public:
     {  return find(wxUniChar(ch), nStart); }
   size_t find(char ch, size_t nStart = 0) const
     {  return find(wxUniChar(ch), nStart); }
     {  return find(wxUniChar(ch), nStart); }
   size_t find(char ch, size_t nStart = 0) const
     {  return find(wxUniChar(ch), nStart); }

+  size_t find(unsigned char ch, size_t nStart = 0) const
+    {  return find(wxUniChar(ch), nStart); }

   size_t find(wchar_t ch, size_t nStart = 0) const
     {  return find(wxUniChar(ch), nStart); }
 
   size_t find(wchar_t ch, size_t nStart = 0) const
     {  return find(wxUniChar(ch), nStart); }
 


@@ -1708,6 +1807,8 @@ public:
     {  return rfind(wxUniChar(ch), nStart); }
   size_t rfind(char ch, size_t nStart = npos) const
     {  return rfind(wxUniChar(ch), nStart); }
     {  return rfind(wxUniChar(ch), nStart); }
   size_t rfind(char ch, size_t nStart = npos) const
     {  return rfind(wxUniChar(ch), nStart); }

+  size_t rfind(unsigned char ch, size_t nStart = npos) const
+    {  return rfind(wxUniChar(ch), nStart); }

   size_t rfind(wchar_t ch, size_t nStart = npos) const
     {  return rfind(wxUniChar(ch), nStart); }
 
   size_t rfind(wchar_t ch, size_t nStart = npos) const
     {  return rfind(wxUniChar(ch), nStart); }
 


@@ -1824,24 +1925,32 @@ public:
     {  return find_first_of(wxUniChar(ch), nStart); }
   size_t find_first_of(char ch, size_t nStart = 0) const
     {  return find_first_of(wxUniChar(ch), nStart); }
     {  return find_first_of(wxUniChar(ch), nStart); }
   size_t find_first_of(char ch, size_t nStart = 0) const
     {  return find_first_of(wxUniChar(ch), nStart); }

+  size_t find_first_of(unsigned char ch, size_t nStart = 0) const
+    {  return find_first_of(wxUniChar(ch), nStart); }

   size_t find_first_of(wchar_t ch, size_t nStart = 0) const
     {  return find_first_of(wxUniChar(ch), nStart); }
   size_t find_last_of(wxUniCharRef ch, size_t nStart = npos) const
     {  return find_last_of(wxUniChar(ch), nStart); }
   size_t find_last_of(char ch, size_t nStart = npos) const
     {  return find_last_of(wxUniChar(ch), nStart); }
   size_t find_first_of(wchar_t ch, size_t nStart = 0) const
     {  return find_first_of(wxUniChar(ch), nStart); }
   size_t find_last_of(wxUniCharRef ch, size_t nStart = npos) const
     {  return find_last_of(wxUniChar(ch), nStart); }
   size_t find_last_of(char ch, size_t nStart = npos) const
     {  return find_last_of(wxUniChar(ch), nStart); }

+  size_t find_last_of(unsigned char ch, size_t nStart = npos) const
+    {  return find_last_of(wxUniChar(ch), nStart); }

   size_t find_last_of(wchar_t ch, size_t nStart = npos) const
     {  return find_last_of(wxUniChar(ch), nStart); }
   size_t find_first_not_of(wxUniCharRef ch, size_t nStart = 0) const
     {  return find_first_not_of(wxUniChar(ch), nStart); }
   size_t find_first_not_of(char ch, size_t nStart = 0) const
     {  return find_first_not_of(wxUniChar(ch), nStart); }
   size_t find_last_of(wchar_t ch, size_t nStart = npos) const
     {  return find_last_of(wxUniChar(ch), nStart); }
   size_t find_first_not_of(wxUniCharRef ch, size_t nStart = 0) const
     {  return find_first_not_of(wxUniChar(ch), nStart); }
   size_t find_first_not_of(char ch, size_t nStart = 0) const
     {  return find_first_not_of(wxUniChar(ch), nStart); }

+  size_t find_first_not_of(unsigned char ch, size_t nStart = 0) const
+    {  return find_first_not_of(wxUniChar(ch), nStart); }

   size_t find_first_not_of(wchar_t ch, size_t nStart = 0) const
     {  return find_first_not_of(wxUniChar(ch), nStart); }
   size_t find_last_not_of(wxUniCharRef ch, size_t nStart = npos) const
     {  return find_last_not_of(wxUniChar(ch), nStart); }
   size_t find_last_not_of(char ch, size_t nStart = npos) const
     {  return find_last_not_of(wxUniChar(ch), nStart); }
   size_t find_first_not_of(wchar_t ch, size_t nStart = 0) const
     {  return find_first_not_of(wxUniChar(ch), nStart); }
   size_t find_last_not_of(wxUniCharRef ch, size_t nStart = npos) const
     {  return find_last_not_of(wxUniChar(ch), nStart); }
   size_t find_last_not_of(char ch, size_t nStart = npos) const
     {  return find_last_not_of(wxUniChar(ch), nStart); }

+  size_t find_last_not_of(unsigned char ch, size_t nStart = npos) const
+    {  return find_last_not_of(wxUniChar(ch), nStart); }

   size_t find_last_not_of(wchar_t ch, size_t nStart = npos) const
     {  return find_last_not_of(wxUniChar(ch), nStart); }
 
   size_t find_last_not_of(wchar_t ch, size_t nStart = npos) const
     {  return find_last_not_of(wxUniChar(ch), nStart); }
 


@@ -1890,6 +1999,35 @@ private:
 
 private:
   wxStringImpl m_impl;
 
 private:
   wxStringImpl m_impl;

+
+  // buffers for compatibility conversion from (char*)c_str() and
+  // (wchar_t*)c_str():
+  // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
+  template<typename T>
+  struct ConvertedBuffer
+  {
+      ConvertedBuffer() : m_buf(NULL) {}
+      ~ConvertedBuffer()
+          { free(m_buf); }
+
+      operator const T*() const { return m_buf; }
+
+      ConvertedBuffer& operator=(T *str)
+      {
+          free(m_buf);
+          m_buf = str;
+          return *this;
+      }
+
+      T *m_buf;
+  };
+#if wxUSE_UNICODE
+  ConvertedBuffer<char> m_convertedToChar;
+#endif
+#if !wxUSE_UNICODE_WCHAR
+  ConvertedBuffer<wchar_t> m_convertedToWChar;
+#endif
+  friend class WXDLLIMPEXP_BASE wxCStrData;

 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN


@@ -2156,12 +2294,8 @@ wxDEFINE_ALL_COMPARISONS(const char *, const wxString&, wxCMP_CHAR_STRING)
 #define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar()
 #define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar()
 
 #define wxCMP_CHAR_CSTRDATA(p, s, op) p op s.AsChar()
 #define wxCMP_WCHAR_CSTRDATA(p, s, op) p op s.AsWChar()
 

-// FIXME: these ifdefs must be removed when wxCStrData has both conversions
-#if wxUSE_UNICODE
-    wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData&, wxCMP_WCHAR_CSTRDATA)
-#else
-    wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA)
-#endif
+wxDEFINE_ALL_COMPARISONS(const wchar_t *, const wxCStrData&, wxCMP_WCHAR_CSTRDATA)
+wxDEFINE_ALL_COMPARISONS(const char *, const wxCStrData&, wxCMP_CHAR_CSTRDATA)

 
 #undef wxCMP_CHAR_CSTRDATA
 #undef wxCMP_WCHAR_CSTRDATA
 
 #undef wxCMP_CHAR_CSTRDATA
 #undef wxCMP_WCHAR_CSTRDATA


@@ -2176,6 +2310,10 @@ wxDEFINE_ALL_COMPARISONS(const char *, const wxString&, wxCMP_CHAR_STRING)
 
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&);
 
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
 WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCStrData&);

+WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxCharBuffer&);
+#ifndef __BORLANDC__
+WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxWCharBuffer&);
+#endif

 
 #endif  // wxSTD_STRING_COMPATIBILITY
 
 
 #endif  // wxSTD_STRING_COMPATIBILITY
 


@@ -2194,15 +2332,26 @@ inline wxCStrData::~wxCStrData()
         delete m_str;
 }
 
         delete m_str;
 }
 

-#if wxUSE_UNICODE
+inline wxCStrData::operator bool() const
+{
+    return !m_str->empty();
+}
+
+// simple cases for AsChar() and AsWChar(), the complicated ones are
+// in string.cpp
+#if wxUSE_UNICODE_WCHAR

 inline const wchar_t* wxCStrData::AsWChar() const
 inline const wchar_t* wxCStrData::AsWChar() const

-#else
+{
+    return m_str->wx_str() + m_offset;
+}
+#endif // wxUSE_UNICODE_WCHAR
+
+#if !wxUSE_UNICODE

 inline const char* wxCStrData::AsChar() const
 inline const char* wxCStrData::AsChar() const

-#endif

 {
 {

-    // FIXME-UTF8: incorrect position, incorrect charset

     return m_str->wx_str() + m_offset;
 }
     return m_str->wx_str() + m_offset;
 }

+#endif // !wxUSE_UNICODE

 
 inline wxString wxCStrData::AsString() const
 {
 
 inline wxString wxCStrData::AsString() const
 {


@@ -2225,14 +2374,35 @@ inline wxUniChar wxCStrData::operator[](size_t n) const
     return m_str->at(m_offset + n);
 }
 
     return m_str->at(m_offset + n);
 }
 

+// ----------------------------------------------------------------------------
+// more wxCStrData operators
+// ----------------------------------------------------------------------------
+
+// we need to define those to allow "size_t pos = p - s.c_str()" where p is
+// some pointer into the string
+inline size_t operator-(const char *p, const wxCStrData& cs)
+{
+    return p - cs.AsChar();
+}
+
+inline size_t operator-(const wchar_t *p, const wxCStrData& cs)
+{
+    return p - cs.AsWChar();
+}
+

 // ----------------------------------------------------------------------------
 // implementation of wx[W]CharBuffer inline methods using wxCStrData
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // implementation of wx[W]CharBuffer inline methods using wxCStrData
 // ----------------------------------------------------------------------------
 

-// FIXME-UTF8: move this to buffer.h; provide versions for both variants
-inline wxWxCharBuffer::wxWxCharBuffer(const wxCStrData& cstr)
-                    : wxCharTypeBufferBase((const wxChar *)cstr)
+// FIXME-UTF8: move this to buffer.h
+inline wxCharBuffer::wxCharBuffer(const wxCStrData& cstr)
+                    : wxCharTypeBufferBase(cstr.AsChar())
+{
+}
+
+inline wxWCharBuffer::wxWCharBuffer(const wxCStrData& cstr)
+                    : wxCharTypeBufferBase(cstr.AsWChar())

 {
 }
 
 {
 }
 

-#endif  // _WX_WXSTRING_H__
+#endif  // _WX_WXSTRING_H_