// 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
#include "wx/wxchar.h"
-#include <string.h> // strdup
+#include <stdlib.h> // malloc() and free()
// ----------------------------------------------------------------------------
// Special classes for (wide) character strings: they use malloc/free instead
// of new/delete
// ----------------------------------------------------------------------------
-class wxCharBuffer
-{
-public:
- wxCharBuffer(const char *str)
- : m_str(str ? strdup(str) : NULL)
- {
- wxASSERT_MSG( str, wxT("NULL string in wxCharBuffer") );
- }
+#define DEFINE_BUFFER(classname, chartype, strdupfunc) \
+class WXDLLIMPEXP_BASE classname \
+{ \
+public: \
+ classname(const chartype *str) \
+ : m_str(str ? strdupfunc(str) : NULL) \
+ { \
+ } \
+ \
+ classname(size_t len=0) \
+ : 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);
- wxCharBuffer(size_t len)
- : m_str((char *)malloc((len + 1)*sizeof(char)))
- {
- m_str[len] = '\0';
- }
+#if wxUSE_WCHAR_T
- // no need to check for NULL, free() does it
- ~wxCharBuffer() { free(m_str); }
+DEFINE_BUFFER(wxWCharBuffer, wchar_t, wxStrdupW);
- 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;
- }
+#endif // wxUSE_WCHAR_T
- const char *data() const { return m_str; }
- operator const char *() const { return m_str; }
- char operator[](size_t n) const { return m_str[n]; }
+#undef DEFINE_BUFFER
-private:
- char *m_str;
-};
+#if wxUSE_UNICODE
+ #define wxMB2WXbuf wxWCharBuffer
+ #define wxWX2MBbuf wxCharBuffer
+ #define wxWC2WXbuf wxChar*
+ #define wxWX2WCbuf wxChar*
+#else // ANSI
+ #define wxMB2WXbuf wxChar*
+ #define wxWX2MBbuf wxChar*
+ #define wxWC2WXbuf wxCharBuffer
+ #define wxWX2WCbuf wxWCharBuffer
+#endif // Unicode/ANSI
-#if wxUSE_WCHAR_T
+// ----------------------------------------------------------------------------
+// A class for holding growable data buffers (not necessarily strings)
+// ----------------------------------------------------------------------------
-class wxWCharBuffer
+// This class manages the actual data buffer pointer and is ref-counted.
+class wxMemoryBufferData
{
public:
- wxWCharBuffer(const wchar_t *wcs)
- : m_wcs((wchar_t *)NULL)
- {
- wxASSERT_MSG( wcs, wxT("NULL string in wxWCharBuffer") );
-
- if (wcs) {
-#if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
- || ( defined(__MWERKS__) && defined(__WXMSW__) )
- size_t siz = (std::wcslen(wcs)+1)*sizeof(wchar_t);
-#else
- size_t siz = (::wcslen(wcs)+1)*sizeof(wchar_t);
-#endif
- m_wcs = (wchar_t *)malloc(siz);
- memcpy(m_wcs, wcs, siz);
- }
- }
- wxWCharBuffer(size_t len)
- : m_wcs((wchar_t *)malloc((len + 1)*sizeof(wchar_t)))
+ // 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)
{
- m_wcs[len] = L'\0';
}
+ ~wxMemoryBufferData() { free(m_data); }
- // no need to check for NULL, free() does it
- ~wxWCharBuffer() { free(m_wcs); }
- wxWCharBuffer(const wxWCharBuffer& src)
- : m_wcs(src.m_wcs)
+ void ResizeIfNeeded(size_t newSize)
{
- // no reference count yet...
- ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
+ 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;
+ }
}
- wxWCharBuffer& operator=(const wxWCharBuffer& src)
+
+ void IncRef() { m_ref += 1; }
+ void DecRef()
{
- m_wcs = src.m_wcs;
- // no reference count yet...
- ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
- return *this;
+ m_ref -= 1;
+ if (m_ref == 0) // are there no more references?
+ delete this;
}
- 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]; }
-private:
- wchar_t *m_wcs;
-};
+ // the buffer containing the data
+ void *m_data;
-#endif // wxUSE_WCHAR_T
+ // the size of the buffer
+ size_t m_size;
-#if wxUSE_UNICODE
- #define wxMB2WXbuf wxWCharBuffer
- #define wxWX2MBbuf wxCharBuffer
- #define wxWC2WXbuf wxChar*
- #define wxWX2WCbuf wxChar*
-#else // ANSI
- #define wxMB2WXbuf wxChar*
- #define wxWX2MBbuf wxChar*
- #define wxWC2WXbuf wxCharBuffer
- #define wxWX2WCbuf wxWCharBuffer
-#endif // Unicode/ANSI
+ // the amount of data currently in the buffer
+ size_t m_len;
+
+ // the reference count
+ size_t m_ref;
+
+ DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
+};
-// ----------------------------------------------------------------------------
-// A class for holding growable data buffers (not necessarily strings)
-// ----------------------------------------------------------------------------
class wxMemoryBuffer
{
public:
- enum { BLOCK_SIZE = 1024 };
- wxMemoryBuffer(size_t size = wxMemoryBuffer::BLOCK_SIZE)
- : m_data(malloc(size)), m_size(size), m_len(0)
+ // ctor and dtor
+ wxMemoryBuffer(size_t size = wxMemoryBufferData::DefBufSize)
+ {
+ m_bufdata = new wxMemoryBufferData(size);
+ m_bufdata->IncRef();
+ }
+
+ ~wxMemoryBuffer() { m_bufdata->DecRef(); }
+
+
+ // copy and assignment
+ wxMemoryBuffer(const wxMemoryBuffer& src)
+ : m_bufdata(src.m_bufdata)
+ {
+ m_bufdata->IncRef();
+ }
+
+ wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
{
+ m_bufdata->DecRef();
+ m_bufdata = src.m_bufdata;
+ m_bufdata->IncRef();
+ return *this;
}
- ~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 *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; }
- void SetBufSize(size_t size) { ResizeIfNeeded(size); }
+ void SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
void SetDataLen(size_t len)
{
- wxASSERT(len <= m_size);
- m_len = len;
+ wxASSERT(len <= m_bufdata->m_size);
+ m_bufdata->m_len = len;
}
// Ensure the buffer is big enough and return a pointer to it
- void* GetWriteBuf(size_t sizeNeeded)
+ void *GetWriteBuf(size_t sizeNeeded)
{
- ResizeIfNeeded(sizeNeeded);
- return m_data;
+ m_bufdata->ResizeIfNeeded(sizeNeeded);
+ return m_bufdata->m_data;
}
+
// 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)
- {
- ResizeIfNeeded(m_len + sizeNeeded);
- return (char*)m_data + m_len;
- }
- 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;
- }
- void AppendData(void* data, size_t len)
+ void *GetAppendBuf(size_t sizeNeeded)
{
- memcpy(GetAppendBuf(len), data, len);
- UngetAppendBuf(len);
+ m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded);
+ return (char*)m_bufdata->m_data + m_bufdata->m_len;
}
- operator const char *() const { return (const char*)m_data; }
-
-
- // Copy and assignment
- wxMemoryBuffer(const wxMemoryBuffer& src)
- : m_data(src.m_data), m_size(src.m_size), m_len(src.m_len)
+ // Update the length after the append
+ void UngetAppendBuf(size_t sizeUsed)
{
- // no reference count yet...
- ((wxMemoryBuffer*)&src)->m_data = NULL;
- ((wxMemoryBuffer*)&src)->m_size = 0;
- ((wxMemoryBuffer*)&src)->m_len = 0;
+ SetDataLen(m_bufdata->m_len + sizeUsed);
}
- wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
+ // Other ways to append to the buffer
+ void AppendByte(char data)
{
- 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;
-
- return *this;
- }
+ 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;
+ }
-protected:
- void ResizeIfNeeded(size_t newSize)
+ void AppendData(const void *data, size_t len)
{
- if (newSize > m_size)
- {
- m_data = realloc(m_data, newSize + wxMemoryBuffer::BLOCK_SIZE);
- wxASSERT(m_data != NULL);
- m_size = newSize + wxMemoryBuffer::BLOCK_SIZE;
- }
+ memcpy(GetAppendBuf(len), data, len);
+ UngetAppendBuf(len);
}
+ operator const char *() const { return (const char*)GetData(); }
+
private:
- void* m_data;
- size_t m_size;
- size_t m_len;
+ wxMemoryBufferData* m_bufdata;
};
// ----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff