X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ccd4deab6b05e27b3275dda38bec124300436480..b6fd0b424573e09ae7e83a28b225bbba008157b7:/include/wx/buffer.h diff --git a/include/wx/buffer.h b/include/wx/buffer.h index c9232820fe..4cc340aa51 100644 --- a/include/wx/buffer.h +++ b/include/wx/buffer.h @@ -12,20 +12,58 @@ #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__ -inline char *wxStrDup(const char *s) { return wxStrdupA(s); } -#if wxUSE_WCHAR_T - inline wchar_t *wxStrDup(const wchar_t *ws) { return wxStrdupW(ws); } -#endif +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, Kind kind = Owned) + : m_str(str), m_ref(1), m_owned(kind == Owned) {} + + ~UntypedBufferData() + { + if ( m_owned ) + free(m_str); + } + + void *m_str; + + // "short" to have sizeof(Data)=8 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 + template class wxCharTypeBuffer { @@ -33,126 +71,218 @@ public: typedef T CharType; wxCharTypeBuffer(const CharType *str = NULL) - : m_str(str ? wxStrDup(str) : NULL) { + if ( str ) + m_data = new Data(wxStrdup(str)); + else + m_data = GetNullData(); } wxCharTypeBuffer(size_t len) - : m_str((CharType *)malloc((len + 1)*sizeof(CharType))) { - m_str[len] = (CharType)0; + m_data = new Data((CharType *)malloc((len + 1)*sizeof(CharType))); + m_data->Get()[len] = (CharType)0; } - /* no need to check for NULL, free() does it */ - ~wxCharTypeBuffer() { free(m_str); } + static const wxCharTypeBuffer CreateNonOwned(const CharType *str) + { + wxCharTypeBuffer buf; + if ( str ) + buf.m_data = new Data(const_cast(str), Data::NonOwned); + return buf; + } - /* - WARNING: + ~wxCharTypeBuffer() + { + DecRef(); + } - the copy ctor and assignment operators change the passed in object - even although it is declared as "const", so: + // 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; - a) it shouldn't be really const - b) you shouldn't use it afterwards (or know that it was reset) + wxASSERT_MSG( m_data->m_owned, _T("can't release non-owned buffer") ); + wxASSERT_MSG( m_data->m_ref == 1, _T("can't release shared buffer") ); - 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...) - */ + CharType * const p = m_data->Get(); + + wxCharTypeBuffer *self = const_cast(this); + self->m_data->Set(NULL); + self->DecRef(); - /* - because of the remark above, release() is declared const even if it - isn't really const - */ - CharType *release() const - { - CharType *p = m_str; - ((wxCharTypeBuffer *)this)->m_str = NULL; return p; } void reset() { - free(m_str); - m_str = NULL; + DecRef(); } wxCharTypeBuffer(const wxCharTypeBuffer& src) - : m_str(src.release()) { + m_data = src.m_data; + IncRef(); } wxCharTypeBuffer& operator=(const CharType *str) { - free(m_str); - m_str = str ? wxStrDup(str) : NULL; + DecRef(); + + if ( str ) + m_data = new Data(wxStrdup(str)); return *this; } wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src) { - free(m_str); - m_str = src.release(); + if ( &src == this ) + return *this; + + DecRef(); + m_data = src.m_data; + IncRef(); return *this; } bool extend(size_t len) { - CharType * - str = (CharType *)realloc(m_str, (len + 1)*sizeof(CharType)); + wxASSERT_MSG( m_data->m_owned, _T("cannot extend non-owned buffer") ); + wxASSERT_MSG( m_data->m_ref == 1, _T("can't extend shared buffer") ); + + CharType *str = + (CharType *)realloc(data(), (len + 1) * sizeof(CharType)); if ( !str ) return false; - m_str = str; + if ( m_data == GetNullData() ) + { + m_data = new Data(str); + } + else + { + m_data->Set(str); + 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]; } + 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]; } + +private: + // reference-counted data + struct Data : public wxPrivate::UntypedBufferData + { + Data(CharType *str, Kind kind = Owned) + : wxPrivate::UntypedBufferData(str, kind) + { + } + + CharType *Get() const { return static_cast(m_str); } + void Set(CharType *str) { m_str = str; } + }; + + // 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(); + } private: - CharType *m_str; + Data *m_data; }; -class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer ) + +class wxCharBuffer : public wxCharTypeBuffer { public: typedef wxCharTypeBuffer wxCharTypeBufferBase; + wxCharBuffer(const wxCharTypeBufferBase& buf) + : wxCharTypeBufferBase(buf) {} + wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {} wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {} -#if !wxUSE_UNICODE wxCharBuffer(const wxCStrData& cstr); -#endif }; #if wxUSE_WCHAR_T -class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer ) + +class wxWCharBuffer : public wxCharTypeBuffer { public: typedef wxCharTypeBuffer wxCharTypeBufferBase; + wxWCharBuffer(const wxCharTypeBufferBase& buf) + : wxCharTypeBufferBase(buf) {} + wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {} wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {} -#if wxUSE_UNICODE wxWCharBuffer(const wxCStrData& cstr); -#endif }; #endif // wxUSE_WCHAR_T +// wxCharTypeBuffer implicitly convertible to T* +template +class wxWritableCharTypeBuffer : public wxCharTypeBuffer +{ +public: + typedef typename wxCharTypeBuffer::CharType CharType; + + wxWritableCharTypeBuffer(const wxCharTypeBuffer& src) + : wxCharTypeBuffer(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(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 @@ -162,6 +292,13 @@ public: #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) // ---------------------------------------------------------------------------- @@ -246,9 +383,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; }