]> git.saurik.com Git - wxWidgets.git/blob - include/wx/buffer.h
cleanup
[wxWidgets.git] / include / wx / buffer.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: wx/buffer.h
3 // Purpose: auto buffer classes: buffers which automatically free memory
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 12.04.99
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_BUFFER_H
13 #define _WX_BUFFER_H
14
15 #include "wx/chartype.h"
16 #include "wx/wxcrtbase.h"
17
18 #include <stdlib.h> // malloc() and free()
19
20 class WXDLLIMPEXP_FWD_BASE wxCStrData;
21
22 // ----------------------------------------------------------------------------
23 // Special classes for (wide) character strings: they use malloc/free instead
24 // of new/delete
25 // ----------------------------------------------------------------------------
26
27 template <typename T>
28 class WXDLLIMPEXP_BASE wxCharTypeBuffer
29 {
30 public:
31 typedef T CharType;
32
33 wxCharTypeBuffer(const CharType *str = NULL)
34 : m_str(str ? wxStrdup(str) : NULL),
35 m_owned(true)
36 {
37 }
38
39 wxCharTypeBuffer(size_t len)
40 : m_str((CharType *)malloc((len + 1)*sizeof(CharType))),
41 m_owned(true)
42 {
43 m_str[len] = (CharType)0;
44 }
45
46 static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
47 {
48 wxCharTypeBuffer buf;
49 buf.m_str = wx_const_cast(CharType*, str);
50 buf.m_owned = false;
51 return buf;
52 }
53
54 /* no need to check for NULL, free() does it */
55 ~wxCharTypeBuffer()
56 {
57 if ( m_owned)
58 free(m_str);
59 }
60
61 /*
62 WARNING:
63
64 the copy ctor and assignment operators change the passed in object
65 even although it is declared as "const", so:
66
67 a) it shouldn't be really const
68 b) you shouldn't use it afterwards (or know that it was reset)
69
70 This is very ugly but is unfortunately needed to make the normal use
71 of wxCharTypeBuffer buffer objects possible and is very similar to what
72 std::auto_ptr<> does (as if it were an excuse...)
73 */
74
75 /*
76 because of the remark above, release() is declared const even if it
77 isn't really const
78 */
79 CharType *release() const
80 {
81 wxASSERT_MSG( m_owned, _T("can't release non-owned buffer") );
82 return DoRelease();
83 }
84
85 void reset()
86 {
87 if ( m_owned )
88 free(m_str);
89 m_str = NULL;
90 }
91
92 wxCharTypeBuffer(const wxCharTypeBuffer& src)
93 {
94 CopyFrom(src);
95 }
96
97 wxCharTypeBuffer& operator=(const CharType *str)
98 {
99 if ( m_owned )
100 free(m_str);
101 m_str = str ? wxStrdup(str) : NULL;
102 m_owned = true;
103 return *this;
104 }
105
106 wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
107 {
108 if ( m_owned )
109 free(m_str);
110 CopyFrom(src);
111 return *this;
112 }
113
114 bool extend(size_t len)
115 {
116 wxASSERT_MSG( m_owned, _T("cannot extend non-owned buffer") );
117
118 CharType *
119 str = (CharType *)realloc(m_str, (len + 1)*sizeof(CharType));
120 if ( !str )
121 return false;
122
123 m_str = str;
124
125 return true;
126 }
127
128 CharType *data() { return m_str; }
129 const CharType *data() const { return m_str; }
130 operator const CharType *() const { return m_str; }
131 CharType operator[](size_t n) const { return m_str[n]; }
132
133
134 private:
135 CharType *DoRelease() const
136 {
137 CharType *p = m_str;
138 ((wxCharTypeBuffer *)this)->m_str = NULL;
139 return p;
140 }
141
142 void CopyFrom(const wxCharTypeBuffer& src)
143 {
144 m_owned = src.m_owned;
145 m_str = src.DoRelease();
146 }
147
148 private:
149 CharType *m_str;
150 bool m_owned;
151 };
152
153 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
154
155 class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
156 {
157 public:
158 typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
159
160 wxCharBuffer(const wxCharTypeBufferBase& buf)
161 : wxCharTypeBufferBase(buf) {}
162
163 wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
164 wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
165
166 wxCharBuffer(const wxCStrData& cstr);
167 };
168
169 #if wxUSE_WCHAR_T
170 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
171
172 class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
173 {
174 public:
175 typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
176
177 wxWCharBuffer(const wxCharTypeBufferBase& buf)
178 : wxCharTypeBufferBase(buf) {}
179
180 wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
181 wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
182
183 wxWCharBuffer(const wxCStrData& cstr);
184 };
185 #endif // wxUSE_WCHAR_T
186
187 // wxCharTypeBuffer<T> implicitly convertible to T*
188 template <typename T>
189 class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
190 {
191 public:
192 typedef typename wxCharTypeBuffer<T>::CharType CharType;
193
194 wxWritableCharTypeBuffer(const wxCharTypeBuffer<T>& src)
195 : wxCharTypeBuffer<T>(src) {}
196 // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
197 // always return a buffer
198 wxWritableCharTypeBuffer(const CharType *str = NULL)
199 : wxCharTypeBuffer<T>(str) {}
200
201 operator CharType*() { return this->data(); }
202 };
203
204 typedef wxWritableCharTypeBuffer<char> wxWritableCharBuffer;
205 typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
206
207
208 #if wxUSE_UNICODE
209 #define wxWxCharBuffer wxWCharBuffer
210
211 #define wxMB2WXbuf wxWCharBuffer
212 #define wxWX2MBbuf wxCharBuffer
213 #if wxUSE_UNICODE_WCHAR
214 #define wxWC2WXbuf wxChar*
215 #define wxWX2WCbuf wxChar*
216 #elif wxUSE_UNICODE_UTF8
217 #define wxWC2WXbuf wxWCharBuffer
218 #define wxWX2WCbuf wxWCharBuffer
219 #endif
220 #else // ANSI
221 #define wxWxCharBuffer wxCharBuffer
222
223 #define wxMB2WXbuf wxChar*
224 #define wxWX2MBbuf wxChar*
225 #define wxWC2WXbuf wxCharBuffer
226 #define wxWX2WCbuf wxWCharBuffer
227 #endif // Unicode/ANSI
228
229 // type of the value returned by wxString::utf8_str()
230 #if wxUSE_UNICODE_UTF8
231 #define wxUTF8Buf wxCharBuffer
232 #else
233 #define wxUTF8Buf char *
234 #endif
235
236 // ----------------------------------------------------------------------------
237 // A class for holding growable data buffers (not necessarily strings)
238 // ----------------------------------------------------------------------------
239
240 // This class manages the actual data buffer pointer and is ref-counted.
241 class wxMemoryBufferData
242 {
243 public:
244 // the initial size and also the size added by ResizeIfNeeded()
245 enum { DefBufSize = 1024 };
246
247 friend class wxMemoryBuffer;
248
249 // everyting is private as it can only be used by wxMemoryBuffer
250 private:
251 wxMemoryBufferData(size_t size = wxMemoryBufferData::DefBufSize)
252 : m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)
253 {
254 }
255 ~wxMemoryBufferData() { free(m_data); }
256
257
258 void ResizeIfNeeded(size_t newSize)
259 {
260 if (newSize > m_size)
261 {
262 void *dataOld = m_data;
263 m_data = realloc(m_data, newSize + wxMemoryBufferData::DefBufSize);
264 if ( !m_data )
265 {
266 free(dataOld);
267 }
268
269 m_size = newSize + wxMemoryBufferData::DefBufSize;
270 }
271 }
272
273 void IncRef() { m_ref += 1; }
274 void DecRef()
275 {
276 m_ref -= 1;
277 if (m_ref == 0) // are there no more references?
278 delete this;
279 }
280
281
282 // the buffer containing the data
283 void *m_data;
284
285 // the size of the buffer
286 size_t m_size;
287
288 // the amount of data currently in the buffer
289 size_t m_len;
290
291 // the reference count
292 size_t m_ref;
293
294 DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
295 };
296
297
298 class WXDLLIMPEXP_BASE wxMemoryBuffer
299 {
300 public:
301 // ctor and dtor
302 wxMemoryBuffer(size_t size = wxMemoryBufferData::DefBufSize)
303 {
304 m_bufdata = new wxMemoryBufferData(size);
305 m_bufdata->IncRef();
306 }
307
308 ~wxMemoryBuffer() { m_bufdata->DecRef(); }
309
310
311 // copy and assignment
312 wxMemoryBuffer(const wxMemoryBuffer& src)
313 : m_bufdata(src.m_bufdata)
314 {
315 m_bufdata->IncRef();
316 }
317
318 wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
319 {
320 m_bufdata->DecRef();
321 m_bufdata = src.m_bufdata;
322 m_bufdata->IncRef();
323 return *this;
324 }
325
326
327 // Accessors
328 void *GetData() const { return m_bufdata->m_data; }
329 size_t GetBufSize() const { return m_bufdata->m_size; }
330 size_t GetDataLen() const { return m_bufdata->m_len; }
331
332 void SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
333 void SetDataLen(size_t len)
334 {
335 wxASSERT(len <= m_bufdata->m_size);
336 m_bufdata->m_len = len;
337 }
338
339 // Ensure the buffer is big enough and return a pointer to it
340 void *GetWriteBuf(size_t sizeNeeded)
341 {
342 m_bufdata->ResizeIfNeeded(sizeNeeded);
343 return m_bufdata->m_data;
344 }
345
346 // Update the length after the write
347 void UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }
348
349 // Like the above, but appends to the buffer
350 void *GetAppendBuf(size_t sizeNeeded)
351 {
352 m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded);
353 return (char*)m_bufdata->m_data + m_bufdata->m_len;
354 }
355
356 // Update the length after the append
357 void UngetAppendBuf(size_t sizeUsed)
358 {
359 SetDataLen(m_bufdata->m_len + sizeUsed);
360 }
361
362 // Other ways to append to the buffer
363 void AppendByte(char data)
364 {
365 wxCHECK_RET( m_bufdata->m_data, _T("invalid wxMemoryBuffer") );
366
367 m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
368 *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;
369 m_bufdata->m_len += 1;
370 }
371
372 void AppendData(const void *data, size_t len)
373 {
374 memcpy(GetAppendBuf(len), data, len);
375 UngetAppendBuf(len);
376 }
377
378 operator const char *() const { return (const char*)GetData(); }
379
380 private:
381 wxMemoryBufferData* m_bufdata;
382 };
383
384 // ----------------------------------------------------------------------------
385 // template class for any kind of data
386 // ----------------------------------------------------------------------------
387
388 // TODO
389
390 #endif // _WX_BUFFER_H