osx regrouping

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

diff --git a/include/wx/string.h b/include/wx/string.h
index 2d7d3e3a9c21c8dcabb23429952a0a1fc0c14341..0a72bfe3206dacfb33d94b37044935577a9cfc1f 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -24,6 +24,7 @@
 
 #include "wx/defs.h"        // everybody should include this
 
 
 #include "wx/defs.h"        // everybody should include this
 

+#ifndef __WXPALMOS5__

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


@@ -46,10 +47,7 @@
 #ifdef HAVE_STRCASECMP_IN_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 #endif // HAVE_STRCASECMP_IN_STRINGS_H
 #ifdef HAVE_STRCASECMP_IN_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 #endif // HAVE_STRCASECMP_IN_STRINGS_H

-
-#ifdef __WXPALMOS__
-    #include <StringMgr.h>
-#endif
+#endif // ! __WXPALMOS5__

 
 #include "wx/wxcrtbase.h"   // for wxChar, wxStrlen() etc.
 #include "wx/strvararg.h"
 
 #include "wx/wxcrtbase.h"   // for wxChar, wxStrlen() etc.
 #include "wx/strvararg.h"


@@ -67,6 +65,11 @@ class WXDLLIMPEXP_FWD_BASE wxString;
     #define WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER 1
 #endif
 
     #define WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER 1
 #endif
 

+namespace wxPrivate
+{
+    template <typename T> struct wxStringAsBufHelper;
+}
+

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


@@ -433,7 +436,10 @@ private:
       size_t len;
 
       SubstrBufFromType(const T& data_, size_t len_)
       size_t len;
 
       SubstrBufFromType(const T& data_, size_t len_)

-          : data(data_), len(len_) {}
+          : data(data_), len(len_)
+      {
+          wxASSERT_MSG( len != npos, "must have real length" );
+      }

   };
 
 #if wxUSE_UNICODE_UTF8
   };
 
 #if wxUSE_UNICODE_UTF8


@@ -952,8 +958,11 @@ public:
   wxString(const wxWCharBuffer& 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
 

+    // NB: this version uses m_impl.c_str() to force making a copy of the
+    //     string, so that "wxString(str.c_str())" idiom for passing strings
+    //     between threads works

   wxString(const wxCStrData& cstr)
   wxString(const wxCStrData& cstr)

-      : m_impl(cstr.AsString().m_impl) { }
+      : m_impl(cstr.AsString().m_impl.c_str()) { }

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


@@ -1013,6 +1022,13 @@ public:
   #endif
 #endif // wxUSE_STL
 
   #endif
 #endif // wxUSE_STL
 

+  wxString Clone() const
+  {
+      // make a deep copy of the string, i.e. the returned string will have
+      // ref count = 1 with refcounted implementation
+      return wxString::FromImpl(wxStringImpl(m_impl.c_str(), m_impl.length()));
+  }
+

   // first valid index position
   const_iterator begin() const { return const_iterator(this, m_impl.begin()); }
   iterator begin() { return iterator(this, m_impl.begin()); }
   // first valid index position
   const_iterator begin() const { return const_iterator(this, m_impl.begin()); }
   iterator begin() { return iterator(this, m_impl.begin()); }


@@ -1200,6 +1216,30 @@ public:
         { return mb_str(conv); }
     wxWritableWCharBuffer wchar_str() const { return wc_str(); }
 
         { return mb_str(conv); }
     wxWritableWCharBuffer wchar_str() const { return wc_str(); }
 

+    // conversion to the buffer of the given type T (= char or wchar_t) and
+    // also optionally return the buffer length
+    //
+    // this is mostly/only useful for the template functions
+    //
+    // FIXME-VC6: the second argument only exists for VC6 which doesn't support
+    //            explicit template function selection, do not use it unless
+    //            you must support VC6!
+    template <typename T>
+    wxCharTypeBuffer<T> tchar_str(size_t *len = NULL,
+                                  T * WXUNUSED(dummy) = NULL) const
+    {
+#if wxUSE_UNICODE
+        // we need a helper dispatcher depending on type
+        return wxPrivate::wxStringAsBufHelper<T>::Get(*this, len);
+#else // ANSI
+        // T can only be char in ANSI build
+        if ( len )
+            *len = length();
+
+        return wxCharTypeBuffer<T>::CreateNonOwned(wx_str());
+#endif // Unicode build kind
+    }
+

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


@@ -1228,7 +1268,7 @@ public:
 
     // conversion to/from UTF-8:
 #if wxUSE_UNICODE_UTF8
 
     // conversion to/from UTF-8:
 #if wxUSE_UNICODE_UTF8

-    static wxString FromUTF8(const char *utf8)
+    static wxString FromUTF8Unchecked(const char *utf8)

     {
       if ( !utf8 )
           return wxEmptyString;
     {
       if ( !utf8 )
           return wxEmptyString;


@@ -1236,23 +1276,51 @@ public:
       wxASSERT( wxStringOperations::IsValidUtf8String(utf8) );
       return FromImpl(wxStringImpl(utf8));
     }
       wxASSERT( wxStringOperations::IsValidUtf8String(utf8) );
       return FromImpl(wxStringImpl(utf8));
     }

-    static wxString FromUTF8(const char *utf8, size_t len)
+    static wxString FromUTF8Unchecked(const char *utf8, size_t len)

     {
       if ( !utf8 )
           return wxEmptyString;
       if ( len == npos )
     {
       if ( !utf8 )
           return wxEmptyString;
       if ( len == npos )

-          return FromUTF8(utf8);
+          return FromUTF8Unchecked(utf8);

 
       wxASSERT( wxStringOperations::IsValidUtf8String(utf8, len) );
       return FromImpl(wxStringImpl(utf8, len));
     }
 
       wxASSERT( wxStringOperations::IsValidUtf8String(utf8, len) );
       return FromImpl(wxStringImpl(utf8, len));
     }

+
+    static wxString FromUTF8(const char *utf8)
+    {
+        if ( !utf8 || !wxStringOperations::IsValidUtf8String(utf8) )
+            return "";
+
+        return FromImpl(wxStringImpl(utf8));
+    }
+    static wxString FromUTF8(const char *utf8, size_t len)
+    {
+        if ( len == npos )
+            return FromUTF8(utf8);
+
+        if ( !utf8 || !wxStringOperations::IsValidUtf8String(utf8, len) )
+            return "";
+
+        return FromImpl(wxStringImpl(utf8, len));
+    }
+

     const char* utf8_str() const { return wx_str(); }
     const char* ToUTF8() const { return wx_str(); }
     const char* utf8_str() const { return wx_str(); }
     const char* ToUTF8() const { return wx_str(); }

+
+    // this function exists in UTF-8 build only and returns the length of the
+    // internal UTF-8 representation
+    size_t utf8_length() const { return m_impl.length(); }

 #elif wxUSE_UNICODE_WCHAR
 #elif wxUSE_UNICODE_WCHAR

-    static wxString FromUTF8(const char *utf8)
-      { return wxString(utf8, wxMBConvUTF8()); }
-    static wxString FromUTF8(const char *utf8, size_t len)
+    static wxString FromUTF8(const char *utf8, size_t len = npos)

       { return wxString(utf8, wxMBConvUTF8(), len); }
       { return wxString(utf8, wxMBConvUTF8(), len); }

+    static wxString FromUTF8Unchecked(const char *utf8, size_t len = npos)
+    {
+        const wxString s(utf8, wxMBConvUTF8(), len);
+        wxASSERT_MSG( !utf8 || !*utf8 || !s.empty(),
+                      "string must be valid UTF-8" );
+        return s;
+    }

     const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); }
     const wxCharBuffer ToUTF8() const { return utf8_str(); }
 #else // ANSI
     const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); }
     const wxCharBuffer ToUTF8() const { return utf8_str(); }
 #else // ANSI


@@ -1260,9 +1328,20 @@ public:
       { return wxString(wxMBConvUTF8().cMB2WC(utf8)); }
     static wxString FromUTF8(const char *utf8, size_t len)
     {
       { return wxString(wxMBConvUTF8().cMB2WC(utf8)); }
     static wxString FromUTF8(const char *utf8, size_t len)
     {

-      size_t wlen;
-      wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen));
-      return wxString(buf.data(), wlen);
+        size_t wlen;
+        wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen));
+        return wxString(buf.data(), wlen);
+    }
+    static wxString FromUTF8Unchecked(const char *utf8, size_t len = npos)
+    {
+        size_t wlen;
+        wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8,
+                                                len == npos ? wxNO_LEN : len,
+                                                &wlen));
+        wxASSERT_MSG( !utf8 || !*utf8 || wlen,
+                      "string must be valid UTF-8" );
+
+        return wxString(buf.data(), wlen);

     }
     const wxCharBuffer utf8_str() const
       { return wxMBConvUTF8().cWC2MB(wc_str()); }
     }
     const wxCharBuffer utf8_str() const
       { return wxMBConvUTF8().cWC2MB(wc_str()); }


@@ -1307,7 +1386,7 @@ public:
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
 #if wxUSE_UNICODE_WCHAR
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
 #if wxUSE_UNICODE_WCHAR

-    const wxChar* wc_str() const { return wx_str(); }
+    const wchar_t* wc_str() const { return wx_str(); }

 #elif wxUSE_UNICODE_UTF8
     const wxWCharBuffer wc_str() const;
 #endif
 #elif wxUSE_UNICODE_UTF8
     const wxWCharBuffer wc_str() const;
 #endif


@@ -1325,7 +1404,7 @@ public:
     const wxChar* mb_str() const { return wx_str(); }
 
     // for compatibility with wxUSE_UNICODE version
     const wxChar* mb_str() const { return wx_str(); }
 
     // for compatibility with wxUSE_UNICODE version

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

 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 


@@ -1335,6 +1414,15 @@ public:
     const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
 #endif // Unicode/ANSI
 
     const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
 #endif // Unicode/ANSI
 

+#if wxUSE_UNICODE_UTF8
+    const wxWCharBuffer t_str() const { return wc_str(); }
+#elif wxUSE_UNICODE_WCHAR
+    const wchar_t* t_str() const { return wx_str(); }
+#else
+    const char* t_str() const { return wx_str(); }
+#endif 
+
+

   // overloaded assignment
     // from another wxString
   wxString& operator=(const wxString& stringSrc)
   // overloaded assignment
     // from another wxString
   wxString& operator=(const wxString& stringSrc)


@@ -1343,7 +1431,15 @@ public:
     { return *this = cstr.AsString(); }
     // from a character
   wxString& operator=(wxUniChar ch)
     { return *this = cstr.AsString(); }
     // from a character
   wxString& operator=(wxUniChar ch)

-    { m_impl = wxStringOperations::EncodeChar(ch); return *this; }
+  {
+#if wxUSE_UNICODE_UTF8
+    if ( !ch.IsAscii() )
+        m_impl = wxStringOperations::EncodeChar(ch);
+    else
+#endif
+        m_impl = (wxStringCharType)ch;
+    return *this;
+  }

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


@@ -1433,6 +1529,16 @@ public:
     { append(psz); return *this; }
   wxString& Append(const wxWCharBuffer& psz)
     { append(psz); return *this; }
     { append(psz); return *this; }
   wxString& Append(const wxWCharBuffer& psz)
     { append(psz); return *this; }

+  wxString& Append(const char* psz, size_t nLen)
+    { append(psz, nLen); return *this; }
+  wxString& Append(const wchar_t* pwz, size_t nLen)
+    { append(pwz, nLen); return *this; }
+  wxString& Append(const wxCStrData& psz, size_t nLen)
+    { append(psz, nLen); return *this; }
+  wxString& Append(const wxCharBuffer& psz, size_t nLen)
+    { append(psz, nLen); return *this; }
+  wxString& Append(const wxWCharBuffer& psz, size_t nLen)
+    { append(psz, nLen); return *this; }

     // append count copies of given character
   wxString& Append(wxUniChar ch, size_t count = 1u)
     { append(count, ch); return *this; }
     // append count copies of given character
   wxString& Append(wxUniChar ch, size_t count = 1u)
     { append(count, ch); return *this; }


@@ -1444,10 +1550,6 @@ public:
     { append(count, ch); return *this; }
   wxString& Append(wchar_t ch, size_t count = 1u)
     { append(count, ch); return *this; }
     { 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)
-    { append(psz, nLen); return *this; }
-  wxString& Append(const wchar_t* pwz, size_t nLen)
-    { append(pwz, nLen); return *this; }

 
     // prepend a string, return the string itself
   wxString& Prepend(const wxString& str)
 
     // prepend a string, return the string itself
   wxString& Prepend(const wxString& str)


@@ -1723,7 +1825,7 @@ public:
   // raw access to string memory
     // ensure that string has space for at least nLen characters
     // only works if the data of this string is not shared
   // raw access to string memory
     // ensure that string has space for at least nLen characters
     // only works if the data of this string is not shared

-  bool Alloc(size_t nLen) { reserve(nLen); /*return capacity() >= nLen;*/ return true; }
+  bool Alloc(size_t nLen) { reserve(nLen); return capacity() >= nLen; }

     // 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();


@@ -1872,6 +1974,12 @@ public:
     { return append(str.data()); }
   wxString& append(const wxWCharBuffer& str)
     { return append(str.data()); }
     { return append(str.data()); }
   wxString& append(const wxWCharBuffer& str)
     { return append(str.data()); }

+  wxString& append(const wxCStrData& str, size_t n)
+    { return append(str.AsString(), 0, n); }
+  wxString& append(const wxCharBuffer& str, size_t n)
+    { return append(str.data(), n); }
+  wxString& append(const wxWCharBuffer& str, size_t n)
+    { return append(str.data(), n); }

 
     // append n copies of ch
   wxString& append(size_t n, wxUniChar ch)
 
     // append n copies of ch
   wxString& append(size_t n, wxUniChar ch)


@@ -1884,6 +1992,15 @@ public:
         m_impl.append(n, (wxStringCharType)ch);
     return *this;
   }
         m_impl.append(n, (wxStringCharType)ch);
     return *this;
   }

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

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


@@ -2242,8 +2359,15 @@ public:
     // find the first occurence of character ch after nStart
   size_t find(wxUniChar ch, size_t nStart = 0) const
   {
     // find the first occurence of character ch after nStart
   size_t find(wxUniChar ch, size_t nStart = 0) const
   {

-    return PosFromImpl(m_impl.find(wxStringOperations::EncodeChar(ch),
-                                   PosToImpl(nStart)));
+#if wxUSE_UNICODE_UTF8
+    if ( !ch.IsAscii() )
+        return PosFromImpl(m_impl.find(wxStringOperations::EncodeChar(ch),
+                                       PosToImpl(nStart)));
+    else
+#endif
+        return PosFromImpl(m_impl.find((wxStringCharType)ch,
+                                       PosToImpl(nStart)));
+

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


@@ -2280,8 +2404,14 @@ public:
     // as find, but from the end
   size_t rfind(wxUniChar ch, size_t nStart = npos) const
   {
     // as find, but from the end
   size_t rfind(wxUniChar ch, size_t nStart = npos) const
   {

-    return PosFromImpl(m_impl.rfind(wxStringOperations::EncodeChar(ch),
-                                    PosToImpl(nStart)));
+#if wxUSE_UNICODE_UTF8
+    if ( !ch.IsAscii() )
+        return PosFromImpl(m_impl.rfind(wxStringOperations::EncodeChar(ch),
+                                        PosToImpl(nStart)));
+    else
+#endif
+        return PosFromImpl(m_impl.rfind((wxStringCharType)ch,
+                                        PosToImpl(nStart)));

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


@@ -2519,7 +2649,15 @@ public:
     { return operator+=(s.data()); }
       // string += char
   wxString& operator+=(wxUniChar ch)
     { return operator+=(s.data()); }
       // string += char
   wxString& operator+=(wxUniChar ch)

-    { m_impl += wxStringOperations::EncodeChar(ch); return *this; }
+  {
+#if wxUSE_UNICODE_UTF8
+    if ( !ch.IsAscii() )
+        m_impl += wxStringOperations::EncodeChar(ch);
+    else
+#endif
+        m_impl += (wxStringCharType)ch;
+    return *this;
+  }

   wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); }
   wxString& operator+=(int ch) { return *this += wxUniChar(ch); }
   wxString& operator+=(char ch) { return *this += wxUniChar(ch); }
   wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); }
   wxString& operator+=(int ch) { return *this += wxUniChar(ch); }
   wxString& operator+=(char ch) { return *this += wxUniChar(ch); }


@@ -2654,6 +2792,67 @@ inline wxString operator+(wchar_t ch, const wxString& string)
 
 #define wxGetEmptyString() wxString()
 
 
 #define wxGetEmptyString() wxString()
 

+// ----------------------------------------------------------------------------
+// helper functions which couldn't be defined inline
+// ----------------------------------------------------------------------------
+
+namespace wxPrivate
+{
+
+#if wxUSE_UNICODE_WCHAR
+
+template <>
+struct wxStringAsBufHelper<char>
+{
+    static wxCharBuffer Get(const wxString& s, size_t *len)
+    {
+        wxCharBuffer buf(s.mb_str());
+        if ( len )
+            *len = buf ? strlen(buf) : 0;
+        return buf;
+    }
+};
+
+template <>
+struct wxStringAsBufHelper<wchar_t>
+{
+    static wxWCharBuffer Get(const wxString& s, size_t *len)
+    {
+        if ( len )
+            *len = s.length();
+        return wxWCharBuffer::CreateNonOwned(s.wx_str());
+    }
+};
+
+#elif wxUSE_UNICODE_UTF8
+
+template <>
+struct wxStringAsBufHelper<char>
+{
+    static wxCharBuffer Get(const wxString& s, size_t *len)
+    {
+        if ( len )
+            *len = s.utf8_length();
+        return wxCharBuffer::CreateNonOwned(s.wx_str());
+    }
+};
+
+template <>
+struct wxStringAsBufHelper<wchar_t>
+{
+    static wxWCharBuffer Get(const wxString& s, size_t *len)
+    {
+        wxWCharBuffer wbuf(s.wc_str());
+        if ( len )
+            *len = wxWcslen(wbuf);
+        return wbuf;
+    }
+};
+
+#endif // Unicode build kind
+
+} // namespace wxPrivate
+

 // ----------------------------------------------------------------------------
 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxStringBuffer: a tiny class allowing to get a writable pointer into string
 // ----------------------------------------------------------------------------


@@ -2721,8 +2920,30 @@ public:
 
     wxStringTypeBufferBase(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(lenWanted)
 
     wxStringTypeBufferBase(wxString& str, size_t lenWanted = 1024)
         : m_str(str), m_buf(lenWanted)

-        { }
-
+    {
+        // for compatibility with old wxStringBuffer which provided direct
+        // access to wxString internal buffer, initialize ourselves with the
+        // string initial contents
+
+        // FIXME-VC6: remove the ugly (CharType *)NULL and use normal
+        //            tchar_str<CharType>
+        size_t len;
+        const wxCharTypeBuffer<CharType> buf(str.tchar_str(&len, (CharType *)NULL));
+        if ( buf )
+        {
+            if ( len > lenWanted )
+            {
+                // in this case there is not enough space for terminating NUL,
+                // ensure that we still put it there
+                m_buf.data()[lenWanted] = 0;
+                len = lenWanted - 1;
+            }
+
+            memcpy(m_buf.data(), buf, (len + 1)*sizeof(CharType));
+        }
+        //else: conversion failed, this can happen when trying to get Unicode
+        //      string contents into a char string
+    }

 
     operator CharType*() { return m_buf.data(); }
 
 
     operator CharType*() { return m_buf.data(); }
 


@@ -2733,22 +2954,25 @@ protected:
 
 template<typename T>
 class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase
 
 template<typename T>
 class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase

+    : public wxStringTypeBufferBase<T>

 {
 public:
 {
 public:

-    typedef T CharType;
-

     wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024)
     wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024)

-        : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false)
+        : wxStringTypeBufferBase<T>(str, lenWanted),
+          m_len(0),
+          m_lenSet(false)

         { }
 
         { }
 

-    operator CharType*() { return m_buf.data(); }
+    ~wxStringTypeBufferLengthBase()
+    {
+        wxASSERT_MSG( this->m_lenSet, "forgot to call SetLength()" );
+    }
+

     void SetLength(size_t length) { m_len = length; m_lenSet = true; }
 
 protected:
     void SetLength(size_t length) { m_len = length; m_lenSet = true; }
 
 protected:

-    wxString& m_str;
-    wxCharTypeBuffer<CharType> m_buf;
-    size_t        m_len;
-    bool          m_lenSet;
+    size_t m_len;
+    bool m_lenSet;

 };
 
 template<typename T>
 };
 
 template<typename T>


@@ -2756,7 +2980,9 @@ class wxStringTypeBuffer : public wxStringTypeBufferBase<T>
 {
 public:
     wxStringTypeBuffer(wxString& str, size_t lenWanted = 1024)
 {
 public:
     wxStringTypeBuffer(wxString& str, size_t lenWanted = 1024)

-        : wxStringTypeBufferBase<T>(str, lenWanted) {}
+        : wxStringTypeBufferBase<T>(str, lenWanted)
+        { }
+

     ~wxStringTypeBuffer()
     {
         this->m_str.assign(this->m_buf.data());
     ~wxStringTypeBuffer()
     {
         this->m_str.assign(this->m_buf.data());


@@ -2770,11 +2996,11 @@ class wxStringTypeBufferLength : public wxStringTypeBufferLengthBase<T>
 {
 public:
     wxStringTypeBufferLength(wxString& str, size_t lenWanted = 1024)
 {
 public:
     wxStringTypeBufferLength(wxString& str, size_t lenWanted = 1024)

-        : wxStringTypeBufferLengthBase<T>(str, lenWanted) {}
+        : wxStringTypeBufferLengthBase<T>(str, lenWanted)
+        { }

 
     ~wxStringTypeBufferLength()
     {
 
     ~wxStringTypeBufferLength()
     {

-        wxASSERT(this->m_lenSet);

         this->m_str.assign(this->m_buf.data(), this->m_len);
     }
 
         this->m_str.assign(this->m_buf.data(), this->m_len);
     }
 


@@ -2808,12 +3034,12 @@ public:
 
     ~wxStringInternalBufferLength()
     {
 
     ~wxStringInternalBufferLength()
     {

-        wxASSERT(m_lenSet);

         m_str.m_impl.assign(m_buf.data(), m_len);
     }
 
     DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
 };
         m_str.m_impl.assign(m_buf.data(), m_len);
     }
 
     DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
 };

+

 #endif // wxUSE_STL_BASED_WXSTRING
 
 
 #endif // wxUSE_STL_BASED_WXSTRING