Added allocation constructor (makes it easy to convert right into a buffer

allocated to size by this class), copy constructor (egcs does not like
const wxCharBuffer& mb_str() { return wxCharBuffer(...); }, so it HAS to be
copiable), and assignment constructor (so it can be stored to a variable
for efficiency, instead of being converted every time the string is needed).

(The copy and assignment operator wipes the source, so the buffer is
essentially passed on to the new instance without being freed by the old.)

wcsdup() is not declared in glibc by default, so use malloc() instead.
Added some 'convenience' macros.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2107 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/buffer.h

@@ -14,8 +14,8 @@
 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 
-#include <string.h> // strdup()
-#include <wchar.h>  // wcsdup()
+#include <string.h> // strdup
+#include <wchar.h>  // wchar_t
 
 // ----------------------------------------------------------------------------
 // Special classes for (wide) character strings: they use malloc/free instead
@@ -27,14 +27,32 @@ class wxCharBuffer
 public:
     wxCharBuffer(const char *str)
     {
-        wxASSERT_MSG( str, "NULL string in wxCharBuffer" );
+        wxASSERT_MSG( str, _T("NULL string in wxCharBuffer") );
 
         m_str = str ? strdup(str) : (char *)NULL;
     }
-
+    wxCharBuffer(size_t len)
+    {
+        m_str = (char *)malloc(len+1);
+	m_str[len] = '\0';
+    }
     // no need to check for NULL, free() does it
    ~wxCharBuffer() { free(m_str); }
 
+   wxCharBuffer(const wxCharBuffer& src)
+   {
+     m_str = src.m_str;
+     // no reference count yet...
+     (wxCharBuffer)src.m_str = (char *)NULL;
+   }
+   wxCharBuffer& operator=(const wxCharBuffer& src)
+   {
+     m_str = src.m_str;
+     // no reference count yet...
+     (wxCharBuffer)src.m_str = (char *)NULL;
+     return *this;
+   }
+
    operator const char *() const { return m_str; }
 
 private:
@@ -46,20 +64,53 @@ class wxWCharBuffer
 public:
     wxWCharBuffer(const wchar_t *wcs)
     {
-        wxASSERT_MSG( wcs, "NULL string in wxWCharBuffer" );
+        wxASSERT_MSG( wcs, _T("NULL string in wxWCharBuffer") );
 
-        m_wcs = wcs ? wcsdup(wcs) : (wchar_t *)NULL;
+        m_wcs = wcs ? (wchar_t *)malloc((wcslen(wcs)+1)*sizeof(wchar_t))
+	            : (wchar_t *)NULL;
+	if (m_wcs) wcscpy(m_wcs, wcs);
+    }
+    wxWCharBuffer(size_t len)
+    {
+        m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t));
+	m_wcs[len] = L'\0';
     }
 
     // no need to check for NULL, free() does it
    ~wxWCharBuffer() { free(m_wcs); }
 
+   wxWCharBuffer(const wxWCharBuffer& src)
+   {
+     m_wcs = src.m_wcs;
+     // no reference count yet...
+     (wxWCharBuffer)src.m_wcs = (wchar_t *)NULL;
+   }
+   wxWCharBuffer& operator=(const wxWCharBuffer& src)
+   {
+     m_wcs = src.m_wcs;
+     // no reference count yet...
+     (wxWCharBuffer)src.m_wcs = (wchar_t *)NULL;
+     return *this;
+   }
+
    operator const wchar_t *() const { return m_wcs; }
 
 private:
    wchar_t *m_wcs;
 };
 
+#if wxUSE_UNICODE
+#define wxMB2WXbuf wxWCharBuffer
+#define wxWX2MBbuf wxCharBuffer
+#define wxWC2WXbuf wxChar*
+#define wxWX2WCbuf wxChar*
+#else
+#define wxMB2WXbuf wxChar*
+#define wxWX2MBbuf wxChar*
+#define wxWC2WXbuf wxCharBuffer
+#define wxWX2WCbuf wxWCharBuffer
+#endif
+
 // ----------------------------------------------------------------------------
 // template class for any kind of data
 // ----------------------------------------------------------------------------