include/wx/buffer.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 license
  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 #include <string.h> // strdup
  19
  20 // ----------------------------------------------------------------------------
  21 // Special classes for (wide) character strings: they use malloc/free instead
  22 // of new/delete
  23 // ----------------------------------------------------------------------------
  24
  25 class wxCharBuffer
  26 {
  27 public:
  28     wxCharBuffer(const char *str)
  29     {
  30         wxASSERT_MSG( str, _T("NULL string in wxCharBuffer") );
  31
  32         m_str = str ? strdup(str) : (char *)NULL;
  33     }
  34     wxCharBuffer(size_t len)
  35     {
  36         m_str = (char *)malloc(len+1);
  37         m_str[len] = '\0';
  38     }
  39     // no need to check for NULL, free() does it
  40    ~wxCharBuffer() { free(m_str); }
  41
  42    wxCharBuffer(const wxCharBuffer& src)
  43    {
  44      m_str = src.m_str;
  45      // no reference count yet...
  46      ((wxCharBuffer*)&src)->m_str = (char *)NULL;
  47    }
  48    wxCharBuffer& operator=(const wxCharBuffer& src)
  49    {
  50      m_str = src.m_str;
  51      // no reference count yet...
  52      ((wxCharBuffer*)&src)->m_str = (char *)NULL;
  53      return *this;
  54    }
  55
  56    operator const char *() const { return m_str; }
  57    char operator[](size_t n) const { return m_str[n]; }
  58
  59 private:
  60    char *m_str;
  61 };
  62
  63 #if wxUSE_WCHAR_T
  64 class wxWCharBuffer
  65 {
  66 public:
  67     wxWCharBuffer(const wchar_t *wcs)
  68     {
  69         wxASSERT_MSG( wcs, _T("NULL string in wxWCharBuffer") );
  70
  71         if (wcs) {
  72           size_t siz = (wcslen(wcs)+1)*sizeof(wchar_t);
  73           m_wcs = (wchar_t *)malloc(siz);
  74           memcpy(m_wcs, wcs, siz);
  75         }
  76         else m_wcs = (wchar_t *)NULL;
  77     }
  78     wxWCharBuffer(size_t len)
  79     {
  80         m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t));
  81         m_wcs[len] = L'\0';
  82     }
  83
  84     // no need to check for NULL, free() does it
  85    ~wxWCharBuffer() { free(m_wcs); }
  86
  87    wxWCharBuffer(const wxWCharBuffer& src)
  88    {
  89      m_wcs = src.m_wcs;
  90      // no reference count yet...
  91      ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
  92    }
  93    wxWCharBuffer& operator=(const wxWCharBuffer& src)
  94    {
  95      m_wcs = src.m_wcs;
  96      // no reference count yet...
  97      ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
  98      return *this;
  99    }
 100
 101    operator const wchar_t *() const { return m_wcs; }
 102    wchar_t operator[](size_t n) const { return m_wcs[n]; }
 103
 104 private:
 105    wchar_t *m_wcs;
 106 };
 107 #endif
 108
 109 #if wxUSE_UNICODE
 110 #define wxMB2WXbuf wxWCharBuffer
 111 #define wxWX2MBbuf wxCharBuffer
 112 #define wxWC2WXbuf wxChar*
 113 #define wxWX2WCbuf wxChar*
 114 #else
 115 #define wxMB2WXbuf wxChar*
 116 #define wxWX2MBbuf wxChar*
 117 #define wxWC2WXbuf wxCharBuffer
 118 #define wxWX2WCbuf wxWCharBuffer
 119 #endif
 120
 121 // ----------------------------------------------------------------------------
 122 // template class for any kind of data
 123 // ----------------------------------------------------------------------------
 124
 125 // TODO
 126
 127 #endif // _WX_BUFFER_H