X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e93e5b0bb68da7a2b9b002f6af5f40e41d4711ed..9a62fa17b1c342b5b1e1bb9b96373e170a9d8b6f:/include/wx/buffer.h diff --git a/include/wx/buffer.h b/include/wx/buffer.h index 3b770e32af..f17aa0c1ab 100644 --- a/include/wx/buffer.h +++ b/include/wx/buffer.h @@ -6,220 +6,283 @@ // Created: 12.04.99 // RCS-ID: $Id$ // Copyright: (c) 1998 Vadim Zeitlin -// 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 // strdup +#include // 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) - { - } +#define DEFINE_BUFFER(classname, chartype, strdupfunc) \ +class WXDLLIMPEXP_BASE classname \ +{ \ +public: \ + classname(const chartype *str = NULL) \ + : 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; \ + } \ + \ + void reset() \ + { \ + free(m_str); \ + m_str = NULL; \ + } \ + \ + 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; \ + } \ + \ + bool extend(size_t len) \ + { \ + 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 *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 + typedef wxWCharBuffer wxWxCharBuffer; -#if wxUSE_WCHAR_T + #define wxMB2WXbuf wxWCharBuffer + #define wxWX2MBbuf wxCharBuffer + #define wxWC2WXbuf wxChar* + #define wxWX2WCbuf wxChar* +#else // ANSI + typedef wxCharBuffer wxWxCharBuffer; + + #define wxMB2WXbuf wxChar* + #define wxWX2MBbuf wxChar* + #define wxWC2WXbuf wxCharBuffer + #define wxWX2WCbuf wxWCharBuffer +#endif // Unicode/ANSI -class wxWCharBuffer +// ---------------------------------------------------------------------------- +// A class for holding growable data buffers (not necessarily strings) +// ---------------------------------------------------------------------------- + +// 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) - { - if (wcs) { - size_t siz = (wxWcslen(wcs) + 1)*sizeof(wchar_t); - 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) + void *GetAppendBuf(size_t sizeNeeded) { - ResizeIfNeeded(m_len + sizeNeeded); - return (char*)m_data + m_len; + m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded); + return (char*)m_bufdata->m_data + m_bufdata->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) + // Update the length after the append + void UngetAppendBuf(size_t sizeUsed) { - memcpy(GetAppendBuf(len), data, len); - UngetAppendBuf(len); + SetDataLen(m_bufdata->m_len + sizeUsed); } - 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) - { - // no reference count yet... - ((wxMemoryBuffer*)&src)->m_data = NULL; - ((wxMemoryBuffer*)&src)->m_size = 0; - ((wxMemoryBuffer*)&src)->m_len = 0; - } - - 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; }; // ----------------------------------------------------------------------------