1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: auto buffer classes: buffers which automatically free memory
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
15 #include "wx/wxchar.h"
17 #include <stdlib.h> // malloc() and free()
19 inline char *wxStrDup(const char *s
) { return wxStrdupA(s
); }
21 inline wchar_t *wxStrDup(const wchar_t *ws
) { return wxStrdupW(ws
); }
24 // ----------------------------------------------------------------------------
25 // Special classes for (wide) character strings: they use malloc/free instead
27 // ----------------------------------------------------------------------------
30 class wxCharTypeBuffer
35 wxCharTypeBuffer(const CharType
*str
= NULL
)
36 : m_str(str
? wxStrDup(str
) : NULL
)
40 wxCharTypeBuffer(size_t len
)
41 : m_str((CharType
*)malloc((len
+ 1)*sizeof(CharType
)))
43 m_str
[len
] = (CharType
)0;
46 /* no need to check for NULL, free() does it */
47 ~wxCharTypeBuffer() { free(m_str
); }
52 the copy ctor and assignment operators change the passed in object
53 even although it is declared as "const", so:
55 a) it shouldn't be really const
56 b) you shouldn't use it afterwards (or know that it was reset)
58 This is very ugly but is unfortunately needed to make the normal use\
59 of wxCharTypeBuffer buffer objects possible and is very similar to what
60 std::auto_ptr<> does (as if it were an excuse...)
64 because of the remark above, release() is declared const even if it
67 CharType
*release() const
70 ((wxCharTypeBuffer
*)this)->m_str
= NULL
;
80 wxCharTypeBuffer(const wxCharTypeBuffer
& src
)
81 : m_str(src
.release())
85 wxCharTypeBuffer
& operator=(const CharType
*str
)
88 m_str
= str
? wxStrDup(str
) : NULL
;
92 wxCharTypeBuffer
& operator=(const wxCharTypeBuffer
& src
)
95 m_str
= src
.release();
100 bool extend(size_t len
)
103 str
= (CharType
*)realloc(m_str
, (len
+ 1)*sizeof(CharType
));
112 CharType
*data() { return m_str
; }
113 const CharType
*data() const { return m_str
; }
114 operator const CharType
*() const { return m_str
; }
115 CharType
operator[](size_t n
) const { return m_str
[n
]; }
121 class WXDLLIMPEXP_BASE wxCharBuffer
: public wxCharTypeBuffer
<char>
124 typedef wxCharTypeBuffer
<char> wxCharTypeBufferBase
;
126 wxCharBuffer(const CharType
*str
= NULL
) : wxCharTypeBufferBase(str
) {}
127 wxCharBuffer(size_t len
) : wxCharTypeBufferBase(len
) {}
129 wxCharBuffer(const wxCStrData
& cstr
);
133 class WXDLLIMPEXP_BASE wxWCharBuffer
: public wxCharTypeBuffer
<wchar_t>
136 typedef wxCharTypeBuffer
<wchar_t> wxCharTypeBufferBase
;
138 wxWCharBuffer(const CharType
*str
= NULL
) : wxCharTypeBufferBase(str
) {}
139 wxWCharBuffer(size_t len
) : wxCharTypeBufferBase(len
) {}
141 wxWCharBuffer(const wxCStrData
& cstr
);
143 #endif // wxUSE_WCHAR_T
145 // wxCharTypeBuffer<T> implicitly convertible to T*
146 template <typename T
>
147 class wxWritableCharTypeBuffer
: public wxCharTypeBuffer
<T
>
150 typedef typename wxCharTypeBuffer
<T
>::CharType CharType
;
152 wxWritableCharTypeBuffer(const wxCharTypeBuffer
<T
>& src
)
153 : wxCharTypeBuffer
<T
>(src
) {}
154 // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
155 // always return a buffer
156 wxWritableCharTypeBuffer(const CharType
*str
= NULL
)
157 : wxCharTypeBuffer
<T
>(str
) {}
159 operator CharType
*() { return this->data(); }
162 typedef wxWritableCharTypeBuffer
<char> wxWritableCharBuffer
;
163 typedef wxWritableCharTypeBuffer
<wchar_t> wxWritableWCharBuffer
;
167 #define wxWxCharBuffer wxWCharBuffer
169 #define wxMB2WXbuf wxWCharBuffer
170 #define wxWX2MBbuf wxCharBuffer
171 #define wxWC2WXbuf wxChar*
172 #define wxWX2WCbuf wxChar*
174 #define wxWxCharBuffer wxCharBuffer
176 #define wxMB2WXbuf wxChar*
177 #define wxWX2MBbuf wxChar*
178 #define wxWC2WXbuf wxCharBuffer
179 #define wxWX2WCbuf wxWCharBuffer
180 #endif // Unicode/ANSI
182 // ----------------------------------------------------------------------------
183 // A class for holding growable data buffers (not necessarily strings)
184 // ----------------------------------------------------------------------------
186 // This class manages the actual data buffer pointer and is ref-counted.
187 class wxMemoryBufferData
190 // the initial size and also the size added by ResizeIfNeeded()
191 enum { DefBufSize
= 1024 };
193 friend class wxMemoryBuffer
;
195 // everyting is private as it can only be used by wxMemoryBuffer
197 wxMemoryBufferData(size_t size
= wxMemoryBufferData::DefBufSize
)
198 : m_data(size
? malloc(size
) : NULL
), m_size(size
), m_len(0), m_ref(0)
201 ~wxMemoryBufferData() { free(m_data
); }
204 void ResizeIfNeeded(size_t newSize
)
206 if (newSize
> m_size
)
208 void *dataOld
= m_data
;
209 m_data
= realloc(m_data
, newSize
+ wxMemoryBufferData::DefBufSize
);
215 m_size
= newSize
+ wxMemoryBufferData::DefBufSize
;
219 void IncRef() { m_ref
+= 1; }
223 if (m_ref
== 0) // are there no more references?
228 // the buffer containing the data
231 // the size of the buffer
234 // the amount of data currently in the buffer
237 // the reference count
240 DECLARE_NO_COPY_CLASS(wxMemoryBufferData
)
248 wxMemoryBuffer(size_t size
= wxMemoryBufferData::DefBufSize
)
250 m_bufdata
= new wxMemoryBufferData(size
);
254 ~wxMemoryBuffer() { m_bufdata
->DecRef(); }
257 // copy and assignment
258 wxMemoryBuffer(const wxMemoryBuffer
& src
)
259 : m_bufdata(src
.m_bufdata
)
264 wxMemoryBuffer
& operator=(const wxMemoryBuffer
& src
)
267 m_bufdata
= src
.m_bufdata
;
274 void *GetData() const { return m_bufdata
->m_data
; }
275 size_t GetBufSize() const { return m_bufdata
->m_size
; }
276 size_t GetDataLen() const { return m_bufdata
->m_len
; }
278 void SetBufSize(size_t size
) { m_bufdata
->ResizeIfNeeded(size
); }
279 void SetDataLen(size_t len
)
281 wxASSERT(len
<= m_bufdata
->m_size
);
282 m_bufdata
->m_len
= len
;
285 // Ensure the buffer is big enough and return a pointer to it
286 void *GetWriteBuf(size_t sizeNeeded
)
288 m_bufdata
->ResizeIfNeeded(sizeNeeded
);
289 return m_bufdata
->m_data
;
292 // Update the length after the write
293 void UngetWriteBuf(size_t sizeUsed
) { SetDataLen(sizeUsed
); }
295 // Like the above, but appends to the buffer
296 void *GetAppendBuf(size_t sizeNeeded
)
298 m_bufdata
->ResizeIfNeeded(m_bufdata
->m_len
+ sizeNeeded
);
299 return (char*)m_bufdata
->m_data
+ m_bufdata
->m_len
;
302 // Update the length after the append
303 void UngetAppendBuf(size_t sizeUsed
)
305 SetDataLen(m_bufdata
->m_len
+ sizeUsed
);
308 // Other ways to append to the buffer
309 void AppendByte(char data
)
311 wxCHECK_RET( m_bufdata
->m_data
, _T("invalid wxMemoryBuffer") );
313 m_bufdata
->ResizeIfNeeded(m_bufdata
->m_len
+ 1);
314 *(((char*)m_bufdata
->m_data
) + m_bufdata
->m_len
) = data
;
315 m_bufdata
->m_len
+= 1;
318 void AppendData(const void *data
, size_t len
)
320 memcpy(GetAppendBuf(len
), data
, len
);
324 operator const char *() const { return (const char*)GetData(); }
327 wxMemoryBufferData
* m_bufdata
;
330 // ----------------------------------------------------------------------------
331 // template class for any kind of data
332 // ----------------------------------------------------------------------------
336 #endif // _WX_BUFFER_H