Better support for unspecified property value in wxDateProperty and DatePickerCtrl...

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

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index c9232820fec15c0d34d3554088350b2e51e2a7c2..4cc340aa518fa7248e26b58781b93958a3596c5a 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -12,20 +12,58 @@
 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 
 #ifndef _WX_BUFFER_H
 #define _WX_BUFFER_H
 

-#include "wx/wxchar.h"
+#include "wx/chartype.h"
+#include "wx/wxcrtbase.h"

 
 

+#ifndef __WXPALMOS5__

 #include <stdlib.h>             // malloc() and free()
 #include <stdlib.h>             // malloc() and free()

+#endif // ! __WXPALMOS5__

 
 

-inline char *wxStrDup(const char *s) { return wxStrdupA(s); }
-#if wxUSE_WCHAR_T
-    inline wchar_t *wxStrDup(const wchar_t *ws) { return wxStrdupW(ws); }
-#endif
+class WXDLLIMPEXP_FWD_BASE wxCStrData;

 
 // ----------------------------------------------------------------------------
 // Special classes for (wide) character strings: they use malloc/free instead
 // of new/delete
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // Special classes for (wide) character strings: they use malloc/free instead
 // of new/delete
 // ----------------------------------------------------------------------------
 

+// helpers used by wxCharTypeBuffer
+namespace wxPrivate
+{
+
+struct UntypedBufferData
+{
+    enum Kind
+    {
+        Owned,
+        NonOwned
+    };
+
+    UntypedBufferData(void *str, Kind kind = Owned)
+        : m_str(str), m_ref(1), m_owned(kind == Owned) {}
+
+    ~UntypedBufferData()
+    {
+        if ( m_owned )
+            free(m_str);
+    }
+
+    void *m_str;
+
+    // "short" to have sizeof(Data)=8 on 32bit archs
+    unsigned short m_ref;
+
+    bool m_owned;
+};
+
+// this has to be defined inside the DLL (and not e.g. as a static variable
+// inside an inline function) as otherwise MSVC gives link errors when the
+// functions are effectively inlined (i.e. in non-debug build)
+//
+// NB: this is defined in string.cpp and not the (non-existent) buffer.cpp
+extern WXDLLIMPEXP_DATA_BASE(UntypedBufferData * const) untypedNullDataPtr;
+
+} // namespace wxPrivate
+

 template <typename T>
 class wxCharTypeBuffer
 {
 template <typename T>
 class wxCharTypeBuffer
 {


@@ -33,126 +71,218 @@ public:
     typedef T CharType;
 
     wxCharTypeBuffer(const CharType *str = NULL)
     typedef T CharType;
 
     wxCharTypeBuffer(const CharType *str = NULL)

-        : m_str(str ? wxStrDup(str) : NULL)

     {
     {

+        if ( str )
+            m_data = new Data(wxStrdup(str));
+        else
+            m_data = GetNullData();

     }
 
     wxCharTypeBuffer(size_t len)
     }
 
     wxCharTypeBuffer(size_t len)

-        : m_str((CharType *)malloc((len + 1)*sizeof(CharType)))

     {
     {

-        m_str[len] = (CharType)0;
+        m_data = new Data((CharType *)malloc((len + 1)*sizeof(CharType)));
+        m_data->Get()[len] = (CharType)0;

     }
 
     }
 

-    /* no need to check for NULL, free() does it */
-    ~wxCharTypeBuffer() { free(m_str); }
+    static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
+    {
+        wxCharTypeBuffer buf;
+        if ( str )
+            buf.m_data = new Data(const_cast<CharType*>(str), Data::NonOwned);
+        return buf;
+    }

 
 

-    /*
-        WARNING:
+    ~wxCharTypeBuffer()
+    {
+        DecRef();
+    }

 
 

-        the copy ctor and assignment operators change the passed in object
-        even although it is declared as "const", so:
+    // NB: this method is only const for backward compatibility. It used to
+    //     be needed for auto_ptr-like semantics of the copy ctor, but now
+    //     that ref-counting is used, it's not really needed.
+    CharType *release() const
+    {
+        if ( m_data == GetNullData() )
+            return NULL;

 
 

-        a) it shouldn't be really const
-        b) you shouldn't use it afterwards (or know that it was reset)
+        wxASSERT_MSG( m_data->m_owned, _T("can't release non-owned buffer") );
+        wxASSERT_MSG( m_data->m_ref == 1, _T("can't release shared buffer") );

 
 

-        This is very ugly but is unfortunately needed to make the normal use\
-        of wxCharTypeBuffer buffer objects possible and is very similar to what
-        std::auto_ptr<> does (as if it were an excuse...)
-    */
+        CharType * const p = m_data->Get();
+
+        wxCharTypeBuffer *self = const_cast<wxCharTypeBuffer*>(this);
+        self->m_data->Set(NULL);
+        self->DecRef();

 
 

-    /*
-       because of the remark above, release() is declared const even if it
-       isn't really const
-     */
-    CharType *release() const
-    {
-        CharType *p = m_str;
-        ((wxCharTypeBuffer *)this)->m_str = NULL;

         return p;
     }
 
     void reset()
     {
         return p;
     }
 
     void reset()
     {

-        free(m_str);
-        m_str = NULL;
+        DecRef();

     }
 
     wxCharTypeBuffer(const wxCharTypeBuffer& src)
     }
 
     wxCharTypeBuffer(const wxCharTypeBuffer& src)

-        : m_str(src.release())

     {
     {

+        m_data = src.m_data;
+        IncRef();

     }
 
     wxCharTypeBuffer& operator=(const CharType *str)
     {
     }
 
     wxCharTypeBuffer& operator=(const CharType *str)
     {

-        free(m_str);
-        m_str = str ? wxStrDup(str) : NULL;
+        DecRef();
+
+        if ( str )
+            m_data = new Data(wxStrdup(str));

         return *this;
     }
 
     wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
     {
         return *this;
     }
 
     wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
     {

-        free(m_str);
-        m_str = src.release();
+        if ( &src == this )
+            return *this;
+
+        DecRef();
+        m_data = src.m_data;
+        IncRef();

 
         return *this;
     }
 
     bool extend(size_t len)
     {
 
         return *this;
     }
 
     bool extend(size_t len)
     {

-        CharType *
-            str = (CharType *)realloc(m_str, (len + 1)*sizeof(CharType));
+        wxASSERT_MSG( m_data->m_owned, _T("cannot extend non-owned buffer") );
+        wxASSERT_MSG( m_data->m_ref == 1, _T("can't extend shared buffer") );
+
+        CharType *str =
+            (CharType *)realloc(data(), (len + 1) * sizeof(CharType));

         if ( !str )
             return false;
 
         if ( !str )
             return false;
 

-        m_str = str;
+        if ( m_data == GetNullData() )
+        {
+            m_data = new Data(str);
+        }
+        else
+        {
+            m_data->Set(str);
+            m_data->m_owned = true;
+        }

 
         return true;
     }
 
 
         return true;
     }
 

-    CharType *data() { return m_str; }
-    const CharType *data() const { return m_str; }
-    operator const CharType *() const { return m_str; }
-    CharType operator[](size_t n) const { return m_str[n]; }
+    CharType *data() { return m_data->Get(); }
+    const CharType *data() const { return  m_data->Get(); }
+    operator const CharType *() const { return data(); }
+    CharType operator[](size_t n) const { return data()[n]; }
+
+private:
+    // reference-counted data
+    struct Data : public wxPrivate::UntypedBufferData
+    {
+        Data(CharType *str, Kind kind = Owned)
+            : wxPrivate::UntypedBufferData(str, kind)
+        {
+        }
+
+        CharType *Get() const { return static_cast<CharType *>(m_str); }
+        void Set(CharType *str) { m_str = str; }
+    };
+
+    // placeholder for NULL string, to simplify this code
+    static Data *GetNullData()
+    {
+        return static_cast<Data *>(wxPrivate::untypedNullDataPtr);
+    }
+
+    void IncRef()
+    {
+        if ( m_data == GetNullData() ) // exception, not ref-counted
+            return;
+        m_data->m_ref++;
+    }
+
+    void DecRef()
+    {
+        if ( m_data == GetNullData() ) // exception, not ref-counted
+            return;
+        if ( --m_data->m_ref == 0 )
+            delete m_data;
+        m_data = GetNullData();
+    }

 
 private:
 
 private:

-    CharType *m_str;
+    Data *m_data;

 };
 
 };
 

-class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
+
+class wxCharBuffer : public wxCharTypeBuffer<char>

 {
 public:
     typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
 
 {
 public:
     typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
 

+    wxCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+

     wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
     wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 

-#if !wxUSE_UNICODE

     wxCharBuffer(const wxCStrData& cstr);
     wxCharBuffer(const wxCStrData& cstr);

-#endif

 };
 
 #if wxUSE_WCHAR_T
 };
 
 #if wxUSE_WCHAR_T

-class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
+
+class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>

 {
 public:
     typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
 
 {
 public:
     typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
 

+    wxWCharBuffer(const wxCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}
+

     wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
     wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 

-#if wxUSE_UNICODE

     wxWCharBuffer(const wxCStrData& cstr);
     wxWCharBuffer(const wxCStrData& cstr);

-#endif

 };
 #endif // wxUSE_WCHAR_T
 
 };
 #endif // wxUSE_WCHAR_T
 

+// wxCharTypeBuffer<T> implicitly convertible to T*
+template <typename T>
+class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
+{
+public:
+    typedef typename wxCharTypeBuffer<T>::CharType CharType;
+
+    wxWritableCharTypeBuffer(const wxCharTypeBuffer<T>& src)
+        : wxCharTypeBuffer<T>(src) {}
+    // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
+    //             always return a buffer
+    wxWritableCharTypeBuffer(const CharType *str = NULL)
+        : wxCharTypeBuffer<T>(str) {}
+
+    operator CharType*() { return this->data(); }
+};
+
+typedef wxWritableCharTypeBuffer<char> wxWritableCharBuffer;
+typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
+
+

 #if wxUSE_UNICODE
     #define wxWxCharBuffer wxWCharBuffer
 
     #define wxMB2WXbuf wxWCharBuffer
     #define wxWX2MBbuf wxCharBuffer
 #if wxUSE_UNICODE
     #define wxWxCharBuffer wxWCharBuffer
 
     #define wxMB2WXbuf wxWCharBuffer
     #define wxWX2MBbuf wxCharBuffer

-    #define wxWC2WXbuf wxChar*
-    #define wxWX2WCbuf wxChar*
+    #if wxUSE_UNICODE_WCHAR
+        #define wxWC2WXbuf wxChar*
+        #define wxWX2WCbuf wxChar*
+    #elif wxUSE_UNICODE_UTF8
+        #define wxWC2WXbuf wxWCharBuffer
+        #define wxWX2WCbuf wxWCharBuffer
+    #endif

 #else // ANSI
     #define wxWxCharBuffer wxCharBuffer
 
 #else // ANSI
     #define wxWxCharBuffer wxCharBuffer
 


@@ -162,6 +292,13 @@ public:
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 

+// type of the value returned by wxString::utf8_str()
+#if wxUSE_UNICODE_UTF8
+    #define wxUTF8Buf char *
+#else
+    #define wxUTF8Buf wxCharBuffer
+#endif
+

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


@@ -246,9 +383,12 @@ public:
 
     wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
     {
 
     wxMemoryBuffer& operator=(const wxMemoryBuffer& src)
     {

-        m_bufdata->DecRef();
-        m_bufdata = src.m_bufdata;
-        m_bufdata->IncRef();
+        if (&src != this)
+        {
+            m_bufdata->DecRef();
+            m_bufdata = src.m_bufdata;
+            m_bufdata->IncRef();
+        }

         return *this;
     }
 
         return *this;
     }