remove warnings of intentionally unreachable code

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

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index c9232820fec15c0d34d3554088350b2e51e2a7c2..6d50b2a0a9035ac69bb4d9e46727b04a1653580d 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -12,10 +12,13 @@
 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 
-#include "wx/wxchar.h"
+#include "wx/chartype.h"
+#include "wx/wxcrt.h"
 
 #include <stdlib.h>             // malloc() and free()
 
+class WXDLLIMPEXP_BASE wxCStrData;
+
 inline char *wxStrDup(const char *s) { return wxStrdupA(s); }
 #if wxUSE_WCHAR_T
     inline wchar_t *wxStrDup(const wchar_t *ws) { return wxStrdupW(ws); }
@@ -33,18 +36,32 @@ public:
     typedef T CharType;
 
     wxCharTypeBuffer(const CharType *str = NULL)
-        : m_str(str ? wxStrDup(str) : NULL)
+        : m_str(str ? wxStrDup(str) : NULL),
+          m_owned(true)
     {
     }
 
     wxCharTypeBuffer(size_t len)
-        : m_str((CharType *)malloc((len + 1)*sizeof(CharType)))
+        : m_str((CharType *)malloc((len + 1)*sizeof(CharType))),
+          m_owned(true)
     {
         m_str[len] = (CharType)0;
     }
 
+    static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
+    {
+        wxCharTypeBuffer buf;
+        buf.m_str = wx_const_cast(CharType*, str);
+        buf.m_owned = false;
+        return buf;
+    }
+
     /* no need to check for NULL, free() does it */
-    ~wxCharTypeBuffer() { free(m_str); }
+    ~wxCharTypeBuffer()
+    {
+        if ( m_owned)
+            free(m_str);
+    }
 
     /*
         WARNING:
@@ -55,7 +72,7 @@ public:
         a) it shouldn't be really const
         b) you shouldn't use it afterwards (or know that it was reset)
 
-        This is very ugly but is unfortunately needed to make the normal use\
+        This is very ugly but is unfortunately needed to make the normal use
         of wxCharTypeBuffer buffer objects possible and is very similar to what
         std::auto_ptr<> does (as if it were an excuse...)
     */
@@ -66,39 +83,43 @@ public:
      */
     CharType *release() const
     {
-        CharType *p = m_str;
-        ((wxCharTypeBuffer *)this)->m_str = NULL;
-        return p;
+        wxASSERT_MSG( m_owned, _T("can't release non-owned buffer") );
+        return DoRelease();
     }
 
     void reset()
     {
-        free(m_str);
+        if ( m_owned )
+            free(m_str);
         m_str = NULL;
     }
 
     wxCharTypeBuffer(const wxCharTypeBuffer& src)
-        : m_str(src.release())
     {
+        CopyFrom(src);
     }
 
     wxCharTypeBuffer& operator=(const CharType *str)
     {
-        free(m_str);
+        if ( m_owned )
+            free(m_str);
         m_str = str ? wxStrDup(str) : NULL;
+        m_owned = true;
         return *this;
     }
 
     wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
     {
-        free(m_str);
-        m_str = src.release();
-
+        if ( m_owned )
+            free(m_str);
+        CopyFrom(src);
         return *this;
     }
 
     bool extend(size_t len)
     {
+        wxASSERT_MSG( m_owned, _T("cannot extend non-owned buffer") );
+
         CharType *
             str = (CharType *)realloc(m_str, (len + 1)*sizeof(CharType));
         if ( !str )
@@ -114,8 +135,24 @@ public:
     operator const CharType *() const { return m_str; }
     CharType operator[](size_t n) const { return m_str[n]; }
 
+
+private:
+    CharType *DoRelease() const
+    {
+        CharType *p = m_str;
+        ((wxCharTypeBuffer *)this)->m_str = NULL;
+        return p;
+    }
+
+    void CopyFrom(const wxCharTypeBuffer& src)
+    {
+        m_owned = src.m_owned;
+        m_str = src.DoRelease();
+    }
+
 private:
     CharType *m_str;
+    bool m_owned;
 };
 
 class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
@@ -123,12 +160,13 @@ class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
 public:
     typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
 
+    wxCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
     wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
-#if !wxUSE_UNICODE
     wxCharBuffer(const wxCStrData& cstr);
-#endif
 };
 
 #if wxUSE_WCHAR_T
@@ -137,22 +175,49 @@ class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
 public:
     typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
 
+    wxWCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
     wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
-#if wxUSE_UNICODE
     wxWCharBuffer(const wxCStrData& cstr);
-#endif
 };
 #endif // wxUSE_WCHAR_T
 
+// wxCharTypeBuffer<T> implicitly convertible to T*
+template <typename T>
+class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
+{
+public:
+    typedef typename wxCharTypeBuffer<T>::CharType CharType;
+
+    wxWritableCharTypeBuffer(const wxCharTypeBuffer<T>& src)
+        : wxCharTypeBuffer<T>(src) {}
+    // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
+    //             always return a buffer
+    wxWritableCharTypeBuffer(const CharType *str = NULL)
+        : wxCharTypeBuffer<T>(str) {}
+
+    operator CharType*() { return this->data(); }
+};
+
+typedef wxWritableCharTypeBuffer<char> wxWritableCharBuffer;
+typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
+
+
 #if wxUSE_UNICODE
     #define wxWxCharBuffer wxWCharBuffer
 
     #define wxMB2WXbuf wxWCharBuffer
     #define wxWX2MBbuf wxCharBuffer
-    #define wxWC2WXbuf wxChar*
-    #define wxWX2WCbuf wxChar*
+    #if wxUSE_UNICODE_WCHAR
+        #define wxWC2WXbuf wxChar*
+        #define wxWX2WCbuf wxChar*
+    #elif wxUSE_UNICODE_UTF8
+        #define wxWC2WXbuf wxWCharBuffer
+        #define wxWX2WCbuf wxWCharBuffer
+    #endif
 #else // ANSI
     #define wxWxCharBuffer wxCharBuffer