include the headers needed for its compilation from the header itself

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

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index db3749c7c0253b13f3e0a51bb84848a8d61598e9..346ef113f9b6bb78d4f9f0e653d765e54810c773 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -9,112 +9,235 @@
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // 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__
+
+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
 // ----------------------------------------------------------------------------
 

-#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);
+template <typename T>
+class WXDLLIMPEXP_BASE wxCharTypeBuffer
+{
+public:
+    typedef T CharType;
+
+    wxCharTypeBuffer(const CharType *str = NULL)
+        : m_str(str ? wxStrdup(str) : NULL),
+          m_owned(true)
+    {
+    }
+
+    wxCharTypeBuffer(size_t len)
+        : 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()
+    {
+        if ( m_owned)
+            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 wxCharTypeBuffer 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
+    {
+        wxASSERT_MSG( m_owned, _T("can't release non-owned buffer") );
+        return DoRelease();
+    }
+
+    void reset()
+    {
+        if ( m_owned )
+            free(m_str);
+        m_str = NULL;
+    }
+
+    wxCharTypeBuffer(const wxCharTypeBuffer& src)
+    {
+        CopyFrom(src);
+    }
+
+    wxCharTypeBuffer& operator=(const CharType *str)
+    {
+        if ( m_owned )
+            free(m_str);
+        m_str = str ? wxStrdup(str) : NULL;
+        m_owned = true;
+        return *this;
+    }
+
+    wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
+    {
+        if (&src != this)
+        {
+            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 )
+            return false;
+
+        m_str = str;
+
+        return true;
+    }
+
+    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 *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;
+};
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
+
+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) {}
+
+    wxCharBuffer(const wxCStrData& cstr);
+};

 
 #if wxUSE_WCHAR_T
 
 #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;

 
 

-DEFINE_BUFFER(wxWCharBuffer, wchar_t, wxStrdupW);
+    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
 
 #endif // wxUSE_WCHAR_T
 

-#undef DEFINE_BUFFER
+// 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)
 // ----------------------------------------------------------------------------


@@ -124,13 +247,13 @@ class wxMemoryBufferData
 {
 public:
     // the initial size and also the size added by ResizeIfNeeded()
 {
 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
 private:
 
     friend class wxMemoryBuffer;
 
     // everyting 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)
     {
     }
         : m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)
     {
     }


@@ -142,13 +265,13 @@ private:
         if (newSize > m_size)
         {
             void *dataOld = m_data;
         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);
             }
 
             if ( !m_data )
             {
                 free(dataOld);
             }
 

-            m_size = newSize + wxMemoryBufferData::BLOCK_SIZE;
+            m_size = newSize + wxMemoryBufferData::DefBufSize;

         }
     }
 
         }
     }
 


@@ -177,11 +300,11 @@ private:
 };
 
 
 };
 
 

-class wxMemoryBuffer
+class WXDLLIMPEXP_BASE wxMemoryBuffer

 {
 public:
     // ctor and dtor
 {
 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();
     {
         m_bufdata = new wxMemoryBufferData(size);
         m_bufdata->IncRef();


@@ -199,9 +322,12 @@ public:
 
     wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
     {
 
     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;
     }
 
         return *this;
     }
 


@@ -251,7 +377,7 @@ public:
         m_bufdata->m_len += 1;
     }
 
         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);
     {
         memcpy(GetAppendBuf(len), data, len);
         UngetAppendBuf(len);