#include "wx/chartype.h"
#include "wx/wxcrtbase.h"
-#ifndef __WXPALMOS5__
#include <stdlib.h> // malloc() and free()
-#endif // ! __WXPALMOS5__
class WXDLLIMPEXP_FWD_BASE wxCStrData;
NonOwned
};
- UntypedBufferData(void *str, Kind kind = Owned)
- : m_str(str), m_ref(1), m_owned(kind == Owned) {}
+ UntypedBufferData(void *str, size_t len, Kind kind = Owned)
+ : m_str(str), m_length(len), m_ref(1), m_owned(kind == Owned) {}
~UntypedBufferData()
{
}
void *m_str;
+ size_t m_length;
- // "short" to have sizeof(Data)=8 on 32bit archs
+ // "short" to have sizeof(Data)=12 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;
+WXDLLIMPEXP_BASE UntypedBufferData * GetUntypedNullData();
} // namespace wxPrivate
// 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)
+ static
+ const wxScopedCharTypeBuffer CreateNonOwned(const CharType *str,
+ size_t len = wxNO_LEN)
{
+ if ( len == wxNO_LEN )
+ len = wxStrlen(str);
+
wxScopedCharTypeBuffer buf;
if ( str )
- buf.m_data = new Data(const_cast<CharType*>(str), Data::NonOwned);
+ buf.m_data = new Data(const_cast<CharType*>(str), len, Data::NonOwned);
return buf;
}
// Creates "owned" buffer, i.e. takes over ownership of 'str' and frees it
// in dtor (if ref.count reaches 0).
- static const wxScopedCharTypeBuffer CreateOwned(const CharType *str)
+ static
+ const wxScopedCharTypeBuffer CreateOwned(CharType *str,
+ size_t len = wxNO_LEN )
{
+ if ( len == wxNO_LEN )
+ len = wxStrlen(str);
+
wxScopedCharTypeBuffer buf;
if ( str )
- buf.m_data = new Data(wxStrdup(str));
+ buf.m_data = new Data(str, len);
return buf;
}
if ( m_data == GetNullData() )
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") );
+ 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<wxScopedCharTypeBuffer*>(this);
- self->m_data->Set(NULL);
+ self->m_data->Set(NULL, 0);
self->DecRef();
return p;
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, Kind kind = Owned)
- : wxPrivate::UntypedBufferData(str, kind)
+ Data(CharType *str, size_t len, Kind kind = Owned)
+ : wxPrivate::UntypedBufferData(str, len, kind)
{
}
CharType *Get() const { return static_cast<CharType *>(m_str); }
- void Set(CharType *str) { m_str = 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<Data *>(wxPrivate::untypedNullDataPtr);
+ return static_cast<Data *>(wxPrivate::GetUntypedNullData());
}
void IncRef()
// 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(wxStrdup(src.m_data->Get()));
+ 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));
+ memcpy(dst, src, sizeof(CharType) * (len + 1));
+ return dst;
+ }
+
protected:
Data *m_data;
};
public:
typedef T CharType;
- wxCharTypeBuffer(const CharType *str = NULL)
+ wxCharTypeBuffer(const CharType *str = NULL, size_t len = wxNO_LEN)
{
if ( str )
- this->m_data = new Data(wxStrdup(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)));
+ this->m_data =
+ new Data((CharType *)malloc((len + 1)*sizeof(CharType)), len);
this->m_data->Get()[len] = (CharType)0;
}
this->DecRef();
if ( str )
- this->m_data = new Data(wxStrdup(str));
+ this->m_data = new Data(wxStrdup(str), wxStrlen(str));
return *this;
}
wxCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
{
- MakeOwnedCopyOf(src);
+ this->MakeOwnedCopyOf(src);
}
wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer<T>& src)
if ( !str )
return false;
+ // 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);
+ this->m_data = new Data(str, len);
}
else
{
- this->m_data->Set(str);
+ this->m_data->Set(str, len);
this->m_data->m_owned = true;
}
return true;
}
+
+ void shrink(size_t len)
+ {
+ 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" );
+
+ wxASSERT( len <= this->length() );
+
+ this->m_data->m_length = len;
+ this->data()[len] = 0;
+ }
};
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<char> )
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
class wxCharBuffer : public wxCharTypeBuffer<char>
wxCharBuffer(const wxCStrData& cstr);
};
-#if wxUSE_WCHAR_T
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<wchar_t> )
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
wxWCharBuffer(const wxCStrData& cstr);
};
-#endif // wxUSE_WCHAR_T
// wxCharTypeBuffer<T> implicitly convertible to T*
template <typename T>
#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)
// ----------------------------------------------------------------------------
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;
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)
{
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)
{
// 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;
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;
};
projects / wxWidgets.git / blobdiff