Avoid warnings in the Objective-C uniquifying code when running in GC mode.

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

diff --git a/include/wx/ptr_scpd.h b/include/wx/ptr_scpd.h
index 9f7c88de4bb8002da80d20c354b92abe2177d79f..2ae40220c97f492b461c9e6ec8f7b0441c7708c7 100644 (file)
--- a/include/wx/ptr_scpd.h
+++ b/include/wx/ptr_scpd.h
@@ -30,6 +30,84 @@
 
 #include "wx/defs.h"
 
+// ----------------------------------------------------------------------------
+// wxScopedPtr: A scoped pointer 
+// ----------------------------------------------------------------------------
+
+template <class T> 
+class wxScopedPtr
+{                                   
+private:                            
+    T * m_ptr;                      
+                                    
+    wxScopedPtr(wxScopedPtr const &);             
+    wxScopedPtr & operator=(wxScopedPtr const &); 
+                                    
+public:                             
+    typedef T element_type;
+    
+    wxEXPLICIT wxScopedPtr(T * ptr = NULL) 
+    : m_ptr(ptr) { }                
+                                    
+    ~wxScopedPtr()
+    {
+       if (m_ptr)
+           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 (m_ptr != 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 & ot)            
+    {                               
+        T * tmp = ot.m_ptr;         
+        ot.m_ptr = m_ptr;           
+        m_ptr = tmp;                
+    }                               
+};
+
+// ----------------------------------------------------------------------------
+// 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
@@ -45,7 +123,7 @@
     #define wxPOST_NO_WARNING_SCOPE(name)
 #else
     #define wxPRE_NO_WARNING_SCOPE(name)  do
-    #define wxPOST_NO_WARNING_SCOPE(name) while ( 0 )
+    #define wxPOST_NO_WARNING_SCOPE(name) while ( wxFalse )
 #endif
 
 #define wxCHECKED_DELETE(ptr)                                                 \
@@ -62,16 +140,10 @@
         delete [] ptr;                                                        \
     } wxPOST_NO_WARNING_SCOPE(scope_var2)
 
-/* These scoped pointers are *not* assignable and cannot be used
-   within a container.  Look for wxDECLARE_SHARED_PTR for this
-   functionality.
-
-   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
-   being used.
-*/
-
+   being used. */
 
 #define wxDECLARE_SCOPED_PTR(T, name) \
 class name                          \
@@ -197,7 +269,7 @@ void name::reset(T * p){                \
 // ----------------------------------------------------------------------------
 
 #define wxDEFINE_TIED_SCOPED_PTR_TYPE(T)                                      \
-    wxDEFINE_SCOPED_PTR_TYPE(T);                                              \
+    wxDEFINE_SCOPED_PTR_TYPE(T)                                               \
     class T ## TiedPtr : public T ## Ptr                                      \
     {                                                                         \
     public:                                                                   \
@@ -216,7 +288,7 @@ void name::reset(T * p){                \
     private:                                                                  \
         T **m_pp;                                                             \
         T *m_pOld;                                                            \
-    }
+    };
 
 #endif // __WX_SCOPED_POINTER__