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 cd4d760661e52952a753ed36c77ec530887b7ce9..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); }
@@ -27,29 +30,38 @@ inline char *wxStrDup(const char *s) { return wxStrdupA(s); }
 // ----------------------------------------------------------------------------
 
 template <typename T>
-class WXDLLIMPEXP_BASE wxCharTypeBuffer
+class wxCharTypeBuffer
 {
 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(const wxCStrData& cstr)
+    wxCharTypeBuffer(size_t len)
+        : m_str((CharType *)malloc((len + 1)*sizeof(CharType))),
+          m_owned(true)
     {
-        FromCStrData(cstr);
+        m_str[len] = (CharType)0;
     }
 
-    wxCharTypeBuffer(size_t len)
-        : m_str((CharType *)malloc((len + 1)*sizeof(CharType)))
+    static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
     {
-        m_str[len] = (CharType)0;
+        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:
@@ -60,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...)
     */
@@ -71,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 )
@@ -119,40 +135,91 @@ public:
     operator const CharType *() const { return m_str; }
     CharType operator[](size_t n) const { return m_str[n]; }
 
+
 private:
-    void FromCStrData(const wxCStrData& cstr);
+    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>
 {
 public:
-    wxCharBuffer(const CharType *str = NULL) : wxCharTypeBuffer<char>(str) {}
-    wxCharBuffer(const wxCStrData& cstr) : wxCharTypeBuffer<char>(cstr) {}
-    wxCharBuffer(size_t len) : wxCharTypeBuffer<char>(len) {}
+    typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
+
+    wxCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
+    wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
+    wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
+
+    wxCharBuffer(const wxCStrData& cstr);
 };
 
 #if wxUSE_WCHAR_T
 class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
 {
 public:
-    wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBuffer<wchar_t>(str) {}
-    wxWCharBuffer(const wxCStrData& cstr) : wxCharTypeBuffer<wchar_t>(cstr) {}
-    wxWCharBuffer(size_t len) : wxCharTypeBuffer<wchar_t>(len) {}
+    typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
+
+    wxWCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
+    wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
+    wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
+
+    wxWCharBuffer(const wxCStrData& cstr);
 };
 #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
-    typedef wxWCharBuffer wxWxCharBuffer;
+    #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
-    typedef wxCharBuffer wxWxCharBuffer;
+    #define wxWxCharBuffer wxCharBuffer
 
     #define wxMB2WXbuf wxChar*
     #define wxWX2MBbuf wxChar*