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/wxchar.h"
  16
  17 #include <stdlib.h>             // malloc() and free()
  18
  19 inline char *wxStrDup(const char *s) { return wxStrdupA(s); }
  20 #if wxUSE_WCHAR_T
  21     inline wchar_t *wxStrDup(const wchar_t *ws) { return wxStrdupW(ws); }
  22 #endif
  23
  24 // ----------------------------------------------------------------------------
  25 // Special classes for (wide) character strings: they use malloc/free instead
  26 // of new/delete
  27 // ----------------------------------------------------------------------------
  28
  29 template <typename T>
  30 class wxCharTypeBuffer
  31 {
  32 public:
  33     typedef T CharType;
  34
  35     wxCharTypeBuffer(const CharType *str = NULL)
  36         : m_str(str ? wxStrDup(str) : NULL)
  37     {
  38     }
  39
  40     wxCharTypeBuffer(size_t len)
  41         : m_str((CharType *)malloc((len + 1)*sizeof(CharType)))
  42     {
  43         m_str[len] = (CharType)0;
  44     }
  45
  46     /* no need to check for NULL, free() does it */
  47     ~wxCharTypeBuffer() { free(m_str); }
  48
  49     /*
  50         WARNING:
  51
  52         the copy ctor and assignment operators change the passed in object
  53         even although it is declared as "const", so:
  54
  55         a) it shouldn't be really const
  56         b) you shouldn't use it afterwards (or know that it was reset)
  57
  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...)
  61     */
  62
  63     /*
  64        because of the remark above, release() is declared const even if it
  65        isn't really const
  66      */
  67     CharType *release() const
  68     {
  69         CharType *p = m_str;
  70         ((wxCharTypeBuffer *)this)->m_str = NULL;
  71         return p;
  72     }
  73
  74     void reset()
  75     {
  76         free(m_str);
  77         m_str = NULL;
  78     }
  79
  80     wxCharTypeBuffer(const wxCharTypeBuffer& src)
  81         : m_str(src.release())
  82     {
  83     }
  84
  85     wxCharTypeBuffer& operator=(const CharType *str)
  86     {
  87         free(m_str);
  88         m_str = str ? wxStrDup(str) : NULL;
  89         return *this;
  90     }
  91
  92     wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
  93     {
  94         free(m_str);
  95         m_str = src.release();
  96
  97         return *this;
  98     }
  99
 100     bool extend(size_t len)
 101     {
 102         CharType *
 103             str = (CharType *)realloc(m_str, (len + 1)*sizeof(CharType));
 104         if ( !str )
 105             return false;
 106
 107         m_str = str;
 108
 109         return true;
 110     }
 111
 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]; }
 116
 117 private:
 118     CharType *m_str;
 119 };
 120
 121 class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
 122 {
 123 public:
 124     typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
 125
 126     wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
 127     wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 128
 129 #if !wxUSE_UNICODE
 130     wxCharBuffer(const wxCStrData& cstr);
 131 #endif
 132 };
 133
 134 #if wxUSE_WCHAR_T
 135 class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
 136 {
 137 public:
 138     typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
 139
 140     wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
 141     wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 142
 143 #if wxUSE_UNICODE
 144     wxWCharBuffer(const wxCStrData& cstr);
 145 #endif
 146 };
 147 #endif // wxUSE_WCHAR_T
 148
 149 // wxCharTypeBuffer<T> implicitly convertible to T*
 150 template <typename T>
 151 class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
 152 {
 153 public:
 154     typedef typename wxCharTypeBuffer<T>::CharType CharType;
 155
 156     wxWritableCharTypeBuffer(const wxCharTypeBuffer<T>& src)
 157         : wxCharTypeBuffer<T>(src) {}
 158     // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
 159     //             always return a buffer
 160     wxWritableCharTypeBuffer(const CharType *str = NULL)
 161         : wxCharTypeBuffer<T>(str) {}
 162
 163     operator CharType*() { return this->data(); }
 164 };
 165
 166 typedef wxWritableCharTypeBuffer<char> wxWritableCharBuffer;
 167 typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
 168
 169
 170 #if wxUSE_UNICODE
 171     #define wxWxCharBuffer wxWCharBuffer
 172
 173     #define wxMB2WXbuf wxWCharBuffer
 174     #define wxWX2MBbuf wxCharBuffer
 175     #define wxWC2WXbuf wxChar*
 176     #define wxWX2WCbuf wxChar*
 177 #else // ANSI
 178     #define wxWxCharBuffer wxCharBuffer
 179
 180     #define wxMB2WXbuf wxChar*
 181     #define wxWX2MBbuf wxChar*
 182     #define wxWC2WXbuf wxCharBuffer
 183     #define wxWX2WCbuf wxWCharBuffer
 184 #endif // Unicode/ANSI
 185
 186 // ----------------------------------------------------------------------------
 187 // A class for holding growable data buffers (not necessarily strings)
 188 // ----------------------------------------------------------------------------
 189
 190 // This class manages the actual data buffer pointer and is ref-counted.
 191 class wxMemoryBufferData
 192 {
 193 public:
 194     // the initial size and also the size added by ResizeIfNeeded()
 195     enum { DefBufSize = 1024 };
 196
 197     friend class wxMemoryBuffer;
 198
 199     // everyting is private as it can only be used by wxMemoryBuffer
 200 private:
 201     wxMemoryBufferData(size_t size = wxMemoryBufferData::DefBufSize)
 202         : m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)
 203     {
 204     }
 205     ~wxMemoryBufferData() { free(m_data); }
 206
 207
 208     void ResizeIfNeeded(size_t newSize)
 209     {
 210         if (newSize > m_size)
 211         {
 212             void *dataOld = m_data;
 213             m_data = realloc(m_data, newSize + wxMemoryBufferData::DefBufSize);
 214             if ( !m_data )
 215             {
 216                 free(dataOld);
 217             }
 218
 219             m_size = newSize + wxMemoryBufferData::DefBufSize;
 220         }
 221     }
 222
 223     void IncRef() { m_ref += 1; }
 224     void DecRef()
 225     {
 226         m_ref -= 1;
 227         if (m_ref == 0)  // are there no more references?
 228             delete this;
 229     }
 230
 231
 232     // the buffer containing the data
 233     void  *m_data;
 234
 235     // the size of the buffer
 236     size_t m_size;
 237
 238     // the amount of data currently in the buffer
 239     size_t m_len;
 240
 241     // the reference count
 242     size_t m_ref;
 243
 244     DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
 245 };
 246
 247
 248 class wxMemoryBuffer
 249 {
 250 public:
 251     // ctor and dtor
 252     wxMemoryBuffer(size_t size = wxMemoryBufferData::DefBufSize)
 253     {
 254         m_bufdata = new wxMemoryBufferData(size);
 255         m_bufdata->IncRef();
 256     }
 257
 258     ~wxMemoryBuffer() { m_bufdata->DecRef(); }
 259
 260
 261     // copy and assignment
 262     wxMemoryBuffer(const wxMemoryBuffer& src)
 263         : m_bufdata(src.m_bufdata)
 264     {
 265         m_bufdata->IncRef();
 266     }
 267
 268     wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
 269     {
 270         m_bufdata->DecRef();
 271         m_bufdata = src.m_bufdata;
 272         m_bufdata->IncRef();
 273         return *this;
 274     }
 275
 276
 277     // Accessors
 278     void  *GetData() const    { return m_bufdata->m_data; }
 279     size_t GetBufSize() const { return m_bufdata->m_size; }
 280     size_t GetDataLen() const { return m_bufdata->m_len; }
 281
 282     void   SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
 283     void   SetDataLen(size_t len)
 284     {
 285         wxASSERT(len <= m_bufdata->m_size);
 286         m_bufdata->m_len = len;
 287     }
 288
 289     // Ensure the buffer is big enough and return a pointer to it
 290     void *GetWriteBuf(size_t sizeNeeded)
 291     {
 292         m_bufdata->ResizeIfNeeded(sizeNeeded);
 293         return m_bufdata->m_data;
 294     }
 295
 296     // Update the length after the write
 297     void  UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }
 298
 299     // Like the above, but appends to the buffer
 300     void *GetAppendBuf(size_t sizeNeeded)
 301     {
 302         m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded);
 303         return (char*)m_bufdata->m_data + m_bufdata->m_len;
 304     }
 305
 306     // Update the length after the append
 307     void  UngetAppendBuf(size_t sizeUsed)
 308     {
 309         SetDataLen(m_bufdata->m_len + sizeUsed);
 310     }
 311
 312     // Other ways to append to the buffer
 313     void  AppendByte(char data)
 314     {
 315         wxCHECK_RET( m_bufdata->m_data, _T("invalid wxMemoryBuffer") );
 316
 317         m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
 318         *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;
 319         m_bufdata->m_len += 1;
 320     }
 321
 322     void  AppendData(const void *data, size_t len)
 323     {
 324         memcpy(GetAppendBuf(len), data, len);
 325         UngetAppendBuf(len);
 326     }
 327
 328     operator const char *() const { return (const char*)GetData(); }
 329
 330 private:
 331     wxMemoryBufferData*  m_bufdata;
 332 };
 333
 334 // ----------------------------------------------------------------------------
 335 // template class for any kind of data
 336 // ----------------------------------------------------------------------------
 337
 338 // TODO
 339
 340 #endif // _WX_BUFFER_H