X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/d566b182a54ff3bba1bfc71e235bb1f46996766c..6f405b31b201c0a01f96da26eac76bc8f74c0b30:/include/wx/ptr_scpd.h diff --git a/include/wx/ptr_scpd.h b/include/wx/ptr_scpd.h index 785b03603e..2ae40220c9 100644 --- a/include/wx/ptr_scpd.h +++ b/include/wx/ptr_scpd.h @@ -10,8 +10,8 @@ ///////////////////////////////////////////////////////////////////////////// // This class closely follows the implementation of the boost -// library scoped_ptr and is an adaption for c++ macro's in -// the wxWindows project. The original authors of the boost +// 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. // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. @@ -30,6 +30,84 @@ #include "wx/defs.h" +// ---------------------------------------------------------------------------- +// wxScopedPtr: A scoped pointer +// ---------------------------------------------------------------------------- + +template +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::*unspecified_bool_type)() const; + operator unspecified_bool_type() const + { + return m_ptr ? &wxScopedPtr::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 @@ -39,30 +117,33 @@ 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) \ - do \ + wxPRE_NO_WARNING_SCOPE(scope_var1) \ { \ typedef char complete[sizeof(*ptr)]; \ delete ptr; \ - } while ( 0 ) + } wxPOST_NO_WARNING_SCOPE(scope_var1) #define wxCHECKED_DELETE_ARRAY(ptr) \ - do \ + wxPRE_NO_WARNING_SCOPE(scope_var2) \ { \ 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 - being used. -*/ - + being used. */ #define wxDECLARE_SCOPED_PTR(T, name) \ class name \ @@ -123,9 +204,17 @@ public: \ #define wxDEFINE_SCOPED_PTR(T, name)\ name::~name() \ { \ - wxCHECKED_DELETE(m_ptr) \ + wxCHECKED_DELETE(m_ptr); \ } +// 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) \ + wxDEFINE_SCOPED_PTR(T, T ## Ptr) + +// the same but for arrays instead of simple pointers #define wxDECLARE_SCOPED_ARRAY(T, name)\ class name \ { \ @@ -162,16 +251,44 @@ public: \ }; #define wxDEFINE_SCOPED_ARRAY(T, name) \ -name::~name() \ -{ \ - wxCHECKED_DELETE_ARRAY(m_ptr) \ -} \ -void name::reset(T * p){ \ - if (m_ptr != p) \ - { \ - wxCHECKED_DELETE_ARRAY(m_ptr); \ - m_ptr = p; \ - } \ +name::~name() \ +{ \ + wxCHECKED_DELETE_ARRAY(m_ptr); \ +} \ +void name::reset(T * p){ \ + if (m_ptr != p) \ + { \ + wxCHECKED_DELETE_ARRAY(m_ptr); \ + m_ptr = p; \ + } \ } -#endif +// ---------------------------------------------------------------------------- +// "Tied" scoped pointer: same as normal one but also sets the value of +// some other variable to the pointer value +// ---------------------------------------------------------------------------- + +#define wxDEFINE_TIED_SCOPED_PTR_TYPE(T) \ + wxDEFINE_SCOPED_PTR_TYPE(T) \ + class T ## TiedPtr : public T ## Ptr \ + { \ + public: \ + T ## TiedPtr(T **pp, T *p) \ + : T ## Ptr(p), m_pp(pp) \ + { \ + m_pOld = *pp; \ + *pp = p; \ + } \ + \ + ~ T ## TiedPtr() \ + { \ + *m_pp = m_pOld; \ + } \ + \ + private: \ + T **m_pp; \ + T *m_pOld; \ + }; + +#endif // __WX_SCOPED_POINTER__ +