moved vararg handling code in wxMessageOutput to single method and added simple Outpu...

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

diff --git a/include/wx/string.h b/include/wx/string.h
index e598ccd5a149bc7a17f6ca25191c1e1a3384981f..5f3801ef5126193e7eac677cd47f2614b8b128ce 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


@@ -553,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


@@ -618,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; }                                    \


@@ -653,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;
   };


@@ -670,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) {}


@@ -906,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(); }


@@ -1167,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


@@ -1237,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


@@ -1347,11 +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( 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( 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( 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; }
 


@@ -1363,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]


@@ -1416,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)
   {


@@ -1456,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;


@@ -1519,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


@@ -1537,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)


@@ -1620,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)


@@ -1651,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)


@@ -1900,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 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


@@ -2166,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


@@ -2208,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
 {


@@ -2239,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_