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 // these classes are for private use only for now, they're not documented
  13
  14 #ifndef _WX_BUFFER_H
  15 #define _WX_BUFFER_H
  16
  17 #include "wx/wxchar.h"
  18
  19 // ----------------------------------------------------------------------------
  20 // Special classes for (wide) character strings: they use malloc/free instead
  21 // of new/delete
  22 // ----------------------------------------------------------------------------
  23
  24 #define DEFINE_BUFFER(classname, chartype, strdupfunc)                      \
  25 class classname                                                             \
  26 {                                                                           \
  27 public:                                                                     \
  28     classname(const chartype *str)                                          \
  29         : m_str(str ? strdupfunc(str) : NULL)                               \
  30     {                                                                       \
  31     }                                                                       \
  32                                                                             \
  33     classname(size_t len)                                                   \
  34         : m_str((chartype *)malloc((len + 1)*sizeof(chartype)))             \
  35     {                                                                       \
  36         m_str[len] = (chartype)0;                                           \
  37     }                                                                       \
  38                                                                             \
  39     /* no need to check for NULL, free() does it */                         \
  40     ~classname() { free(m_str); }                                           \
  41                                                                             \
  42     /*                                                                      \
  43         WARNING:                                                            \
  44                                                                             \
  45         the copy ctor and assignment operators change the passed in object  \
  46         even although it is declared as "const", so:                        \
  47                                                                             \
  48         a) it shouldn't be really const                                     \
  49         b) you shouldn't use it afterwards (or know that it was reset)      \
  50                                                                             \
  51         This is very ugly but is unfortunately needed to make the normal use\
  52         of classname buffer objects possible and is very similar to what    \
  53         std::auto_ptr<> does (as if it were an excuse...)                   \
  54     */                                                                      \
  55                                                                             \
  56     /*                                                                      \
  57        because of the remark above, release() is declared const even if it  \
  58        isn't really const                                                   \
  59      */                                                                     \
  60     chartype *release() const                                               \
  61     {                                                                       \
  62         chartype *p = m_str;                                                \
  63         ((classname *)this)->m_str = NULL;                                  \
  64         return p;                                                           \
  65     }                                                                       \
  66                                                                             \
  67     classname(const classname& src)                                         \
  68         : m_str(src.release())                                              \
  69     {                                                                       \
  70     }                                                                       \
  71                                                                             \
  72     classname& operator=(const chartype *str)                               \
  73     {                                                                       \
  74         free(m_str);                                                        \
  75         m_str = str ? strdupfunc(str) : NULL;                               \
  76         return *this;                                                       \
  77     }                                                                       \
  78                                                                             \
  79     classname& operator=(const classname& src)                              \
  80     {                                                                       \
  81         free(m_str);                                                        \
  82         m_str = src.release();                                              \
  83                                                                             \
  84         return *this;                                                       \
  85     }                                                                       \
  86                                                                             \
  87     chartype *data() { return m_str; }                                      \
  88     const chartype *data() const { return m_str; }                          \
  89     operator const chartype *() const { return m_str; }                     \
  90     chartype operator[](size_t n) const { return m_str[n]; }                \
  91                                                                             \
  92 private:                                                                    \
  93     chartype *m_str;                                                        \
  94 }
  95
  96 DEFINE_BUFFER(wxCharBuffer, char, wxStrdupA);
  97
  98 #if wxUSE_WCHAR_T
  99
 100 DEFINE_BUFFER(wxWCharBuffer, wchar_t, wxStrdupW);
 101
 102 #endif // wxUSE_WCHAR_T
 103
 104 #undef DEFINE_BUFFER
 105
 106 #if wxUSE_UNICODE
 107     #define wxMB2WXbuf wxWCharBuffer
 108     #define wxWX2MBbuf wxCharBuffer
 109     #define wxWC2WXbuf wxChar*
 110     #define wxWX2WCbuf wxChar*
 111 #else // ANSI
 112     #define wxMB2WXbuf wxChar*
 113     #define wxWX2MBbuf wxChar*
 114     #define wxWC2WXbuf wxCharBuffer
 115     #define wxWX2WCbuf wxWCharBuffer
 116 #endif // Unicode/ANSI
 117
 118 // ----------------------------------------------------------------------------
 119 // A class for holding growable data buffers (not necessarily strings)
 120 // ----------------------------------------------------------------------------
 121
 122 // This class manages the actual data buffer pointer and is ref-counted.
 123 class wxMemoryBufferData
 124 {
 125 public:
 126     // the initial size and also the size added by ResizeIfNeeded()
 127     enum { BLOCK_SIZE = 1024 };
 128
 129     friend class wxMemoryBuffer;
 130
 131     // everyting is private as it can only be used by wxMemoryBuffer
 132 private:
 133     wxMemoryBufferData(size_t size = wxMemoryBufferData::BLOCK_SIZE)
 134         : m_data(size ? malloc(size) : NULL), m_size(size), m_len(0), m_ref(0)
 135     {
 136     }
 137     ~wxMemoryBufferData() { free(m_data); }
 138
 139
 140     void ResizeIfNeeded(size_t newSize)
 141     {
 142         if (newSize > m_size)
 143         {
 144             void *dataOld = m_data;
 145             m_data = realloc(m_data, newSize + wxMemoryBufferData::BLOCK_SIZE);
 146             if ( !m_data )
 147             {
 148                 free(dataOld);
 149             }
 150
 151             m_size = newSize + wxMemoryBufferData::BLOCK_SIZE;
 152         }
 153     }
 154
 155     void IncRef() { m_ref += 1; }
 156     void DecRef()
 157     {
 158         m_ref -= 1;
 159         if (m_ref == 0)  // are there no more references?
 160             delete this;
 161     }
 162
 163
 164     // the buffer containing the data
 165     void  *m_data;
 166
 167     // the size of the buffer
 168     size_t m_size;
 169
 170     // the amount of data currently in the buffer
 171     size_t m_len;
 172
 173     // the reference count
 174     size_t m_ref;
 175
 176     DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
 177 };
 178
 179
 180 class wxMemoryBuffer
 181 {
 182 public:
 183     // ctor and dtor
 184     wxMemoryBuffer(size_t size = wxMemoryBufferData::BLOCK_SIZE)
 185     {
 186         m_bufdata = new wxMemoryBufferData(size);
 187         m_bufdata->IncRef();
 188     }
 189
 190     ~wxMemoryBuffer() { m_bufdata->DecRef(); }
 191
 192
 193     // copy and assignment
 194     wxMemoryBuffer(const wxMemoryBuffer& src)
 195         : m_bufdata(src.m_bufdata)
 196     {
 197         m_bufdata->IncRef();
 198     }
 199
 200     wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
 201     {
 202         m_bufdata->DecRef();
 203         m_bufdata = src.m_bufdata;
 204         m_bufdata->IncRef();
 205         return *this;
 206     }
 207
 208
 209     // Accessors
 210     void  *GetData() const    { return m_bufdata->m_data; }
 211     size_t GetBufSize() const { return m_bufdata->m_size; }
 212     size_t GetDataLen() const { return m_bufdata->m_len; }
 213
 214     void   SetBufSize(size_t size) { m_bufdata->ResizeIfNeeded(size); }
 215     void   SetDataLen(size_t len)
 216     {
 217         wxASSERT(len <= m_bufdata->m_size);
 218         m_bufdata->m_len = len;
 219     }
 220
 221     // Ensure the buffer is big enough and return a pointer to it
 222     void *GetWriteBuf(size_t sizeNeeded)
 223     {
 224         m_bufdata->ResizeIfNeeded(sizeNeeded);
 225         return m_bufdata->m_data;
 226     }
 227
 228     // Update the length after the write
 229     void  UngetWriteBuf(size_t sizeUsed) { SetDataLen(sizeUsed); }
 230
 231     // Like the above, but appends to the buffer
 232     void *GetAppendBuf(size_t sizeNeeded)
 233     {
 234         m_bufdata->ResizeIfNeeded(m_bufdata->m_len + sizeNeeded);
 235         return (char*)m_bufdata->m_data + m_bufdata->m_len;
 236     }
 237
 238     // Update the length after the append
 239     void  UngetAppendBuf(size_t sizeUsed)
 240     {
 241         SetDataLen(m_bufdata->m_len + sizeUsed);
 242     }
 243
 244     // Other ways to append to the buffer
 245     void  AppendByte(char data)
 246     {
 247         wxCHECK_RET( m_bufdata->m_data, _T("invalid wxMemoryBuffer") );
 248
 249         m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
 250         *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;
 251         m_bufdata->m_len += 1;
 252     }
 253
 254     void  AppendData(void* data, size_t len)
 255     {
 256         memcpy(GetAppendBuf(len), data, len);
 257         UngetAppendBuf(len);
 258     }
 259
 260     operator const char *() const { return (const char*)GetData(); }
 261
 262 private:
 263     wxMemoryBufferData*  m_bufdata;
 264 };
 265
 266 // ----------------------------------------------------------------------------
 267 // template class for any kind of data
 268 // ----------------------------------------------------------------------------
 269
 270 // TODO
 271
 272 #endif // _WX_BUFFER_H