X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ef1cae87cd4102bef46712f64f06fcd102ae9eee..03773e400b6ff2692f2a9ba045d652c3b7b7109d:/include/wx/buffer.h diff --git a/include/wx/buffer.h b/include/wx/buffer.h index dac2adf1bd..864bb64eb7 100644 --- a/include/wx/buffer.h +++ b/include/wx/buffer.h @@ -1,244 +1,585 @@ /////////////////////////////////////////////////////////////////////////////// -// 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 -// 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 "wx/chartype.h" +#include "wx/wxcrtbase.h" + +#ifndef __WXPALMOS5__ +#include // malloc() and free() +#endif // ! __WXPALMOS5__ -#include // strdup +class WXDLLIMPEXP_FWD_BASE wxCStrData; // ---------------------------------------------------------------------------- // Special classes for (wide) character strings: they use malloc/free instead // of new/delete // ---------------------------------------------------------------------------- -class wxCharBuffer +// 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; +}; + +// this has to be defined inside the DLL (and not e.g. as a static variable +// inside an inline function) as otherwise MSVC gives link errors when the +// functions are effectively inlined (i.e. in non-debug build) +// +// NB: this is defined in string.cpp and not the (non-existent) buffer.cpp +extern WXDLLIMPEXP_DATA_BASE(UntypedBufferData * const) untypedNullDataPtr; + +} // 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 for persistent variant. +template +class wxScopedCharTypeBuffer { public: - wxCharBuffer(const char *str) + 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(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(const CharType *str, + size_t len = wxNO_LEN ) + { + if ( len == wxNO_LEN ) + len = wxStrlen(str); + + wxScopedCharTypeBuffer buf; + if ( str ) + buf.m_data = new Data(StrCopy(str, len), len); + return buf; + } + + wxScopedCharTypeBuffer(const wxScopedCharTypeBuffer& src) + { + m_data = src.m_data; + IncRef(); + } + + wxScopedCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& src) { - wxASSERT_MSG( str, wxT("NULL string in wxCharBuffer") ); + if ( &src == this ) + return *this; - m_str = str ? strdup(str) : (char *)NULL; + DecRef(); + m_data = src.m_data; + IncRef(); + + return *this; } - wxCharBuffer(size_t len) + + ~wxScopedCharTypeBuffer() { - m_str = (char *)malloc(len+1); - m_str[len] = '\0'; + DecRef(); } - // 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; - } + // 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; - const char *data() const { return m_str; } - operator const char *() const { return m_str; } - char operator[](size_t n) const { return m_str[n]; } + 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") ); -private: - char *m_str; + CharType * const p = m_data->Get(); + + wxScopedCharTypeBuffer *self = const_cast(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(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(wxPrivate::untypedNullDataPtr); + } + + 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)); + memcpy(dst, src, sizeof(CharType) * (len + 1)); + return dst; + } + +protected: + Data *m_data; }; -#if wxUSE_WCHAR_T -class wxWCharBuffer +typedef wxScopedCharTypeBuffer wxScopedCharBuffer; +typedef wxScopedCharTypeBuffer wxScopedWCharBuffer; + + +// this buffer class always stores data in "owned" (persistent) manner +template +class wxCharTypeBuffer : public wxScopedCharTypeBuffer { +protected: + typedef typename wxScopedCharTypeBuffer::Data Data; + public: - wxWCharBuffer(const wchar_t *wcs) - { - 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); + 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(StrCopy(str, len), len); + } + else + { + this->m_data = this->GetNullData(); } - else m_wcs = (wchar_t *)NULL; } - wxWCharBuffer(size_t len) + + wxCharTypeBuffer(size_t len) { - m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t)); - m_wcs[len] = L'\0'; + this->m_data = + new Data((CharType *)malloc((len + 1)*sizeof(CharType)), len); + this->m_data->Get()[len] = (CharType)0; } - // no need to check for NULL, free() does it - ~wxWCharBuffer() { free(m_wcs); } + wxCharTypeBuffer(const wxCharTypeBuffer& src) + : wxScopedCharTypeBuffer(src) {} - 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; - } + wxCharTypeBuffer& operator=(const CharType *str) + { + this->DecRef(); - 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]; } + if ( str ) + this->m_data = new Data(wxStrdup(str), wxStrlen(str)); + return *this; + } -private: - wchar_t *m_wcs; + wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src) + { + wxScopedCharTypeBuffer::operator=(src); + return *this; + } + + wxCharTypeBuffer(const wxScopedCharTypeBuffer& src) + { + MakeOwnedCopyOf(src); + } + + wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& 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; + + 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 ) +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer ) + +class wxCharBuffer : public wxCharTypeBuffer +{ +public: + typedef wxCharTypeBuffer wxCharTypeBufferBase; + typedef wxScopedCharTypeBuffer 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); +}; + +#if wxUSE_WCHAR_T +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer ) +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer ) + +class wxWCharBuffer : public wxCharTypeBuffer +{ +public: + typedef wxCharTypeBuffer wxCharTypeBufferBase; + typedef wxScopedCharTypeBuffer 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); }; -#endif +#endif // wxUSE_WCHAR_T + +// wxCharTypeBuffer implicitly convertible to T* +template +class wxWritableCharTypeBuffer : public wxCharTypeBuffer +{ +public: + typedef typename wxScopedCharTypeBuffer::CharType CharType; + + wxWritableCharTypeBuffer(const wxScopedCharTypeBuffer& src) + : wxCharTypeBuffer(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(str) {} + + operator CharType*() { return this->data(); } +}; + +typedef wxWritableCharTypeBuffer wxWritableCharBuffer; +typedef wxWritableCharTypeBuffer 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 #define wxWX2WCbuf wxWCharBuffer #endif // Unicode/ANSI - - // ---------------------------------------------------------------------------- // 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: - enum { BLOCK_SIZE = 1024 }; - wxMemoryBuffer(size_t size=wxMemoryBuffer::BLOCK_SIZE) + // 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; - m_len = 0; } + ~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; + + wxDECLARE_NO_COPY_CLASS(wxMemoryBufferData); +}; + + +class 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) + void SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); } + void SetDataLen(size_t len) { - 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; + 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; + m_bufdata->ResizeIfNeeded(sizeNeeded); + return m_bufdata->m_data; + } - // no reference count yet... - ((wxMemoryBuffer*)&src)->m_data = NULL; - ((wxMemoryBuffer*)&src)->m_size = 0; - ((wxMemoryBuffer*)&src)->m_len = 0; + // Update the length after the write + void UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); } - return *this; - } + // 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; + } + // Update the length after the append + void UngetAppendBuf(size_t sizeUsed) + { + SetDataLen(m_bufdata->m_len + sizeUsed); + } -protected: + // Other ways to append to the buffer + void AppendByte(char data) + { + wxCHECK_RET( m_bufdata->m_data, wxT("invalid wxMemoryBuffer") ); - void ResizeIfNeeded(size_t newSize) + 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(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; }; - - // ---------------------------------------------------------------------------- // template class for any kind of data // ----------------------------------------------------------------------------