X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/541aa821800536b6e265d415de8c1ed9a304f1c1..8e77fd8bca165aab9709649d79a7cbc6a172d4e1:/include/wx/buffer.h?ds=inline diff --git a/include/wx/buffer.h b/include/wx/buffer.h index 8e7fd8dbb1..951777a13c 100644 --- a/include/wx/buffer.h +++ b/include/wx/buffer.h @@ -17,146 +17,344 @@ #include // malloc() and free() -class WXDLLIMPEXP_BASE wxCStrData; +class WXDLLIMPEXP_FWD_BASE wxCStrData; // ---------------------------------------------------------------------------- // Special classes for (wide) character strings: they use malloc/free instead // of new/delete // ---------------------------------------------------------------------------- +// 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; +}; + +// NB: this is defined in string.cpp and not the (non-existent) buffer.cpp +WXDLLIMPEXP_BASE UntypedBufferData * GetUntypedNullData(); + +} // 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 wxCharTypeBuffer +class wxScopedCharTypeBuffer { public: typedef T CharType; - wxCharTypeBuffer(const CharType *str = NULL) - : m_str(str ? wxStrdup(str) : NULL), - m_owned(true) + wxScopedCharTypeBuffer() { + m_data = GetNullData(); } - wxCharTypeBuffer(size_t len) - : m_str((CharType *)malloc((len + 1)*sizeof(CharType))), - m_owned(true) + // 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) { - m_str[len] = (CharType)0; + if ( len == wxNO_LEN ) + len = wxStrlen(str); + + wxScopedCharTypeBuffer buf; + if ( str ) + buf.m_data = new Data(const_cast(str), len, Data::NonOwned); + return buf; } - static const wxCharTypeBuffer CreateNonOwned(const CharType *str) + // Creates "owned" buffer, i.e. takes over ownership of 'str' and frees it + // in dtor (if ref.count reaches 0). + static + const wxScopedCharTypeBuffer CreateOwned(CharType *str, + size_t len = wxNO_LEN ) { - wxCharTypeBuffer buf; - buf.m_str = wx_const_cast(CharType*, str); - buf.m_owned = false; + if ( len == wxNO_LEN ) + len = wxStrlen(str); + + wxScopedCharTypeBuffer buf; + if ( str ) + buf.m_data = new Data(str, len); return buf; } - /* no need to check for NULL, free() does it */ - ~wxCharTypeBuffer() + wxScopedCharTypeBuffer(const wxScopedCharTypeBuffer& src) { - if ( m_owned) - free(m_str); + m_data = src.m_data; + IncRef(); } - /* - WARNING: + wxScopedCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& src) + { + if ( &src == this ) + return *this; - the copy ctor and assignment operators change the passed in object - even although it is declared as "const", so: + DecRef(); + m_data = src.m_data; + IncRef(); - a) it shouldn't be really const - b) you shouldn't use it afterwards (or know that it was reset) + return *this; + } - 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...) - */ + ~wxScopedCharTypeBuffer() + { + DecRef(); + } - /* - because of the remark above, release() is declared const even if it - isn't really const - */ + // 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 { - wxASSERT_MSG( m_owned, _T("can't release non-owned buffer") ); - return DoRelease(); + if ( m_data == GetNullData() ) + return NULL; + + 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") ); + + CharType * const p = m_data->Get(); + + wxScopedCharTypeBuffer *self = const_cast(this); + self->m_data->Set(NULL, 0); + self->DecRef(); + + return p; } void reset() { - if ( m_owned ) - free(m_str); - m_str = NULL; + DecRef(); } - wxCharTypeBuffer(const wxCharTypeBuffer& src) + 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::GetUntypedNullData()); + } + + void IncRef() + { + if ( m_data == GetNullData() ) // exception, not ref-counted + return; + m_data->m_ref++; + } + + void DecRef() { - CopyFrom(src); + 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)); + if ( dst ) + memcpy(dst, src, sizeof(CharType) * (len + 1)); + return dst; + } + +protected: + Data *m_data; +}; + +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: + 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(this->StrCopy(str, len), len); + } + else + { + this->m_data = this->GetNullData(); + } + } + + wxCharTypeBuffer(size_t len) + { + this->m_data = + new Data((CharType *)malloc((len + 1)*sizeof(CharType)), len); + this->m_data->Get()[len] = (CharType)0; + } + + wxCharTypeBuffer(const wxCharTypeBuffer& src) + : wxScopedCharTypeBuffer(src) {} + wxCharTypeBuffer& operator=(const CharType *str) { - if ( m_owned ) - free(m_str); - m_str = str ? wxStrdup(str) : NULL; - m_owned = true; + this->DecRef(); + + if ( str ) + this->m_data = new Data(wxStrdup(str), wxStrlen(str)); return *this; } wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src) { - if ( m_owned ) - free(m_str); - CopyFrom(src); + wxScopedCharTypeBuffer::operator=(src); + return *this; + } + + wxCharTypeBuffer(const wxScopedCharTypeBuffer& src) + { + this->MakeOwnedCopyOf(src); + } + + wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& src) + { + MakeOwnedCopyOf(src); return *this; } bool extend(size_t len) { - wxASSERT_MSG( m_owned, _T("cannot extend non-owned buffer") ); + 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(m_str, (len + 1)*sizeof(CharType)); + CharType *str = + (CharType *)realloc(this->data(), (len + 1) * sizeof(CharType)); if ( !str ) return false; - m_str = str; + // For consistency with the ctor taking just the length, NUL-terminate + // the buffer. + str[len] = (CharType)0; + + 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; } - 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 + void shrink(size_t len) { - CharType *p = m_str; - ((wxCharTypeBuffer *)this)->m_str = NULL; - return p; - } + 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" ); - void CopyFrom(const wxCharTypeBuffer& src) - { - m_owned = src.m_owned; - m_str = src.DoRelease(); - } + wxASSERT( len <= this->length() ); -private: - CharType *m_str; - bool m_owned; + 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) {} @@ -164,33 +362,39 @@ public: 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 // wxUSE_WCHAR_T // wxCharTypeBuffer implicitly convertible to T* template class wxWritableCharTypeBuffer : public wxCharTypeBuffer { public: - typedef typename wxCharTypeBuffer::CharType CharType; + typedef typename wxScopedCharTypeBuffer::CharType CharType; - wxWritableCharTypeBuffer(const wxCharTypeBuffer& src) + 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) {} @@ -235,7 +439,7 @@ public: friend class wxMemoryBuffer; - // everyting is private as it can only be used by wxMemoryBuffer + // everything 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) @@ -267,6 +471,21 @@ private: delete this; } + void *release() + { + if ( m_data == NULL ) + return NULL; + + wxASSERT_MSG( m_ref == 1, "can't release shared buffer" ); + + void *p = m_data; + m_data = NULL; + m_len = + m_size = 0; + + return p; + } + // the buffer containing the data void *m_data; @@ -280,7 +499,7 @@ private: // the reference count size_t m_ref; - DECLARE_NO_COPY_CLASS(wxMemoryBufferData) + wxDECLARE_NO_COPY_CLASS(wxMemoryBufferData); }; @@ -306,9 +525,12 @@ public: 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; } @@ -318,6 +540,8 @@ public: size_t GetBufSize() const { return m_bufdata->m_size; } size_t GetDataLen() const { return m_bufdata->m_len; } + bool IsEmpty() const { return GetDataLen() == 0; } + void SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); } void SetDataLen(size_t len) { @@ -325,6 +549,8 @@ public: m_bufdata->m_len = len; } + void Clear() { SetDataLen(0); } + // Ensure the buffer is big enough and return a pointer to it void *GetWriteBuf(size_t sizeNeeded) { @@ -351,7 +577,7 @@ public: // Other ways to append to the buffer void AppendByte(char data) { - wxCHECK_RET( m_bufdata->m_data, _T("invalid wxMemoryBuffer") ); + wxCHECK_RET( m_bufdata->m_data, wxT("invalid wxMemoryBuffer") ); m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1); *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data; @@ -366,6 +592,13 @@ public: operator const char *() const { return (const char*)GetData(); } + // gives up ownership of data, returns the pointer; after this call, + // data isn't freed by the buffer and its content is resent to empty + void *release() + { + return m_bufdata->release(); + } + private: wxMemoryBufferData* m_bufdata; };