X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/11fead7c4651091aa20c3a8c2dd4d25586460108..4f2511d706e5274a34e1521e11c1b95fed735b42:/include/wx/buffer.h diff --git a/include/wx/buffer.h b/include/wx/buffer.h index fa8f3215c5..3244323737 100644 --- a/include/wx/buffer.h +++ b/include/wx/buffer.h @@ -12,127 +12,274 @@ #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__ + +class WXDLLIMPEXP_FWD_BASE wxCStrData; // ---------------------------------------------------------------------------- // Special classes for (wide) character strings: they use malloc/free instead // of new/delete // ---------------------------------------------------------------------------- -#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); +template +class WXDLLIMPEXP_BASE wxCharTypeBuffer +{ +public: + typedef T CharType; + + wxCharTypeBuffer(const CharType *str = NULL) + { + if ( str ) + m_data = new Data(wxStrdup(str)); + else + m_data = &NullData; + } + + wxCharTypeBuffer(size_t len) + { + m_data = new Data((CharType *)malloc((len + 1)*sizeof(CharType))); + m_data->m_str[len] = (CharType)0; + } + + static const wxCharTypeBuffer CreateNonOwned(const CharType *str) + { + wxCharTypeBuffer buf; + if ( str ) + buf.m_data = new Data(wx_const_cast(CharType*, str), Data::NonOwned); + return buf; + } + + ~wxCharTypeBuffer() + { + DecRef(); + } + + // 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 == &NullData ) + return NULL; + + 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") ); + + CharType *p = m_data->m_str; + + wxCharTypeBuffer *self = wx_const_cast(wxCharTypeBuffer*, this); + self->m_data->m_str = NULL; + self->DecRef(); + + return p; + } + + void reset() + { + DecRef(); + } + + wxCharTypeBuffer(const wxCharTypeBuffer& src) + { + m_data = src.m_data; + IncRef(); + } + + wxCharTypeBuffer& operator=(const CharType *str) + { + DecRef(); + + if ( str ) + m_data = new Data(wxStrdup(str)); + return *this; + } + + wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src) + { + if ( &src == this ) + return *this; + + DecRef(); + m_data = src.m_data; + IncRef(); + + return *this; + } + + bool extend(size_t len) + { + 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; + + if ( m_data == &NullData ) + { + m_data = new Data(str); + } + else + { + m_data->m_str = str; + m_data->m_owned = true; + } + + return true; + } + + CharType *data() { return m_data->m_str; } + const CharType *data() const { return m_data->m_str; } + operator const CharType *() const { return data(); } + CharType operator[](size_t n) const { return data()[n]; } + +private: + // reference-counted data + struct Data + { + enum Kind + { + Owned, + NonOwned + }; + + Data(CharType *str, Kind kind = Owned) + : m_str(str), m_ref(1), m_owned(kind == Owned) {} + + ~Data() + { + if ( m_owned ) + free(m_str); + } + + CharType *m_str; + + // "short" to have sizeof(Data)=8 on 32bit archs + unsigned short m_ref; + + bool m_owned; + }; + + // placeholder for NULL string, to simplify this code + // NB: this is defined in string.cpp, not (non-existent) buffer.cpp +#ifdef __MINGW32__ + // MinGW requires explicit WXDLLIMPEXP_DATA_BASE to avoid compilation + // errors + static WXDLLIMPEXP_DATA_BASE(Data) NullData; +#else + // but Visual C++ doesn't like it + static Data NullData; +#endif + + void IncRef() + { + if ( m_data == &NullData ) // exception, not ref-counted + return; + m_data->m_ref++; + } + + void DecRef() + { + if ( m_data == &NullData ) // exception, not ref-counted + return; + if ( --m_data->m_ref == 0 ) + delete m_data; + m_data = &NullData; + } + +private: + Data *m_data; +}; + +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer ) + +class WXDLLIMPEXP_BASE 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) {} + + wxCharBuffer(const wxCStrData& cstr); +}; #if wxUSE_WCHAR_T +WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer ) -DEFINE_BUFFER(wxWCharBuffer, wchar_t, wxStrdupW); +class WXDLLIMPEXP_BASE 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) {} + + wxWCharBuffer(const wxCStrData& cstr); +}; #endif // wxUSE_WCHAR_T -#undef DEFINE_BUFFER +// 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 + #define wxMB2WXbuf wxChar* #define wxWX2MBbuf wxChar* #define wxWC2WXbuf wxCharBuffer #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) // ---------------------------------------------------------------------------- @@ -195,7 +342,7 @@ private: }; -class wxMemoryBuffer +class WXDLLIMPEXP_BASE wxMemoryBuffer { public: // ctor and dtor @@ -217,9 +364,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; }