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;
} // namespace wxPrivate
+
+// Reference-counted character buffer for storing string data. The buffer
+// is only valid for as long as the "parent" object that provided the data
+// is valid; see wxCharTypeBuffer<T> for persistent variant.
template <typename T>
-class wxCharTypeBuffer
+class wxScopedCharTypeBuffer
{
public:
typedef T CharType;
- wxCharTypeBuffer(const CharType *str = NULL)
+ wxScopedCharTypeBuffer()
{
- if ( str )
- m_data = new Data(wxStrdup(str));
- else
- m_data = GetNullData();
+ m_data = GetNullData();
}
- wxCharTypeBuffer(size_t len)
+ // 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,
+ size_t len = wxNO_LEN)
{
- m_data = new Data((CharType *)malloc((len + 1)*sizeof(CharType)));
- m_data->Get()[len] = (CharType)0;
+ if ( len == wxNO_LEN )
+ len = wxStrlen(str);
+
+ wxScopedCharTypeBuffer buf;
+ if ( str )
+ buf.m_data = new Data(const_cast<CharType*>(str), len, Data::NonOwned);
+ return buf;
}
- static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
+ // 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,
+ size_t len = wxNO_LEN )
{
- wxCharTypeBuffer buf;
+ 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(StrCopy(str, len), len);
return buf;
}
- ~wxCharTypeBuffer()
+ wxScopedCharTypeBuffer(const wxScopedCharTypeBuffer& src)
+ {
+ m_data = src.m_data;
+ IncRef();
+ }
+
+ wxScopedCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& src)
+ {
+ if ( &src == this )
+ return *this;
+
+ DecRef();
+ m_data = src.m_data;
+ IncRef();
+
+ return *this;
+ }
+
+ ~wxScopedCharTypeBuffer()
{
DecRef();
}
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();
- wxCharTypeBuffer *self = const_cast<wxCharTypeBuffer*>(this);
- self->m_data->Set(NULL);
+ wxScopedCharTypeBuffer *self = const_cast<wxScopedCharTypeBuffer*>(this);
+ self->m_data->Set(NULL, 0);
self->DecRef();
return p;
DecRef();
}
- wxCharTypeBuffer(const wxCharTypeBuffer& src)
+ 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]; }
+
+ size_t length() const { return m_data->m_length; }
+
+protected:
+ // reference-counted data
+ struct Data : public wxPrivate::UntypedBufferData
{
- m_data = src.m_data;
- IncRef();
+ 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, 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);
+ }
+
+ 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();
+ }
+
+ // sets this object to a be copy of 'other'; if 'src' is non-owned,
+ // a deep copy is made and 'this' will contain new instance of the data
+ void MakeOwnedCopyOf(const wxScopedCharTypeBuffer& src)
+ {
+ this->DecRef();
+
+ if ( src.m_data == this->GetNullData() )
+ {
+ this->m_data = this->GetNullData();
+ }
+ else if ( src.m_data->m_owned )
+ {
+ this->m_data = src.m_data;
+ this->IncRef();
+ }
+ else
+ {
+ // 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
+ (
+ 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;
+};
+
+typedef wxScopedCharTypeBuffer<char> wxScopedCharBuffer;
+typedef wxScopedCharTypeBuffer<wchar_t> wxScopedWCharBuffer;
+
+
+// this buffer class always stores data in "owned" (persistent) manner
+template <typename T>
+class wxCharTypeBuffer : public wxScopedCharTypeBuffer<T>
+{
+protected:
+ typedef typename wxScopedCharTypeBuffer<T>::Data Data;
+
+public:
+ typedef T CharType;
+
+ wxCharTypeBuffer(const CharType *str = NULL, size_t len = wxNO_LEN)
+ {
+ if ( str )
+ {
+ if ( len == wxNO_LEN )
+ len = wxStrlen(str);
+ this->m_data = new Data(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)), len);
+ this->m_data->Get()[len] = (CharType)0;
}
+ wxCharTypeBuffer(const wxCharTypeBuffer& src)
+ : wxScopedCharTypeBuffer<T>(src) {}
+
wxCharTypeBuffer& operator=(const CharType *str)
{
- DecRef();
+ this->DecRef();
if ( str )
- m_data = new Data(wxStrdup(str));
+ this->m_data = new Data(wxStrdup(str), wxStrlen(str));
return *this;
}
wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
{
- if ( &src == this )
- return *this;
+ wxScopedCharTypeBuffer<T>::operator=(src);
+ return *this;
+ }
- DecRef();
- m_data = src.m_data;
- IncRef();
+ wxCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
+ {
+ MakeOwnedCopyOf(src);
+ }
+ wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer<T>& src)
+ {
+ MakeOwnedCopyOf(src);
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") );
+ wxASSERT_MSG( this->m_data->m_owned, "cannot extend non-owned buffer" );
+ wxASSERT_MSG( this->m_data->m_ref == 1, "can't extend shared buffer" );
CharType *str =
- (CharType *)realloc(data(), (len + 1) * sizeof(CharType));
+ (CharType *)realloc(this->data(), (len + 1) * sizeof(CharType));
if ( !str )
return false;
- if ( m_data == GetNullData() )
+ if ( this->m_data == this->GetNullData() )
{
- m_data = new Data(str);
+ this->m_data = new Data(str, len);
}
else
{
- m_data->Set(str);
- m_data->m_owned = true;
+ this->m_data->Set(str, len);
+ this->m_data->m_owned = true;
}
return true;
}
- 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 : wxPrivate::UntypedBufferData
+ void shrink(size_t len)
{
- Data(CharType *str, Kind kind = Owned)
- : UntypedBufferData(str, kind)
- {
- }
-
- CharType *Get() const { return static_cast<CharType *>(m_str); }
- void Set(CharType *str) { m_str = str; }
- };
-
- // placeholder for NULL string, to simplify this code
- static Data *GetNullData()
- {
- return static_cast<Data *>(wxPrivate::untypedNullDataPtr);
- }
+ 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" );
- void IncRef()
- {
- if ( m_data == GetNullData() ) // exception, not ref-counted
- return;
- m_data->m_ref++;
- }
+ wxASSERT( len <= this->length() );
- void DecRef()
- {
- if ( m_data == GetNullData() ) // exception, not ref-counted
- return;
- if ( --m_data->m_ref == 0 )
- delete m_data;
- m_data = GetNullData();
+ this->m_data->m_length = len;
+ this->data()[len] = 0;
}
-
-private:
- Data *m_data;
};
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<char> )
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
class wxCharBuffer : public wxCharTypeBuffer<char>
{
public:
typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
+ typedef wxScopedCharTypeBuffer<char> wxScopedCharTypeBufferBase;
wxCharBuffer(const wxCharTypeBufferBase& buf)
: wxCharTypeBufferBase(buf) {}
+ wxCharBuffer(const wxScopedCharTypeBufferBase& buf)
+ : wxCharTypeBufferBase(buf) {}
wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
};
#if wxUSE_WCHAR_T
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<wchar_t> )
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
{
public:
typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
+ typedef wxScopedCharTypeBuffer<wchar_t> wxScopedCharTypeBufferBase;
wxWCharBuffer(const wxCharTypeBufferBase& buf)
: wxCharTypeBufferBase(buf) {}
+ wxWCharBuffer(const wxScopedCharTypeBufferBase& buf)
+ : wxCharTypeBufferBase(buf) {}
wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
{
public:
- typedef typename wxCharTypeBuffer<T>::CharType CharType;
+ typedef typename wxScopedCharTypeBuffer<T>::CharType CharType;
- wxWritableCharTypeBuffer(const wxCharTypeBuffer<T>& src)
+ wxWritableCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
: wxCharTypeBuffer<T>(src) {}
// FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
// always return a buffer
+ // + we should derive this class from wxScopedCharTypeBuffer
+ // then
wxWritableCharTypeBuffer(const CharType *str = NULL)
: wxCharTypeBuffer<T>(str) {}
#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)
// ----------------------------------------------------------------------------
// the reference count
size_t m_ref;
- DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
+ wxDECLARE_NO_COPY_CLASS(wxMemoryBufferData);
};
// 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;
projects / wxWidgets.git / blobdiff