]> git.saurik.com Git - wxWidgets.git/blob - include/wx/buffer.h
Force wide char environment version initialization in wxGetEnvMap().
[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 // helpers used by wxCharTypeBuffer
28 namespace wxPrivate
29 {
30
31 struct UntypedBufferData
32 {
33 enum Kind
34 {
35 Owned,
36 NonOwned
37 };
38
39 UntypedBufferData(void *str, size_t len, Kind kind = Owned)
40 : m_str(str), m_length(len), m_ref(1), m_owned(kind == Owned) {}
41
42 ~UntypedBufferData()
43 {
44 if ( m_owned )
45 free(m_str);
46 }
47
48 void *m_str;
49 size_t m_length;
50
51 // "short" to have sizeof(Data)=12 on 32bit archs
52 unsigned short m_ref;
53
54 bool m_owned;
55 };
56
57 // NB: this is defined in string.cpp and not the (non-existent) buffer.cpp
58 WXDLLIMPEXP_BASE UntypedBufferData * GetUntypedNullData();
59
60 } // namespace wxPrivate
61
62
63 // Reference-counted character buffer for storing string data. The buffer
64 // is only valid for as long as the "parent" object that provided the data
65 // is valid; see wxCharTypeBuffer<T> for persistent variant.
66 template <typename T>
67 class wxScopedCharTypeBuffer
68 {
69 public:
70 typedef T CharType;
71
72 wxScopedCharTypeBuffer()
73 {
74 m_data = GetNullData();
75 }
76
77 // Creates "non-owned" buffer, i.e. 'str' is not owned by the buffer
78 // and doesn't get freed by dtor. Used e.g. to point to wxString's internal
79 // storage.
80 static
81 const wxScopedCharTypeBuffer CreateNonOwned(const CharType *str,
82 size_t len = wxNO_LEN)
83 {
84 if ( len == wxNO_LEN )
85 len = wxStrlen(str);
86
87 wxScopedCharTypeBuffer buf;
88 if ( str )
89 buf.m_data = new Data(const_cast<CharType*>(str), len, Data::NonOwned);
90 return buf;
91 }
92
93 // Creates "owned" buffer, i.e. takes over ownership of 'str' and frees it
94 // in dtor (if ref.count reaches 0).
95 static
96 const wxScopedCharTypeBuffer CreateOwned(CharType *str,
97 size_t len = wxNO_LEN )
98 {
99 if ( len == wxNO_LEN )
100 len = wxStrlen(str);
101
102 wxScopedCharTypeBuffer buf;
103 if ( str )
104 buf.m_data = new Data(str, len);
105 return buf;
106 }
107
108 wxScopedCharTypeBuffer(const wxScopedCharTypeBuffer& src)
109 {
110 m_data = src.m_data;
111 IncRef();
112 }
113
114 wxScopedCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& src)
115 {
116 if ( &src == this )
117 return *this;
118
119 DecRef();
120 m_data = src.m_data;
121 IncRef();
122
123 return *this;
124 }
125
126 ~wxScopedCharTypeBuffer()
127 {
128 DecRef();
129 }
130
131 // NB: this method is only const for backward compatibility. It used to
132 // be needed for auto_ptr-like semantics of the copy ctor, but now
133 // that ref-counting is used, it's not really needed.
134 CharType *release() const
135 {
136 if ( m_data == GetNullData() )
137 return NULL;
138
139 wxASSERT_MSG( m_data->m_owned, wxT("can't release non-owned buffer") );
140 wxASSERT_MSG( m_data->m_ref == 1, wxT("can't release shared buffer") );
141
142 CharType * const p = m_data->Get();
143
144 wxScopedCharTypeBuffer *self = const_cast<wxScopedCharTypeBuffer*>(this);
145 self->m_data->Set(NULL, 0);
146 self->DecRef();
147
148 return p;
149 }
150
151 void reset()
152 {
153 DecRef();
154 }
155
156 CharType *data() { return m_data->Get(); }
157 const CharType *data() const { return m_data->Get(); }
158 operator const CharType *() const { return data(); }
159 CharType operator[](size_t n) const { return data()[n]; }
160
161 size_t length() const { return m_data->m_length; }
162
163 protected:
164 // reference-counted data
165 struct Data : public wxPrivate::UntypedBufferData
166 {
167 Data(CharType *str, size_t len, Kind kind = Owned)
168 : wxPrivate::UntypedBufferData(str, len, kind)
169 {
170 }
171
172 CharType *Get() const { return static_cast<CharType *>(m_str); }
173 void Set(CharType *str, size_t len)
174 {
175 m_str = str;
176 m_length = len;
177 }
178 };
179
180 // placeholder for NULL string, to simplify this code
181 static Data *GetNullData()
182 {
183 return static_cast<Data *>(wxPrivate::GetUntypedNullData());
184 }
185
186 void IncRef()
187 {
188 if ( m_data == GetNullData() ) // exception, not ref-counted
189 return;
190 m_data->m_ref++;
191 }
192
193 void DecRef()
194 {
195 if ( m_data == GetNullData() ) // exception, not ref-counted
196 return;
197 if ( --m_data->m_ref == 0 )
198 delete m_data;
199 m_data = GetNullData();
200 }
201
202 // sets this object to a be copy of 'other'; if 'src' is non-owned,
203 // a deep copy is made and 'this' will contain new instance of the data
204 void MakeOwnedCopyOf(const wxScopedCharTypeBuffer& src)
205 {
206 this->DecRef();
207
208 if ( src.m_data == this->GetNullData() )
209 {
210 this->m_data = this->GetNullData();
211 }
212 else if ( src.m_data->m_owned )
213 {
214 this->m_data = src.m_data;
215 this->IncRef();
216 }
217 else
218 {
219 // if the scoped buffer had non-owned data, we have to make
220 // a copy here, because src.m_data->m_str is valid only for as long
221 // as 'src' exists
222 this->m_data = new Data
223 (
224 StrCopy(src.data(), src.length()),
225 src.length()
226 );
227 }
228 }
229
230 static CharType *StrCopy(const CharType *src, size_t len)
231 {
232 CharType *dst = (CharType*)malloc(sizeof(CharType) * (len + 1));
233 memcpy(dst, src, sizeof(CharType) * (len + 1));
234 return dst;
235 }
236
237 protected:
238 Data *m_data;
239 };
240
241 typedef wxScopedCharTypeBuffer<char> wxScopedCharBuffer;
242 typedef wxScopedCharTypeBuffer<wchar_t> wxScopedWCharBuffer;
243
244
245 // this buffer class always stores data in "owned" (persistent) manner
246 template <typename T>
247 class wxCharTypeBuffer : public wxScopedCharTypeBuffer<T>
248 {
249 protected:
250 typedef typename wxScopedCharTypeBuffer<T>::Data Data;
251
252 public:
253 typedef T CharType;
254
255 wxCharTypeBuffer(const CharType *str = NULL, size_t len = wxNO_LEN)
256 {
257 if ( str )
258 {
259 if ( len == wxNO_LEN )
260 len = wxStrlen(str);
261 this->m_data = new Data(this->StrCopy(str, len), len);
262 }
263 else
264 {
265 this->m_data = this->GetNullData();
266 }
267 }
268
269 wxCharTypeBuffer(size_t len)
270 {
271 this->m_data =
272 new Data((CharType *)malloc((len + 1)*sizeof(CharType)), len);
273 this->m_data->Get()[len] = (CharType)0;
274 }
275
276 wxCharTypeBuffer(const wxCharTypeBuffer& src)
277 : wxScopedCharTypeBuffer<T>(src) {}
278
279 wxCharTypeBuffer& operator=(const CharType *str)
280 {
281 this->DecRef();
282
283 if ( str )
284 this->m_data = new Data(wxStrdup(str), wxStrlen(str));
285 return *this;
286 }
287
288 wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
289 {
290 wxScopedCharTypeBuffer<T>::operator=(src);
291 return *this;
292 }
293
294 wxCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
295 {
296 this->MakeOwnedCopyOf(src);
297 }
298
299 wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer<T>& src)
300 {
301 MakeOwnedCopyOf(src);
302 return *this;
303 }
304
305 bool extend(size_t len)
306 {
307 wxASSERT_MSG( this->m_data->m_owned, "cannot extend non-owned buffer" );
308 wxASSERT_MSG( this->m_data->m_ref == 1, "can't extend shared buffer" );
309
310 CharType *str =
311 (CharType *)realloc(this->data(), (len + 1) * sizeof(CharType));
312 if ( !str )
313 return false;
314
315 // For consistency with the ctor taking just the length, NUL-terminate
316 // the buffer.
317 str[len] = (CharType)0;
318
319 if ( this->m_data == this->GetNullData() )
320 {
321 this->m_data = new Data(str, len);
322 }
323 else
324 {
325 this->m_data->Set(str, len);
326 this->m_data->m_owned = true;
327 }
328
329 return true;
330 }
331
332 void shrink(size_t len)
333 {
334 wxASSERT_MSG( this->m_data->m_owned, "cannot shrink non-owned buffer" );
335 wxASSERT_MSG( this->m_data->m_ref == 1, "can't shrink shared buffer" );
336
337 wxASSERT( len <= this->length() );
338
339 this->m_data->m_length = len;
340 this->data()[len] = 0;
341 }
342 };
343
344 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<char> )
345 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
346
347 class wxCharBuffer : public wxCharTypeBuffer<char>
348 {
349 public:
350 typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
351 typedef wxScopedCharTypeBuffer<char> wxScopedCharTypeBufferBase;
352
353 wxCharBuffer(const wxCharTypeBufferBase& buf)
354 : wxCharTypeBufferBase(buf) {}
355 wxCharBuffer(const wxScopedCharTypeBufferBase& buf)
356 : wxCharTypeBufferBase(buf) {}
357
358 wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
359 wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
360
361 wxCharBuffer(const wxCStrData& cstr);
362 };
363
364 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<wchar_t> )
365 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
366
367 class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
368 {
369 public:
370 typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
371 typedef wxScopedCharTypeBuffer<wchar_t> wxScopedCharTypeBufferBase;
372
373 wxWCharBuffer(const wxCharTypeBufferBase& buf)
374 : wxCharTypeBufferBase(buf) {}
375 wxWCharBuffer(const wxScopedCharTypeBufferBase& buf)
376 : wxCharTypeBufferBase(buf) {}
377
378 wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
379 wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
380
381 wxWCharBuffer(const wxCStrData& cstr);
382 };
383
384 // wxCharTypeBuffer<T> implicitly convertible to T*
385 template <typename T>
386 class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
387 {
388 public:
389 typedef typename wxScopedCharTypeBuffer<T>::CharType CharType;
390
391 wxWritableCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
392 : wxCharTypeBuffer<T>(src) {}
393 // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
394 // always return a buffer
395 // + we should derive this class from wxScopedCharTypeBuffer
396 // then
397 wxWritableCharTypeBuffer(const CharType *str = NULL)
398 : wxCharTypeBuffer<T>(str) {}
399
400 operator CharType*() { return this->data(); }
401 };
402
403 typedef wxWritableCharTypeBuffer<char> wxWritableCharBuffer;
404 typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
405
406
407 #if wxUSE_UNICODE
408 #define wxWxCharBuffer wxWCharBuffer
409
410 #define wxMB2WXbuf wxWCharBuffer
411 #define wxWX2MBbuf wxCharBuffer
412 #if wxUSE_UNICODE_WCHAR
413 #define wxWC2WXbuf wxChar*
414 #define wxWX2WCbuf wxChar*
415 #elif wxUSE_UNICODE_UTF8
416 #define wxWC2WXbuf wxWCharBuffer
417 #define wxWX2WCbuf wxWCharBuffer
418 #endif
419 #else // ANSI
420 #define wxWxCharBuffer wxCharBuffer
421
422 #define wxMB2WXbuf wxChar*
423 #define wxWX2MBbuf wxChar*
424 #define wxWC2WXbuf wxCharBuffer
425 #define wxWX2WCbuf wxWCharBuffer
426 #endif // Unicode/ANSI
427
428 // ----------------------------------------------------------------------------
429 // A class for holding growable data buffers (not necessarily strings)
430 // ----------------------------------------------------------------------------
431
432 // This class manages the actual data buffer pointer and is ref-counted.
433 class wxMemoryBufferData
434 {
435 public:
436 // the initial size and also the size added by ResizeIfNeeded()
437 enum { DefBufSize = 1024 };
438
439 friend class wxMemoryBuffer;
440
441 // everyting is private as it can only be used by wxMemoryBuffer
442 private:
443 wxMemoryBufferData(size_t size = wxMemoryBufferData::DefBufSize)
444 : m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)
445 {
446 }
447 ~wxMemoryBufferData() { free(m_data); }
448
449
450 void ResizeIfNeeded(size_t newSize)
451 {
452 if (newSize > m_size)
453 {
454 void *dataOld = m_data;
455 m_data = realloc(m_data, newSize + wxMemoryBufferData::DefBufSize);
456 if ( !m_data )
457 {
458 free(dataOld);
459 }
460
461 m_size = newSize + wxMemoryBufferData::DefBufSize;
462 }
463 }
464
465 void IncRef() { m_ref += 1; }
466 void DecRef()
467 {
468 m_ref -= 1;
469 if (m_ref == 0) // are there no more references?
470 delete this;
471 }
472
473 void *release()
474 {
475 if ( m_data == NULL )
476 return NULL;
477
478 wxASSERT_MSG( m_ref == 1, "can't release shared buffer" );
479
480 void *p = m_data;
481 m_data = NULL;
482 m_len =
483 m_size = 0;
484
485 return p;
486 }
487
488
489 // the buffer containing the data
490 void *m_data;
491
492 // the size of the buffer
493 size_t m_size;
494
495 // the amount of data currently in the buffer
496 size_t m_len;
497
498 // the reference count
499 size_t m_ref;
500
501 wxDECLARE_NO_COPY_CLASS(wxMemoryBufferData);
502 };
503
504
505 class wxMemoryBuffer
506 {
507 public:
508 // ctor and dtor
509 wxMemoryBuffer(size_t size = wxMemoryBufferData::DefBufSize)
510 {
511 m_bufdata = new wxMemoryBufferData(size);
512 m_bufdata->IncRef();
513 }
514
515 ~wxMemoryBuffer() { m_bufdata->DecRef(); }
516
517
518 // copy and assignment
519 wxMemoryBuffer(const wxMemoryBuffer& src)
520 : m_bufdata(src.m_bufdata)
521 {
522 m_bufdata->IncRef();
523 }
524
525 wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
526 {
527 if (&src != this)
528 {
529 m_bufdata->DecRef();
530 m_bufdata = src.m_bufdata;
531 m_bufdata->IncRef();
532 }
533 return *this;
534 }
535
536
537 // Accessors
538 void *GetData() const { return m_bufdata->m_data; }
539 size_t GetBufSize() const { return m_bufdata->m_size; }
540 size_t GetDataLen() const { return m_bufdata->m_len; }
541
542 bool IsEmpty() const { return GetDataLen() == 0; }
543
544 void SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
545 void SetDataLen(size_t len)
546 {
547 wxASSERT(len <= m_bufdata->m_size);
548 m_bufdata->m_len = len;
549 }
550
551 void Clear() { SetDataLen(0); }
552
553 // Ensure the buffer is big enough and return a pointer to it
554 void *GetWriteBuf(size_t sizeNeeded)
555 {
556 m_bufdata->ResizeIfNeeded(sizeNeeded);
557 return m_bufdata->m_data;
558 }
559
560 // Update the length after the write
561 void UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }
562
563 // Like the above, but appends to the buffer
564 void *GetAppendBuf(size_t sizeNeeded)
565 {
566 m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded);
567 return (char*)m_bufdata->m_data + m_bufdata->m_len;
568 }
569
570 // Update the length after the append
571 void UngetAppendBuf(size_t sizeUsed)
572 {
573 SetDataLen(m_bufdata->m_len + sizeUsed);
574 }
575
576 // Other ways to append to the buffer
577 void AppendByte(char data)
578 {
579 wxCHECK_RET( m_bufdata->m_data, wxT("invalid wxMemoryBuffer") );
580
581 m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
582 *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;
583 m_bufdata->m_len += 1;
584 }
585
586 void AppendData(const void *data, size_t len)
587 {
588 memcpy(GetAppendBuf(len), data, len);
589 UngetAppendBuf(len);
590 }
591
592 operator const char *() const { return (const char*)GetData(); }
593
594 // gives up ownership of data, returns the pointer; after this call,
595 // data isn't freed by the buffer and its content is resent to empty
596 void *release()
597 {
598 return m_bufdata->release();
599 }
600
601 private:
602 wxMemoryBufferData* m_bufdata;
603 };
604
605 // ----------------------------------------------------------------------------
606 // template class for any kind of data
607 // ----------------------------------------------------------------------------
608
609 // TODO
610
611 #endif // _WX_BUFFER_H