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