#ifndef _WX_BUFFER_H
#define _WX_BUFFER_H
-#include "wx/wxchar.h"
+#include "wx/chartype.h"
+#include "wx/wxcrtbase.h"
#include <stdlib.h> // malloc() and free()
+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(const wxCStrData& cstr); \
- \
- 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 <typename T>
+class WXDLLIMPEXP_BASE wxCharTypeBuffer
+{
+public:
+ typedef T CharType;
+
+ wxCharTypeBuffer(const CharType *str = NULL)
+ : m_str(str ? wxStrdup(str) : NULL),
+ m_owned(true)
+ {
+ }
+
+ wxCharTypeBuffer(size_t len)
+ : m_str((CharType *)malloc((len + 1)*sizeof(CharType))),
+ m_owned(true)
+ {
+ m_str[len] = (CharType)0;
+ }
+
+ static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
+ {
+ wxCharTypeBuffer buf;
+ buf.m_str = wx_const_cast(CharType*, str);
+ buf.m_owned = false;
+ return buf;
+ }
+
+ /* no need to check for NULL, free() does it */
+ ~wxCharTypeBuffer()
+ {
+ if ( m_owned)
+ 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 wxCharTypeBuffer 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
+ {
+ wxASSERT_MSG( m_owned, _T("can't release non-owned buffer") );
+ return DoRelease();
+ }
+
+ void reset()
+ {
+ if ( m_owned )
+ free(m_str);
+ m_str = NULL;
+ }
+
+ wxCharTypeBuffer(const wxCharTypeBuffer& src)
+ {
+ CopyFrom(src);
+ }
+
+ wxCharTypeBuffer& operator=(const CharType *str)
+ {
+ if ( m_owned )
+ free(m_str);
+ m_str = str ? wxStrdup(str) : NULL;
+ m_owned = true;
+ return *this;
+ }
+
+ wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
+ {
+ if (&src != this)
+ {
+ if ( m_owned )
+ free(m_str);
+ CopyFrom(src);
+ }
+ return *this;
+ }
+
+ bool extend(size_t len)
+ {
+ wxASSERT_MSG( m_owned, _T("cannot extend non-owned buffer") );
+
+ 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 *DoRelease() const
+ {
+ CharType *p = m_str;
+ ((wxCharTypeBuffer *)this)->m_str = NULL;
+ return p;
+ }
+
+ void CopyFrom(const wxCharTypeBuffer& src)
+ {
+ m_owned = src.m_owned;
+ m_str = src.DoRelease();
+ }
+
+private:
+ CharType *m_str;
+ bool m_owned;
+};
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
+
+class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
+{
+public:
+ typedef wxCharTypeBuffer<char> 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<wchar_t> )
+
+class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
+{
+public:
+ typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
+
+ wxWCharBuffer(const wxCharTypeBufferBase& buf)
+ : wxCharTypeBufferBase(buf) {}
-DEFINE_BUFFER(wxWCharBuffer, wchar_t, wxStrdupW);
+ 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<T> implicitly convertible to T*
+template <typename T>
+class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
+{
+public:
+ typedef typename wxCharTypeBuffer<T>::CharType CharType;
+
+ wxWritableCharTypeBuffer(const wxCharTypeBuffer<T>& src)
+ : wxCharTypeBuffer<T>(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<T>(str) {}
+
+ operator CharType*() { return this->data(); }
+};
+
+typedef wxWritableCharTypeBuffer<char> wxWritableCharBuffer;
+typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
+
#if wxUSE_UNICODE
- typedef wxWCharBuffer wxWxCharBuffer;
+ #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
- typedef wxCharBuffer wxWxCharBuffer;
+ #define wxWxCharBuffer wxCharBuffer
#define wxMB2WXbuf wxChar*
#define wxWX2MBbuf wxChar*
#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)
// ----------------------------------------------------------------------------
};
-class wxMemoryBuffer
+class WXDLLIMPEXP_BASE wxMemoryBuffer
{
public:
// ctor and dtor
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;
}
projects / wxWidgets.git / blobdiff