another fix for wxUSE_DRAG_AND_DROP==0 build

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

diff --git a/include/wx/ptr_scpd.h b/include/wx/ptr_scpd.h
index 487765c82c528330b4a6fa972017925fef2d62d9..ffbb01105d01017df7bfc0dd0b712680d2381a43 100644 (file)
--- a/include/wx/ptr_scpd.h
+++ b/include/wx/ptr_scpd.h
@@ -2,15 +2,16 @@
 // Name:        wx/ptr_scpd.h
 // Purpose:     scoped smart pointer class
 // Author:      Jesse Lovelace <jllovela@eos.ncsu.edu>
 // Name:        wx/ptr_scpd.h
 // Purpose:     scoped smart pointer class
 // Author:      Jesse Lovelace <jllovela@eos.ncsu.edu>

-// Modified by:
+// Modified by: Vadim Zeitlin to add template wxScopedArray

 // Created:     06/01/02
 // RCS-ID:      $Id$
 // Copyright:   (c) Jesse Lovelace and original Boost authors (see below)
 // Created:     06/01/02
 // RCS-ID:      $Id$
 // Copyright:   (c) Jesse Lovelace and original Boost authors (see below)

+//              (c) 2009 Vadim Zeitlin

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 //  This class closely follows the implementation of the boost
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 //  This class closely follows the implementation of the boost

-//  library scoped_ptr and is an adaption for c++ macro's in 
+//  library scoped_ptr and is an adaption for c++ macro's in

 //  the wxWidgets project. The original authors of the boost
 //  scoped_ptr are given below with their respective copyrights.
 
 //  the wxWidgets project. The original authors of the boost
 //  scoped_ptr are given below with their respective copyrights.
 


@@ -30,6 +31,126 @@
 
 #include "wx/defs.h"
 
 
 #include "wx/defs.h"
 

+// ----------------------------------------------------------------------------
+// wxScopedPtr: A scoped pointer
+// ----------------------------------------------------------------------------
+
+template <class T>
+class wxScopedPtr
+{
+public:
+    typedef T element_type;
+
+    wxEXPLICIT wxScopedPtr(T * ptr = NULL) : m_ptr(ptr) { }
+
+    ~wxScopedPtr() { delete m_ptr; }
+
+    // test for pointer validity: defining conversion to unspecified_bool_type
+    // and not more obvious bool to avoid implicit conversions to integer types
+    typedef T *(wxScopedPtr<T>::*unspecified_bool_type)() const;
+    operator unspecified_bool_type() const
+    {
+        return m_ptr ? &wxScopedPtr<T>::get : NULL;
+    }
+
+    void reset(T * ptr = NULL)
+    {
+        if ( ptr != m_ptr )
+        {
+            delete m_ptr;
+            m_ptr = ptr;
+        }
+    }
+
+    T *release()
+    {
+        T *ptr = m_ptr;
+        m_ptr = NULL;
+        return ptr;
+    }
+
+    T & operator*() const
+    {
+        wxASSERT(m_ptr != NULL);
+        return *m_ptr;
+    }
+
+    T * operator->() const
+    {
+        wxASSERT(m_ptr != NULL);
+        return m_ptr;
+    }
+
+    T * get() const
+    {
+        return m_ptr;
+    }
+
+    void swap(wxScopedPtr& other)
+    {
+        T * const tmp = other.m_ptr;
+        other.m_ptr = m_ptr;
+        m_ptr = tmp;
+    }
+
+private:
+    T * m_ptr;
+
+    DECLARE_NO_COPY_TEMPLATE_CLASS(wxScopedPtr, T)
+};
+
+// ----------------------------------------------------------------------------
+// wxScopedArray: A scoped array
+// ----------------------------------------------------------------------------
+
+template <class T>
+class wxScopedArray
+{
+public:
+    typedef T element_type;
+
+    wxEXPLICIT wxScopedArray(T * array = NULL) : m_array(array) { }
+
+    ~wxScopedArray() { delete [] m_array; }
+
+    // test for pointer validity: defining conversion to unspecified_bool_type
+    // and not more obvious bool to avoid implicit conversions to integer types
+    typedef T *(wxScopedArray<T>::*unspecified_bool_type)() const;
+    operator unspecified_bool_type() const
+    {
+        return m_array ? &wxScopedArray<T>::get : NULL;
+    }
+
+    void reset(T *array = NULL)
+    {
+        if ( array != m_array )
+        {
+            delete m_array;
+            m_array = array;
+        }
+    }
+
+    T& operator[](size_t n) const { return m_array[n]; }
+
+    T *get() const { return m_array; }
+
+    void swap(wxScopedArray &other)
+    {
+        T * const tmp = other.m_array;
+        other.m_array = m_array;
+        m_array = tmp;
+    }
+
+private:
+    T *m_array;
+
+    DECLARE_NO_COPY_TEMPLATE_CLASS(wxScopedArray, T)
+};
+
+// ----------------------------------------------------------------------------
+// old macro based implementation
+// ----------------------------------------------------------------------------
+

 /*
    checked deleters are used to make sure that the type being deleted is really
    a complete type.: otherwise sizeof() would result in a compile-time error
 /*
    checked deleters are used to make sure that the type being deleted is really
    a complete type.: otherwise sizeof() would result in a compile-time error


@@ -39,30 +160,33 @@
    still force a semicolon after the macro
 */
 
    still force a semicolon after the macro
 */
 

+#ifdef __WATCOMC__
+    #define wxFOR_ONCE(name)              for(int name=0; name<1; name++)
+    #define wxPRE_NO_WARNING_SCOPE(name)  wxFOR_ONCE(wxMAKE_UNIQUE_NAME(name))
+    #define wxPOST_NO_WARNING_SCOPE(name)
+#else
+    #define wxPRE_NO_WARNING_SCOPE(name)  do
+    #define wxPOST_NO_WARNING_SCOPE(name) while ( wxFalse )
+#endif
+

 #define wxCHECKED_DELETE(ptr)                                                 \
 #define wxCHECKED_DELETE(ptr)                                                 \

-    do                                                                        \
+    wxPRE_NO_WARNING_SCOPE(scope_var1)                                        \

     {                                                                         \
         typedef char complete[sizeof(*ptr)];                                  \
         delete ptr;                                                           \
     {                                                                         \
         typedef char complete[sizeof(*ptr)];                                  \
         delete ptr;                                                           \

-    } while ( 0 )
+    } wxPOST_NO_WARNING_SCOPE(scope_var1)

 
 #define wxCHECKED_DELETE_ARRAY(ptr)                                           \
 
 #define wxCHECKED_DELETE_ARRAY(ptr)                                           \

-    do                                                                        \
+    wxPRE_NO_WARNING_SCOPE(scope_var2)                                        \

     {                                                                         \
         typedef char complete[sizeof(*ptr)];                                  \
         delete [] ptr;                                                        \
     {                                                                         \
         typedef char complete[sizeof(*ptr)];                                  \
         delete [] ptr;                                                        \

-    } while ( 0 )
-
-/* These scoped pointers are *not* assignable and cannot be used
-   within a container.  Look for wxDECLARE_SHARED_PTR for this
-   functionality.
+    } wxPOST_NO_WARNING_SCOPE(scope_var2)

 
 

-   In addition, the type being used *must* be complete at the time
+/* The type being used *must* be complete at the time

    that wxDEFINE_SCOPED_* is called or a compiler error will result.
    This is because the class checks for the completeness of the type
    that wxDEFINE_SCOPED_* is called or a compiler error will result.
    This is because the class checks for the completeness of the type

-   being used.
-*/
-
+   being used. */

 
 #define wxDECLARE_SCOPED_PTR(T, name) \
 class name                          \
 
 #define wxDECLARE_SCOPED_PTR(T, name) \
 class name                          \


@@ -129,8 +253,8 @@ name::~name()                       \
 // this macro can be used for the most common case when you want to declare and
 // define the scoped pointer at the same time and want to use the standard
 // naming convention: auto pointer to Foo is called FooPtr
 // this macro can be used for the most common case when you want to declare and
 // define the scoped pointer at the same time and want to use the standard
 // naming convention: auto pointer to Foo is called FooPtr

-#define wxDEFINE_SCOPED_PTR_TYPE(T)                                           \
-    wxDECLARE_SCOPED_PTR(T, T ## Ptr);                                        \
+#define wxDEFINE_SCOPED_PTR_TYPE(T)    \
+    wxDECLARE_SCOPED_PTR(T, T ## Ptr)  \

     wxDEFINE_SCOPED_PTR(T, T ## Ptr)
 
 // the same but for arrays instead of simple pointers
     wxDEFINE_SCOPED_PTR(T, T ## Ptr)
 
 // the same but for arrays instead of simple pointers


@@ -188,7 +312,7 @@ void name::reset(T * p){                \
 // ----------------------------------------------------------------------------
 
 #define wxDEFINE_TIED_SCOPED_PTR_TYPE(T)                                      \
 // ----------------------------------------------------------------------------
 
 #define wxDEFINE_TIED_SCOPED_PTR_TYPE(T)                                      \

-    wxDEFINE_SCOPED_PTR_TYPE(T);                                              \
+    wxDEFINE_SCOPED_PTR_TYPE(T)                                               \

     class T ## TiedPtr : public T ## Ptr                                      \
     {                                                                         \
     public:                                                                   \
     class T ## TiedPtr : public T ## Ptr                                      \
     {                                                                         \
     public:                                                                   \


@@ -207,7 +331,7 @@ void name::reset(T * p){                \
     private:                                                                  \
         T **m_pp;                                                             \
         T *m_pOld;                                                            \
     private:                                                                  \
         T **m_pp;                                                             \
         T *m_pOld;                                                            \

-    }
+    };

 
 #endif // __WX_SCOPED_POINTER__
 
 
 #endif // __WX_SCOPED_POINTER__