declare wxEntry() as taking char **Argv, not char *argv[]

[wxWidgets.git] / include / wx / buffer.h

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index 7a550a9310fb995fbbf0eca30a4029eba5628fec..3b770e32af24d8e9f5e8d109c74146b8c74f999d 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        buffer.h
+// Name:        wx/buffer.h

 // Purpose:     auto buffer classes: buffers which automatically free memory
 // Author:      Vadim Zeitlin
 // Modified by:
 // Purpose:     auto buffer classes: buffers which automatically free memory
 // Author:      Vadim Zeitlin
 // Modified by:


@@ -27,92 +27,87 @@ class wxCharBuffer
 {
 public:
     wxCharBuffer(const char *str)
 {
 public:
     wxCharBuffer(const char *str)

+        : m_str(str ? strdup(str) : NULL)

     {
     {

-        wxASSERT_MSG( str, wxT("NULL string in wxCharBuffer") );
-
-        m_str = str ? strdup(str) : (char *)NULL;

     }
     }

+

     wxCharBuffer(size_t len)
     wxCharBuffer(size_t len)

+        : m_str((char *)malloc((len + 1)*sizeof(char)))

     {
     {

-        m_str = (char *)malloc(len+1);

         m_str[len] = '\0';
     }
         m_str[len] = '\0';
     }

+

     // no need to check for NULL, free() does it
     // no need to check for NULL, free() does it

-   ~wxCharBuffer() { free(m_str); }
+    ~wxCharBuffer() { free(m_str); }

 
 

-   wxCharBuffer(const wxCharBuffer& src)
-   {
-     m_str = src.m_str;
-     // no reference count yet...
-     ((wxCharBuffer*)&src)->m_str = (char *)NULL;
-   }
-   wxCharBuffer& operator=(const wxCharBuffer& src)
-   {
-     m_str = src.m_str;
-     // no reference count yet...
-     ((wxCharBuffer*)&src)->m_str = (char *)NULL;
-     return *this;
-   }
+    wxCharBuffer(const wxCharBuffer& src)
+        : m_str(src.m_str)
+    {
+        // no reference count yet...
+        ((wxCharBuffer*)&src)->m_str = (char *)NULL;
+    }
+    wxCharBuffer& operator=(const wxCharBuffer& src)
+    {
+        m_str = src.m_str;
+        // no reference count yet...
+        ((wxCharBuffer*)&src)->m_str = (char *)NULL;
+        return *this;
+    }

 
 

-   const char *data() const { return m_str; }
-   operator const char *() const { return m_str; }
-   char operator[](size_t n) const { return m_str[n]; }
+    const char *data() const { return m_str; }
+    operator const char *() const { return m_str; }
+    char operator[](size_t n) const { return m_str[n]; }

 
 private:
 
 private:

-   char *m_str;
+    char *m_str;

 };
 
 #if wxUSE_WCHAR_T
 };
 
 #if wxUSE_WCHAR_T

+

 class wxWCharBuffer
 {
 public:
     wxWCharBuffer(const wchar_t *wcs)
 class wxWCharBuffer
 {
 public:
     wxWCharBuffer(const wchar_t *wcs)

+        : m_wcs((wchar_t *)NULL)

     {
     {

-        wxASSERT_MSG( wcs, wxT("NULL string in wxWCharBuffer") );
-

         if (wcs) {
         if (wcs) {

-#if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
-    || ( defined(__MWERKS__) && defined(__WXMSW__) )
-          size_t siz = (std::wcslen(wcs)+1)*sizeof(wchar_t);
-#else
-          size_t siz = (::wcslen(wcs)+1)*sizeof(wchar_t);
-#endif
+          size_t siz = (wxWcslen(wcs) + 1)*sizeof(wchar_t);

           m_wcs = (wchar_t *)malloc(siz);
           memcpy(m_wcs, wcs, siz);
         }
           m_wcs = (wchar_t *)malloc(siz);
           memcpy(m_wcs, wcs, siz);
         }

-        else m_wcs = (wchar_t *)NULL;

     }
     wxWCharBuffer(size_t len)
     }
     wxWCharBuffer(size_t len)

+        : m_wcs((wchar_t *)malloc((len + 1)*sizeof(wchar_t)))

     {
     {

-        m_wcs = (wchar_t *)malloc((len+1)*sizeof(wchar_t));

         m_wcs[len] = L'\0';
     }
 
     // no need to check for NULL, free() does it
         m_wcs[len] = L'\0';
     }
 
     // no need to check for NULL, free() does it

-   ~wxWCharBuffer() { free(m_wcs); }
+    ~wxWCharBuffer() { free(m_wcs); }

 
 

-   wxWCharBuffer(const wxWCharBuffer& src)
-   {
-     m_wcs = src.m_wcs;
-     // no reference count yet...
-     ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
-   }
-   wxWCharBuffer& operator=(const wxWCharBuffer& src)
-   {
-     m_wcs = src.m_wcs;
-     // no reference count yet...
-     ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
-     return *this;
-   }
+    wxWCharBuffer(const wxWCharBuffer& src)
+        : m_wcs(src.m_wcs)
+    {
+       // no reference count yet...
+       ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
+    }
+    wxWCharBuffer& operator=(const wxWCharBuffer& src)
+    {
+        m_wcs = src.m_wcs;
+        // no reference count yet...
+        ((wxWCharBuffer*)&src)->m_wcs = (wchar_t *)NULL;
+        return *this;
+    }

 
 

-   const wchar_t *data() const { return m_wcs; }
-   operator const wchar_t *() const { return m_wcs; }
-   wchar_t operator[](size_t n) const { return m_wcs[n]; }
+    const wchar_t *data() const { return m_wcs; }
+    operator const wchar_t *() const { return m_wcs; }
+    wchar_t operator[](size_t n) const { return m_wcs[n]; }

 
 private:
 
 private:

-   wchar_t *m_wcs;
+    wchar_t *m_wcs;

 };
 };

-#endif
+
+#endif // wxUSE_WCHAR_T

 
 #if wxUSE_UNICODE
     #define wxMB2WXbuf wxWCharBuffer
 
 #if wxUSE_UNICODE
     #define wxMB2WXbuf wxWCharBuffer


@@ -126,8 +121,6 @@ private:
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 

-
-

 // ----------------------------------------------------------------------------
 // A class for holding growable data buffers (not necessarily strings)
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // A class for holding growable data buffers (not necessarily strings)
 // ----------------------------------------------------------------------------


@@ -136,21 +129,17 @@ class wxMemoryBuffer
 {
 public:
     enum { BLOCK_SIZE = 1024 };
 {
 public:
     enum { BLOCK_SIZE = 1024 };

-    wxMemoryBuffer(size_t size=wxMemoryBuffer::BLOCK_SIZE)
+    wxMemoryBuffer(size_t size = wxMemoryBuffer::BLOCK_SIZE)
+        : m_data(malloc(size)), m_size(size), m_len(0)

     {
     {

-        wxASSERT(size > 0);
-        m_data = malloc(size);
-        wxASSERT(m_data != NULL);
-        m_size = size;
-        m_len  = 0;

     }
 
     ~wxMemoryBuffer() { free(m_data); }
 
     // Accessors
     }
 
     ~wxMemoryBuffer() { free(m_data); }
 
     // Accessors

-    void*  GetData()    { return m_data; }
-    size_t GetBufSize() { return m_size; }
-    size_t GetDataLen() { return m_len; }
+    void*  GetData() const    { return m_data; }
+    size_t GetBufSize() const { return m_size; }
+    size_t GetDataLen() const { return m_len; }

 
     void   SetBufSize(size_t size) { ResizeIfNeeded(size); }
     void   SetDataLen(size_t len)
 
     void   SetBufSize(size_t size) { ResizeIfNeeded(size); }
     void   SetDataLen(size_t len)


@@ -179,7 +168,7 @@ public:
     // Other ways to append to the buffer
     void  AppendByte(char data) {
         ResizeIfNeeded(m_len + 1);
     // Other ways to append to the buffer
     void  AppendByte(char data) {
         ResizeIfNeeded(m_len + 1);

-        *((char*)m_data) = data;
+        *(((char*)m_data)+m_len) = data;

         m_len += 1;
     }
     void  AppendData(void* data, size_t len)
         m_len += 1;
     }
     void  AppendData(void* data, size_t len)


@@ -190,8 +179,33 @@ public:
 
     operator const char *() const { return (const char*)m_data; }
 
 
     operator const char *() const { return (const char*)m_data; }
 

-protected:

 
 

+    // Copy and assignment
+    wxMemoryBuffer(const wxMemoryBuffer& src)
+        : m_data(src.m_data), m_size(src.m_size), m_len(src.m_len)
+    {
+        // no reference count yet...
+        ((wxMemoryBuffer*)&src)->m_data = NULL;
+        ((wxMemoryBuffer*)&src)->m_size = 0;
+        ((wxMemoryBuffer*)&src)->m_len  = 0;
+    }
+
+    wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
+    {
+        m_data = src.m_data;
+        m_size = src.m_size;
+        m_len  = src.m_len;
+
+        // no reference count yet...
+        ((wxMemoryBuffer*)&src)->m_data = NULL;
+        ((wxMemoryBuffer*)&src)->m_size = 0;
+        ((wxMemoryBuffer*)&src)->m_len  = 0;
+
+        return *this;
+   }
+
+
+protected:

     void ResizeIfNeeded(size_t newSize)
     {
         if (newSize > m_size)
     void ResizeIfNeeded(size_t newSize)
     {
         if (newSize > m_size)


@@ -202,16 +216,12 @@ protected:
         }
     }
 
         }
     }
 

-    DECLARE_NO_COPY_CLASS(wxMemoryBuffer)
-

 private:
     void*       m_data;
     size_t      m_size;
     size_t      m_len;
 };
 
 private:
     void*       m_data;
     size_t      m_size;
     size_t      m_len;
 };
 

-
-

 // ----------------------------------------------------------------------------
 // template class for any kind of data
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // template class for any kind of data
 // ----------------------------------------------------------------------------