// Created: 12.04.99
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// 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 <string.h> // strdup
+#include <stdlib.h> // malloc() and free()
+
+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
// ----------------------------------------------------------------------------
// Special classes for (wide) character strings: they use malloc/free instead
// of new/delete
// ----------------------------------------------------------------------------
-#define DEFINE_BUFFER(classname, chartype, strdupfunc) \
-class classname \
-{ \
-public: \
- classname(const chartype *str) \
- : 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) \
- \
+template <typename T>
+class wxCharTypeBuffer
+{
+public:
+ typedef T CharType;
+
+ wxCharTypeBuffer(const CharType *str = NULL)
+ : m_str(str ? wxStrDup(str) : NULL)
+ {
+ }
+
+ wxCharTypeBuffer(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 */
+ ~wxCharTypeBuffer() { 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; \
- } \
- \
- 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; \
- } \
- \
- 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; \
-}
-
-#ifndef strdup
-inline char *strdup(const char *cs)
+ 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
+ {
+ CharType *p = m_str;
+ ((wxCharTypeBuffer *)this)->m_str = NULL;
+ return p;
+ }
+
+ void reset()
+ {
+ free(m_str);
+ m_str = NULL;
+ }
+
+ wxCharTypeBuffer(const wxCharTypeBuffer& src)
+ : m_str(src.release())
+ {
+ }
+
+ wxCharTypeBuffer& operator=(const CharType *str)
+ {
+ free(m_str);
+ m_str = str ? wxStrDup(str) : NULL;
+ return *this;
+ }
+
+ wxCharTypeBuffer& operator=(const wxCharTypeBuffer& 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;
+};
+
+class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
{
- size_t len = 0;
- while (cs[len] != 0)
- len++;
- const size_t siz = (len + 1)*sizeof(char);
- char *csCopy = (char *)malloc(siz);
- memcpy(csCopy, cs, siz);
- return csCopy;
-}
-#endif
+public:
+ typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
-DEFINE_BUFFER(wxCharBuffer, char, strdup);
+ wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
+ wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
-#if wxUSE_WCHAR_T
+#if !wxUSE_UNICODE
+ wxCharBuffer(const wxCStrData& cstr);
+#endif
+};
-inline wchar_t *wxWcsdupReplacement(const wchar_t *wcs)
+#if wxUSE_WCHAR_T
+class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
{
- const size_t siz = (wxWcslen(wcs) + 1)*sizeof(wchar_t);
- wchar_t *wcsCopy = (wchar_t *)malloc(siz);
- memcpy(wcsCopy, wcs, siz);
- return wcsCopy;
-}
+public:
+ typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
-DEFINE_BUFFER(wxWCharBuffer, wchar_t, wxWcsdupReplacement);
+ 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
-#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
+ #define wxWxCharBuffer wxWCharBuffer
+
#define wxMB2WXbuf wxWCharBuffer
#define wxWX2MBbuf wxCharBuffer
#define wxWC2WXbuf wxChar*
#define wxWX2WCbuf wxChar*
#else // ANSI
+ #define wxWxCharBuffer wxCharBuffer
+
#define wxMB2WXbuf wxChar*
#define wxWX2MBbuf wxChar*
#define wxWC2WXbuf wxCharBuffer
{
public:
// the initial size and also the size added by ResizeIfNeeded()
- enum { BLOCK_SIZE = 1024 };
+ enum { DefBufSize = 1024 };
friend class wxMemoryBuffer;
// everyting is private as it can only be used by wxMemoryBuffer
private:
- wxMemoryBufferData(size_t size = wxMemoryBufferData::BLOCK_SIZE)
+ wxMemoryBufferData(size_t size = wxMemoryBufferData::DefBufSize)
: m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)
{
}
if (newSize > m_size)
{
void *dataOld = m_data;
- m_data = realloc(m_data, newSize + wxMemoryBufferData::BLOCK_SIZE);
+ m_data = realloc(m_data, newSize + wxMemoryBufferData::DefBufSize);
if ( !m_data )
{
free(dataOld);
}
- m_size = newSize + wxMemoryBufferData::BLOCK_SIZE;
+ m_size = newSize + wxMemoryBufferData::DefBufSize;
}
}
// the reference count
size_t m_ref;
+
+ DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
};
{
public:
// ctor and dtor
- wxMemoryBuffer(size_t size = wxMemoryBufferData::BLOCK_SIZE)
+ wxMemoryBuffer(size_t size = wxMemoryBufferData::DefBufSize)
{
m_bufdata = new wxMemoryBufferData(size);
m_bufdata->IncRef();
m_bufdata->m_len += 1;
}
- void AppendData(void* data, size_t len)
+ void AppendData(const void *data, size_t len)
{
memcpy(GetAppendBuf(len), data, len);
UngetAppendBuf(len);
projects / wxWidgets.git / blobdiff