Minor corrections to make dist after reports

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

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index 9415229b9c236412ab37e226ec19d73128c53011..32443237373ac92b4429d53f69cfe227f3dac051 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -1,243 +1,435 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        buffer.h
+// Name:        wx/buffer.h

 // Purpose:     auto buffer classes: buffers which automatically free memory
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     12.04.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Purpose:     auto buffer classes: buffers which automatically free memory
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     12.04.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
 

-// these classes are for private use only for now, they're not documented
-

 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 
 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 

-#include "wx/wxchar.h"
+#include "wx/chartype.h"
+#include "wx/wxcrtbase.h"
+
+#ifndef __WXPALMOS5__
+#include <stdlib.h>             // malloc() and free()
+#endif // ! __WXPALMOS5__

 
 

-#include <string.h> // strdup
+class WXDLLIMPEXP_FWD_BASE wxCStrData;

 
 // ----------------------------------------------------------------------------
 // Special classes for (wide) character strings: they use malloc/free instead
 // of new/delete
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // Special classes for (wide) character strings: they use malloc/free instead
 // of new/delete
 // ----------------------------------------------------------------------------
 

-class wxCharBuffer
+template <typename T>
+class WXDLLIMPEXP_BASE wxCharTypeBuffer

 {
 public:
 {
 public:

-    wxCharBuffer(const char *str)
-        : m_str(NULL)
+    typedef T CharType;
+
+    wxCharTypeBuffer(const CharType *str = NULL)

     {
     {

-        wxASSERT_MSG( str, wxT("NULL string in wxCharBuffer") );
+        if ( str )
+            m_data = new Data(wxStrdup(str));
+        else
+            m_data = &NullData;
+    }

 
 

-        m_str = str ? strdup(str) : (char *)NULL;
+    wxCharTypeBuffer(size_t len)
+    {
+        m_data = new Data((CharType *)malloc((len + 1)*sizeof(CharType)));
+        m_data->m_str[len] = (CharType)0;

     }
     }

-    wxCharBuffer(size_t len)
-        : m_str(NULL)
+
+    static const wxCharTypeBuffer CreateNonOwned(const CharType *str)

     {
     {

-        m_str = (char *)malloc(len+1);
-        m_str[len] = '\0';
+        wxCharTypeBuffer buf;
+        if ( str )
+            buf.m_data = new Data(wx_const_cast(CharType*, str), Data::NonOwned);
+        return buf;

     }
     }

-    // 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;
-   }
+    ~wxCharTypeBuffer()
+    {
+        DecRef();
+    }

 
 

-   const char *data() const { return m_str; }
-   operator const char *() const { return m_str; }
-   char operator[](size_t n) const { return m_str[n]; }
+    // 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 == &NullData )
+            return NULL;

 
 

-private:
-   char *m_str;
-};
+        wxASSERT_MSG( m_data->m_owned, _T("can't release non-owned buffer") );
+        wxASSERT_MSG( m_data->m_ref == 1, _T("can't release shared buffer") );

 
 

-#if wxUSE_WCHAR_T
-class wxWCharBuffer
-{
-public:
-    wxWCharBuffer(const wchar_t *wcs)
-        : m_wcs((wchar_t *)NULL)
+        CharType *p = m_data->m_str;
+
+        wxCharTypeBuffer *self = wx_const_cast(wxCharTypeBuffer*, this);
+        self->m_data->m_str = NULL;
+        self->DecRef();
+
+        return p;
+    }
+
+    void reset()
+    {
+        DecRef();
+    }
+
+    wxCharTypeBuffer(const wxCharTypeBuffer& src)
+    {
+        m_data = src.m_data;
+        IncRef();
+    }
+
+    wxCharTypeBuffer& operator=(const CharType *str)
+    {
+        DecRef();
+
+        if ( str )
+            m_data = new Data(wxStrdup(str));
+        return *this;
+    }
+
+    wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
+    {
+        if ( &src == this )
+            return *this;
+
+        DecRef();
+        m_data = src.m_data;
+        IncRef();
+
+        return *this;
+    }
+
+    bool extend(size_t len)
+    {
+        wxASSERT_MSG( m_data->m_owned, _T("cannot extend non-owned buffer") );
+        wxASSERT_MSG( m_data->m_ref == 1, _T("can't extend shared buffer") );
+
+        CharType *str =
+            (CharType *)realloc(data(), (len + 1) * sizeof(CharType));
+        if ( !str )
+            return false;
+
+        if ( m_data == &NullData )
+        {
+            m_data = new Data(str);
+        }
+        else
+        {
+            m_data->m_str = str;
+            m_data->m_owned = true;
+        }
+
+        return true;
+    }
+
+    CharType *data() { return m_data->m_str; }
+    const CharType *data() const { return  m_data->m_str; }
+    operator const CharType *() const { return data(); }
+    CharType operator[](size_t n) const { return data()[n]; }
+
+private:
+    // reference-counted data
+    struct Data

     {
     {

-        wxASSERT_MSG( wcs, wxT("NULL string in wxWCharBuffer") );
+        enum Kind
+        {
+            Owned,
+            NonOwned
+        };
+
+        Data(CharType *str, Kind kind = Owned)
+            : m_str(str), m_ref(1), m_owned(kind == Owned) {}
+
+        ~Data()
+        {
+            if ( m_owned )
+                free(m_str);
+        }

 
 

-        if (wcs) {
-#if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
-    || ( defined(__MWERKS__) && defined(__WXMSW__) )
-          size_t siz = (std::wcslen(wcs)+1)*sizeof(wchar_t);
+        CharType *m_str;
+
+        // "short" to have sizeof(Data)=8 on 32bit archs
+        unsigned short m_ref;
+
+        bool m_owned;
+    };
+
+    // placeholder for NULL string, to simplify this code
+    // NB: this is defined in string.cpp, not (non-existent) buffer.cpp
+#ifdef __MINGW32__
+    // MinGW requires explicit WXDLLIMPEXP_DATA_BASE to avoid compilation
+    // errors
+    static WXDLLIMPEXP_DATA_BASE(Data) NullData;

 #else
 #else

-          size_t siz = (::wcslen(wcs)+1)*sizeof(wchar_t);
+    // but Visual C++ doesn't like it
+    static Data NullData;

 #endif
 #endif

-          m_wcs = (wchar_t *)malloc(siz);
-          memcpy(m_wcs, wcs, siz);
-        }
+
+    void IncRef()
+    {
+        if ( m_data == &NullData ) // exception, not ref-counted
+            return;
+        m_data->m_ref++;

     }
     }

-    wxWCharBuffer(size_t len)
-        : m_wcs((wchar_t *)NULL)
+
+    void DecRef()

     {
     {

-        m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t));
-        m_wcs[len] = L'\0';
+        if ( m_data == &NullData ) // exception, not ref-counted
+            return;
+        if ( --m_data->m_ref == 0 )
+            delete m_data;
+        m_data = &NullData;

     }
 
     }
 

-    // no need to check for NULL, free() does it
-   ~wxWCharBuffer() { free(m_wcs); }
+private:
+    Data *m_data;
+};
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )

 
 

-   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;
-   }
+class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
+{
+public:
+    typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;

 
 

-   const wchar_t *data() const { return m_wcs; }
-   operator const wchar_t *() const { return m_wcs; }
-   wchar_t operator[](size_t n) const { return m_wcs[n]; }
+    wxCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}

 
 

-private:
-   wchar_t *m_wcs;
+    wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
+    wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
+
+    wxCharBuffer(const wxCStrData& cstr);

 };
 };

-#endif
+
+#if wxUSE_WCHAR_T
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
+
+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) {}
+
+    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
 
 #if wxUSE_UNICODE

+    #define wxWxCharBuffer wxWCharBuffer
+

     #define wxMB2WXbuf wxWCharBuffer
     #define wxWX2MBbuf wxCharBuffer
     #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
 #else // ANSI

+    #define wxWxCharBuffer wxCharBuffer
+

     #define wxMB2WXbuf wxChar*
     #define wxWX2MBbuf wxChar*
     #define wxWC2WXbuf wxCharBuffer
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 
     #define wxMB2WXbuf wxChar*
     #define wxWX2MBbuf wxChar*
     #define wxWC2WXbuf wxCharBuffer
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 

-
+// type of the value returned by wxString::utf8_str()
+#if wxUSE_UNICODE_UTF8
+    #define wxUTF8Buf char *
+#else
+    #define wxUTF8Buf wxCharBuffer
+#endif

 
 // ----------------------------------------------------------------------------
 // A class for holding growable data buffers (not necessarily strings)
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // A class for holding growable data buffers (not necessarily strings)
 // ----------------------------------------------------------------------------
 

-class wxMemoryBuffer
+// This class manages the actual data buffer pointer and is ref-counted.
+class wxMemoryBufferData

 {
 public:
 {
 public:

-    enum { BLOCK_SIZE = 1024 };
-    wxMemoryBuffer(size_t size=wxMemoryBuffer::BLOCK_SIZE)
-        : m_data(NULL), m_size(0), m_len(0)
+    // the initial size and also the size added by ResizeIfNeeded()
+    enum { DefBufSize = 1024 };
+
+    friend class wxMemoryBuffer;
+
+    // everyting is private as it can only be used by wxMemoryBuffer
+private:
+    wxMemoryBufferData(size_t size = wxMemoryBufferData::DefBufSize)
+        : m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)

     {
     {

-        wxASSERT(size > 0);
-        m_data = malloc(size);
-        wxASSERT(m_data != NULL);
-        m_size = size;

     }
     }

+    ~wxMemoryBufferData() { free(m_data); }

 
 

-    ~wxMemoryBuffer() { free(m_data); }
-
-    // Accessors
-    void*  GetData() const    { return m_data; }
-    size_t GetBufSize() const { return m_size; }
-    size_t GetDataLen() const { return m_len; }

 
 

-    void   SetBufSize(size_t size) { ResizeIfNeeded(size); }
-    void   SetDataLen(size_t len)
+    void ResizeIfNeeded(size_t newSize)

     {
     {

-        wxASSERT(len <= m_size);
-        m_len = len;
+        if (newSize > m_size)
+        {
+            void *dataOld = m_data;
+            m_data = realloc(m_data, newSize + wxMemoryBufferData::DefBufSize);
+            if ( !m_data )
+            {
+                free(dataOld);
+            }
+
+            m_size = newSize + wxMemoryBufferData::DefBufSize;
+        }

     }
 
     }
 

-    // Ensure the buffer is big enough and return a pointer to it
-    void* GetWriteBuf(size_t sizeNeeded)
+    void IncRef() { m_ref += 1; }
+    void DecRef()

     {
     {

-        ResizeIfNeeded(sizeNeeded);
-        return m_data;
+        m_ref -= 1;
+        if (m_ref == 0)  // are there no more references?
+            delete this;

     }
     }

-    // Update the length after the write
-    void  UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }

 
 

-    // Like the above, but appends to the buffer
-    void* GetAppendBuf(size_t sizeNeeded)
+
+    // the buffer containing the data
+    void  *m_data;
+
+    // the size of the buffer
+    size_t m_size;
+
+    // the amount of data currently in the buffer
+    size_t m_len;
+
+    // the reference count
+    size_t m_ref;
+
+    DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
+};
+
+
+class WXDLLIMPEXP_BASE wxMemoryBuffer
+{
+public:
+    // ctor and dtor
+    wxMemoryBuffer(size_t size = wxMemoryBufferData::DefBufSize)

     {
     {

-        ResizeIfNeeded(m_len + sizeNeeded);
-        return (char*)m_data + m_len;
+        m_bufdata = new wxMemoryBufferData(size);
+        m_bufdata->IncRef();

     }
     }

-    void  UngetAppendBuf(size_t sizeUsed) { SetDataLen(m_len + sizeUsed); }

 
 

-    // Other ways to append to the buffer
-    void  AppendByte(char data) {
-        ResizeIfNeeded(m_len + 1);
-        *(((char*)m_data)+m_len) = data;
-        m_len += 1;
+    ~wxMemoryBuffer() { m_bufdata->DecRef(); }
+
+
+    // copy and assignment
+    wxMemoryBuffer(const wxMemoryBuffer& src)
+        : m_bufdata(src.m_bufdata)
+    {
+        m_bufdata->IncRef();

     }
     }

-    void  AppendData(void* data, size_t len)
+
+    wxMemoryBuffer& operator=(const wxMemoryBuffer& src)

     {
     {

-        memcpy(GetAppendBuf(len), data, len);
-        UngetAppendBuf(len);
+        if (&src != this)
+        {
+            m_bufdata->DecRef();
+            m_bufdata = src.m_bufdata;
+            m_bufdata->IncRef();
+        }
+        return *this;

     }
 
     }
 

-    operator const char *() const { return (const char*)m_data; }

 
 

+    // Accessors
+    void  *GetData() const    { return m_bufdata->m_data; }
+    size_t GetBufSize() const { return m_bufdata->m_size; }
+    size_t GetDataLen() const { return m_bufdata->m_len; }

 
 

-    // Copy and assignment
-    wxMemoryBuffer(const wxMemoryBuffer& src)
-        : m_data(src.m_data), m_size(src.m_size), m_len(src.m_len)
+    void   SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
+    void   SetDataLen(size_t len)

     {
     {

-        // no reference count yet...
-        ((wxMemoryBuffer*)&src)->m_data = NULL;
-        ((wxMemoryBuffer*)&src)->m_size = 0;
-        ((wxMemoryBuffer*)&src)->m_len  = 0;
+        wxASSERT(len <= m_bufdata->m_size);
+        m_bufdata->m_len = len;

     }
 
     }
 

-    wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
+    // Ensure the buffer is big enough and return a pointer to it
+    void *GetWriteBuf(size_t sizeNeeded)

     {
     {

-        m_data = src.m_data;
-        m_size = src.m_size;
-        m_len  = src.m_len;
-        
-        // no reference count yet...
-        ((wxMemoryBuffer*)&src)->m_data = NULL;
-        ((wxMemoryBuffer*)&src)->m_size = 0;
-        ((wxMemoryBuffer*)&src)->m_len  = 0;
+        m_bufdata->ResizeIfNeeded(sizeNeeded);
+        return m_bufdata->m_data;
+    }

 
 

-        return *this;
-   }
+    // Update the length after the write
+    void  UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }

 
 

+    // Like the above, but appends to the buffer
+    void *GetAppendBuf(size_t sizeNeeded)
+    {
+        m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded);
+        return (char*)m_bufdata->m_data + m_bufdata->m_len;
+    }

 
 

-protected:
+    // Update the length after the append
+    void  UngetAppendBuf(size_t sizeUsed)
+    {
+        SetDataLen(m_bufdata->m_len + sizeUsed);
+    }

 
 

-    void ResizeIfNeeded(size_t newSize)
+    // Other ways to append to the buffer
+    void  AppendByte(char data)

     {
     {

-        if (newSize > m_size)
-        {
-            m_data = realloc(m_data, newSize + wxMemoryBuffer::BLOCK_SIZE);
-            wxASSERT(m_data != NULL);
-            m_size = newSize + wxMemoryBuffer::BLOCK_SIZE;
-        }
+        wxCHECK_RET( m_bufdata->m_data, _T("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;

     }
 
     }
 

-private:
-    void*       m_data;
-    size_t      m_size;
-    size_t      m_len;
-};
+    void  AppendData(const void *data, size_t len)
+    {
+        memcpy(GetAppendBuf(len), data, len);
+        UngetAppendBuf(len);
+    }

 
 

+    operator const char *() const { return (const char*)GetData(); }

 
 

+private:
+    wxMemoryBufferData*  m_bufdata;
+};

 
 // ----------------------------------------------------------------------------
 // template class for any kind of data
 
 // ----------------------------------------------------------------------------
 // template class for any kind of data