X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9b386ecadb0f98fb92cfaad786dcc26915a070bd..438959cca892a7651634cc3a7aad4819ac49b23c:/include/wx/buffer.h

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index 1396ef5d26..951777a13c 100644
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -12,103 +12,414 @@
 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 
-#include "wx/wxchar.h"
+#include "wx/chartype.h"
+#include "wx/wxcrtbase.h"
 
 #include <stdlib.h>             // malloc() and free()
 
+class WXDLLIMPEXP_FWD_BASE wxCStrData;
+
 // ----------------------------------------------------------------------------
 // Special classes for (wide) character strings: they use malloc/free instead
 // of new/delete
 // ----------------------------------------------------------------------------
 
-#define DEFINE_BUFFER(classname, chartype, strdupfunc)                      \
-class classname                                                             \
-{                                                                           \
-public:                                                                     \
-    classname(const chartype *str)                                          \
-        : m_str(str ? strdupfunc(str) : NULL)                               \
-    {                                                                       \
-    }                                                                       \
-                                                                            \
-    classname(size_t len)                                                   \
-        : m_str((chartype *)malloc((len + 1)*sizeof(chartype)))             \
-    {                                                                       \
-        m_str[len] = (chartype)0;                                           \
-    }                                                                       \
-                                                                            \
-    /* no need to check for NULL, free() does it */                         \
-    ~classname() { free(m_str); }                                           \
-                                                                            \
-    /*                                                                      \
-        WARNING:                                                            \
-                                                                            \
-        the copy ctor and assignment operators change the passed in object  \
-        even although it is declared as "const", so:                        \
-                                                                            \
-        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\
-        of classname buffer objects possible and is very similar to what    \
-        std::auto_ptr<> does (as if it were an excuse...)                   \
-    */                                                                      \
-                                                                            \
-    /*                                                                      \
-       because of the remark above, release() is declared const even if it  \
-       isn't really const                                                   \
-     */                                                                     \
-    chartype *release() const                                               \
-    {                                                                       \
-        chartype *p = m_str;                                                \
-        ((classname *)this)->m_str = NULL;                                  \
-        return p;                                                           \
-    }                                                                       \
-                                                                            \
-    classname(const classname& src)                                         \
-        : m_str(src.release())                                              \
-    {                                                                       \
-    }                                                                       \
-                                                                            \
-    classname& operator=(const chartype *str)                               \
-    {                                                                       \
-        free(m_str);                                                        \
-        m_str = str ? strdupfunc(str) : NULL;                               \
-        return *this;                                                       \
-    }                                                                       \
-                                                                            \
-    classname& operator=(const classname& src)                              \
-    {                                                                       \
-        free(m_str);                                                        \
-        m_str = src.release();                                              \
-                                                                            \
-        return *this;                                                       \
-    }                                                                       \
-                                                                            \
-    chartype *data() { return m_str; }                                      \
-    const chartype *data() const { return m_str; }                          \
-    operator const chartype *() const { return m_str; }                     \
-    chartype operator[](size_t n) const { return m_str[n]; }                \
-                                                                            \
-private:                                                                    \
-    chartype *m_str;                                                        \
-}
-
-DEFINE_BUFFER(wxCharBuffer, char, wxStrdupA);
-
-#if wxUSE_WCHAR_T
-
-DEFINE_BUFFER(wxWCharBuffer, wchar_t, wxStrdupW);
-
-#endif // wxUSE_WCHAR_T
-
-#undef DEFINE_BUFFER
+// helpers used by wxCharTypeBuffer
+namespace wxPrivate
+{
+
+struct UntypedBufferData
+{
+    enum Kind
+    {
+        Owned,
+        NonOwned
+    };
+
+    UntypedBufferData(void *str, size_t len, Kind kind = Owned)
+        : m_str(str), m_length(len), m_ref(1), m_owned(kind == Owned) {}
+
+    ~UntypedBufferData()
+    {
+        if ( m_owned )
+            free(m_str);
+    }
+
+    void *m_str;
+    size_t m_length;
+
+    // "short" to have sizeof(Data)=12 on 32bit archs
+    unsigned short m_ref;
+
+    bool m_owned;
+};
+
+// NB: this is defined in string.cpp and not the (non-existent) buffer.cpp
+WXDLLIMPEXP_BASE UntypedBufferData * GetUntypedNullData();
+
+} // namespace wxPrivate
+
+
+// Reference-counted character buffer for storing string data. The buffer
+// is only valid for as long as the "parent" object that provided the data
+// is valid; see wxCharTypeBuffer<T> for persistent variant.
+template <typename T>
+class wxScopedCharTypeBuffer
+{
+public:
+    typedef T CharType;
+
+    wxScopedCharTypeBuffer()
+    {
+        m_data = GetNullData();
+    }
+
+    // Creates "non-owned" buffer, i.e. 'str' is not owned by the buffer
+    // and doesn't get freed by dtor. Used e.g. to point to wxString's internal
+    // storage.
+    static
+    const wxScopedCharTypeBuffer CreateNonOwned(const CharType *str,
+                                                size_t len = wxNO_LEN)
+    {
+        if ( len == wxNO_LEN )
+            len = wxStrlen(str);
+
+        wxScopedCharTypeBuffer buf;
+        if ( str )
+            buf.m_data = new Data(const_cast<CharType*>(str), len, Data::NonOwned);
+        return buf;
+    }
+
+    // Creates "owned" buffer, i.e. takes over ownership of 'str' and frees it
+    // in dtor (if ref.count reaches 0).
+    static
+    const wxScopedCharTypeBuffer CreateOwned(CharType *str,
+                                             size_t len = wxNO_LEN )
+    {
+        if ( len == wxNO_LEN )
+            len = wxStrlen(str);
+
+        wxScopedCharTypeBuffer buf;
+        if ( str )
+            buf.m_data = new Data(str, len);
+        return buf;
+    }
+
+    wxScopedCharTypeBuffer(const wxScopedCharTypeBuffer& src)
+    {
+        m_data = src.m_data;
+        IncRef();
+    }
+
+    wxScopedCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& src)
+    {
+        if ( &src == this )
+            return *this;
+
+        DecRef();
+        m_data = src.m_data;
+        IncRef();
+
+        return *this;
+    }
+
+    ~wxScopedCharTypeBuffer()
+    {
+        DecRef();
+    }
+
+    // NB: this method is only const for backward compatibility. It used to
+    //     be needed for auto_ptr-like semantics of the copy ctor, but now
+    //     that ref-counting is used, it's not really needed.
+    CharType *release() const
+    {
+        if ( m_data == GetNullData() )
+            return NULL;
+
+        wxASSERT_MSG( m_data->m_owned, wxT("can't release non-owned buffer") );
+        wxASSERT_MSG( m_data->m_ref == 1, wxT("can't release shared buffer") );
+
+        CharType * const p = m_data->Get();
+
+        wxScopedCharTypeBuffer *self = const_cast<wxScopedCharTypeBuffer*>(this);
+        self->m_data->Set(NULL, 0);
+        self->DecRef();
+
+        return p;
+    }
+
+    void reset()
+    {
+        DecRef();
+    }
+
+    CharType *data() { return m_data->Get(); }
+    const CharType *data() const { return  m_data->Get(); }
+    operator const CharType *() const { return data(); }
+    CharType operator[](size_t n) const { return data()[n]; }
+
+    size_t length() const { return m_data->m_length; }
+
+protected:
+    // reference-counted data
+    struct Data : public wxPrivate::UntypedBufferData
+    {
+        Data(CharType *str, size_t len, Kind kind = Owned)
+            : wxPrivate::UntypedBufferData(str, len, kind)
+        {
+        }
+
+        CharType *Get() const { return static_cast<CharType *>(m_str); }
+        void Set(CharType *str, size_t len)
+        {
+            m_str = str;
+            m_length = len;
+        }
+    };
+
+    // placeholder for NULL string, to simplify this code
+    static Data *GetNullData()
+    {
+        return static_cast<Data *>(wxPrivate::GetUntypedNullData());
+    }
+
+    void IncRef()
+    {
+        if ( m_data == GetNullData() ) // exception, not ref-counted
+            return;
+        m_data->m_ref++;
+    }
+
+    void DecRef()
+    {
+        if ( m_data == GetNullData() ) // exception, not ref-counted
+            return;
+        if ( --m_data->m_ref == 0 )
+            delete m_data;
+        m_data = GetNullData();
+    }
+
+    // sets this object to a be copy of 'other'; if 'src' is non-owned,
+    // a deep copy is made and 'this' will contain new instance of the data
+    void MakeOwnedCopyOf(const wxScopedCharTypeBuffer& src)
+    {
+        this->DecRef();
+
+        if ( src.m_data == this->GetNullData() )
+        {
+            this->m_data = this->GetNullData();
+        }
+        else if ( src.m_data->m_owned )
+        {
+            this->m_data = src.m_data;
+            this->IncRef();
+        }
+        else
+        {
+            // if the scoped buffer had non-owned data, we have to make
+            // a copy here, because src.m_data->m_str is valid only for as long
+            // as 'src' exists
+            this->m_data = new Data
+                               (
+                                   StrCopy(src.data(), src.length()),
+                                   src.length()
+                               );
+        }
+    }
+
+    static CharType *StrCopy(const CharType *src, size_t len)
+    {
+        CharType *dst = (CharType*)malloc(sizeof(CharType) * (len + 1));
+        if ( dst )
+            memcpy(dst, src, sizeof(CharType) * (len + 1));
+        return dst;
+    }
+
+protected:
+    Data *m_data;
+};
+
+typedef wxScopedCharTypeBuffer<char> wxScopedCharBuffer;
+typedef wxScopedCharTypeBuffer<wchar_t> wxScopedWCharBuffer;
+
+
+// this buffer class always stores data in "owned" (persistent) manner
+template <typename T>
+class wxCharTypeBuffer : public wxScopedCharTypeBuffer<T>
+{
+protected:
+    typedef typename wxScopedCharTypeBuffer<T>::Data Data;
+
+public:
+    typedef T CharType;
+
+    wxCharTypeBuffer(const CharType *str = NULL, size_t len = wxNO_LEN)
+    {
+        if ( str )
+        {
+            if ( len == wxNO_LEN )
+                len = wxStrlen(str);
+            this->m_data = new Data(this->StrCopy(str, len), len);
+        }
+        else
+        {
+            this->m_data = this->GetNullData();
+        }
+    }
+
+    wxCharTypeBuffer(size_t len)
+    {
+        this->m_data =
+            new Data((CharType *)malloc((len + 1)*sizeof(CharType)), len);
+        this->m_data->Get()[len] = (CharType)0;
+    }
+
+    wxCharTypeBuffer(const wxCharTypeBuffer& src)
+        : wxScopedCharTypeBuffer<T>(src) {}
+
+    wxCharTypeBuffer& operator=(const CharType *str)
+    {
+        this->DecRef();
+
+        if ( str )
+            this->m_data = new Data(wxStrdup(str), wxStrlen(str));
+        return *this;
+    }
+
+    wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
+    {
+        wxScopedCharTypeBuffer<T>::operator=(src);
+        return *this;
+    }
+
+    wxCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
+    {
+        this->MakeOwnedCopyOf(src);
+    }
+
+    wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer<T>& src)
+    {
+        MakeOwnedCopyOf(src);
+        return *this;
+    }
+
+    bool extend(size_t len)
+    {
+        wxASSERT_MSG( this->m_data->m_owned, "cannot extend non-owned buffer" );
+        wxASSERT_MSG( this->m_data->m_ref == 1, "can't extend shared buffer" );
+
+        CharType *str =
+            (CharType *)realloc(this->data(), (len + 1) * sizeof(CharType));
+        if ( !str )
+            return false;
+
+        // For consistency with the ctor taking just the length, NUL-terminate
+        // the buffer.
+        str[len] = (CharType)0;
+
+        if ( this->m_data == this->GetNullData() )
+        {
+            this->m_data = new Data(str, len);
+        }
+        else
+        {
+            this->m_data->Set(str, len);
+            this->m_data->m_owned = true;
+        }
+
+        return true;
+    }
+
+    void shrink(size_t len)
+    {
+        wxASSERT_MSG( this->m_data->m_owned, "cannot shrink non-owned buffer" );
+        wxASSERT_MSG( this->m_data->m_ref == 1, "can't shrink shared buffer" );
+
+        wxASSERT( len <= this->length() );
+
+        this->m_data->m_length = len;
+        this->data()[len] = 0;
+    }
+};
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<char> )
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
+
+class wxCharBuffer : public wxCharTypeBuffer<char>
+{
+public:
+    typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
+    typedef wxScopedCharTypeBuffer<char> wxScopedCharTypeBufferBase;
+
+    wxCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+    wxCharBuffer(const wxScopedCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
+    wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
+    wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
+
+    wxCharBuffer(const wxCStrData& cstr);
+};
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<wchar_t> )
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
+
+class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
+{
+public:
+    typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
+    typedef wxScopedCharTypeBuffer<wchar_t> wxScopedCharTypeBufferBase;
+
+    wxWCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+    wxWCharBuffer(const wxScopedCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+
+    wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
+    wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
+
+    wxWCharBuffer(const wxCStrData& cstr);
+};
+
+// wxCharTypeBuffer<T> implicitly convertible to T*
+template <typename T>
+class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
+{
+public:
+    typedef typename wxScopedCharTypeBuffer<T>::CharType CharType;
+
+    wxWritableCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
+        : wxCharTypeBuffer<T>(src) {}
+    // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
+    //             always return a buffer
+    //             + we should derive this class from wxScopedCharTypeBuffer
+    //               then
+    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
+
     #define wxMB2WXbuf wxChar*
     #define wxWX2MBbuf wxChar*
     #define wxWC2WXbuf wxCharBuffer
@@ -124,13 +435,13 @@ class wxMemoryBufferData
 {
 public:
     // the initial size and also the size added by ResizeIfNeeded()
-    enum { BLOCK_SIZE = 1024 };
+    enum { DefBufSize = 1024 };
 
     friend class wxMemoryBuffer;
 
-    // everyting is private as it can only be used by wxMemoryBuffer
+    // everything is private as it can only be used by wxMemoryBuffer
 private:
-    wxMemoryBufferData(size_t size = wxMemoryBufferData::BLOCK_SIZE)
+    wxMemoryBufferData(size_t size = wxMemoryBufferData::DefBufSize)
         : m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)
     {
     }
@@ -142,13 +453,13 @@ private:
         if (newSize > m_size)
         {
             void *dataOld = m_data;
-            m_data = realloc(m_data, newSize + wxMemoryBufferData::BLOCK_SIZE);
+            m_data = realloc(m_data, newSize + wxMemoryBufferData::DefBufSize);
             if ( !m_data )
             {
                 free(dataOld);
             }
 
-            m_size = newSize + wxMemoryBufferData::BLOCK_SIZE;
+            m_size = newSize + wxMemoryBufferData::DefBufSize;
         }
     }
 
@@ -160,6 +471,21 @@ private:
             delete this;
     }
 
+    void *release()
+    {
+        if ( m_data == NULL )
+            return NULL;
+
+        wxASSERT_MSG( m_ref == 1, "can't release shared buffer" );
+
+        void *p = m_data;
+        m_data = NULL;
+        m_len =
+        m_size = 0;
+
+        return p;
+    }
+
 
     // the buffer containing the data
     void  *m_data;
@@ -173,7 +499,7 @@ private:
     // the reference count
     size_t m_ref;
 
-    DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
+    wxDECLARE_NO_COPY_CLASS(wxMemoryBufferData);
 };
 
 
@@ -181,7 +507,7 @@ class wxMemoryBuffer
 {
 public:
     // ctor and dtor
-    wxMemoryBuffer(size_t size = wxMemoryBufferData::BLOCK_SIZE)
+    wxMemoryBuffer(size_t size = wxMemoryBufferData::DefBufSize)
     {
         m_bufdata = new wxMemoryBufferData(size);
         m_bufdata->IncRef();
@@ -199,9 +525,12 @@ public:
 
     wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
     {
-        m_bufdata->DecRef();
-        m_bufdata = src.m_bufdata;
-        m_bufdata->IncRef();
+        if (&src != this)
+        {
+            m_bufdata->DecRef();
+            m_bufdata = src.m_bufdata;
+            m_bufdata->IncRef();
+        }
         return *this;
     }
 
@@ -211,6 +540,8 @@ public:
     size_t GetBufSize() const { return m_bufdata->m_size; }
     size_t GetDataLen() const { return m_bufdata->m_len; }
 
+    bool IsEmpty() const { return GetDataLen() == 0; }
+
     void   SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
     void   SetDataLen(size_t len)
     {
@@ -218,6 +549,8 @@ public:
         m_bufdata->m_len = len;
     }
 
+    void Clear() { SetDataLen(0); }
+
     // Ensure the buffer is big enough and return a pointer to it
     void *GetWriteBuf(size_t sizeNeeded)
     {
@@ -244,14 +577,14 @@ public:
     // Other ways to append to the buffer
     void  AppendByte(char data)
     {
-        wxCHECK_RET( m_bufdata->m_data, _T("invalid wxMemoryBuffer") );
+        wxCHECK_RET( m_bufdata->m_data, wxT("invalid wxMemoryBuffer") );
 
         m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
         *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;
         m_bufdata->m_len += 1;
     }
 
-    void  AppendData(void* data, size_t len)
+    void  AppendData(const void *data, size_t len)
     {
         memcpy(GetAppendBuf(len), data, len);
         UngetAppendBuf(len);
@@ -259,6 +592,13 @@ public:
 
     operator const char *() const { return (const char*)GetData(); }
 
+    // gives up ownership of data, returns the pointer; after this call,
+    // data isn't freed by the buffer and its content is resent to empty
+    void *release()
+    {
+        return m_bufdata->release();
+    }
+
 private:
     wxMemoryBufferData*  m_bufdata;
 };