Add wxABI_VERSION > 20601 wrappers

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

diff --git a/include/wx/scopeguard.h b/include/wx/scopeguard.h
index 2b794dc43fb437cfe6e49d51ee15213392abd381..8d5795f13f06e1781b40226dc2345b4bfb5548bd 100644 (file)
--- a/include/wx/scopeguard.h
+++ b/include/wx/scopeguard.h
@@ -5,7 +5,7 @@
 // Modified by:
 // Created:     03.07.2003
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     03.07.2003
 // RCS-ID:      $Id$

-// Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
+// Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org>

 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 


@@ -20,6 +20,8 @@
 
 #include "wx/defs.h"
 
 
 #include "wx/defs.h"
 

+#include "wx/except.h"
+

 // ----------------------------------------------------------------------------
 // helpers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // helpers
 // ----------------------------------------------------------------------------


@@ -29,33 +31,27 @@ namespace wxPrivate
     // in the original implementation this was a member template function of
     // ScopeGuardImplBase but gcc 2.8 which is still used for OS/2 doesn't
     // support member templates and so we must make it global
     // in the original implementation this was a member template function of
     // ScopeGuardImplBase but gcc 2.8 which is still used for OS/2 doesn't
     // support member templates and so we must make it global

-    template <typename ScopeGuardImpl>
-    void OnScopeExit(ScopeGuardImpl& guard) 
+    template <class ScopeGuardImpl>
+    void OnScopeExit(ScopeGuardImpl& guard)

     {
         if ( !guard.WasDismissed() )
         {
             // we're called from ScopeGuardImpl dtor and so we must not throw
     {
         if ( !guard.WasDismissed() )
         {
             // we're called from ScopeGuardImpl dtor and so we must not throw

-#if wxUSE_EXCEPTIONS
-            try
-#endif // wxUSE_EXCEPTIONS
+            wxTRY

             {
                 guard.Execute();
             }
             {
                 guard.Execute();
             }

-#if wxUSE_EXCEPTIONS
-            catch ( ... )
-            {
-            }
-#endif // wxUSE_EXCEPTIONS
+            wxCATCH_ALL(;) // do nothing, just eat the exception

         }
     }
 
     // just to avoid the warning about unused variables
         }
     }
 
     // just to avoid the warning about unused variables

-    template <typename T>
+    template <class T>

     void Use(const T& WXUNUSED(t))
     {
     }
 } // namespace wxPrivate
     void Use(const T& WXUNUSED(t))
     {
     }
 } // namespace wxPrivate

-    
+

 // ============================================================================
 // wxScopeGuard for functions and functors
 // ============================================================================
 // ============================================================================
 // wxScopeGuard for functions and functors
 // ============================================================================


@@ -71,13 +67,13 @@ public:
 
     void Dismiss() const { m_wasDismissed = true; }
 
 
     void Dismiss() const { m_wasDismissed = true; }
 

-    // for OnScopeExit() only we can't make it friend, unfortunately)!
+    // for OnScopeExit() only (we can't make it friend, unfortunately)!

     bool WasDismissed() const { return m_wasDismissed; }
 
 protected:
     ~wxScopeGuardImplBase() { }
 
     bool WasDismissed() const { return m_wasDismissed; }
 
 protected:
     ~wxScopeGuardImplBase() { }
 

-    wxScopeGuardImplBase(const wxScopeGuardImplBase& other) 
+    wxScopeGuardImplBase(const wxScopeGuardImplBase& other)

         : m_wasDismissed(other.m_wasDismissed)
     {
         other.Dismiss();
         : m_wasDismissed(other.m_wasDismissed)
     {
         other.Dismiss();


@@ -94,7 +90,7 @@ private:
 // wxScopeGuardImpl0: scope guard for actions without parameters
 // ----------------------------------------------------------------------------
 
 // wxScopeGuardImpl0: scope guard for actions without parameters
 // ----------------------------------------------------------------------------
 

-template <typename F>
+template <class F>

 class wxScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:
 class wxScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:


@@ -115,7 +111,7 @@ protected:
     wxScopeGuardImpl0& operator=(const wxScopeGuardImpl0&);
 };
 
     wxScopeGuardImpl0& operator=(const wxScopeGuardImpl0&);
 };
 

-template <typename F> 
+template <class F>

 inline wxScopeGuardImpl0<F> wxMakeGuard(F fun)
 {
     return wxScopeGuardImpl0<F>::MakeGuard(fun);
 inline wxScopeGuardImpl0<F> wxMakeGuard(F fun)
 {
     return wxScopeGuardImpl0<F>::MakeGuard(fun);


@@ -125,7 +121,7 @@ inline wxScopeGuardImpl0<F> wxMakeGuard(F fun)
 // wxScopeGuardImpl1: scope guard for actions with 1 parameter
 // ----------------------------------------------------------------------------
 
 // wxScopeGuardImpl1: scope guard for actions with 1 parameter
 // ----------------------------------------------------------------------------
 

-template <typename F, typename P1>
+template <class F, class P1>

 class wxScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:
 class wxScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:


@@ -147,7 +143,7 @@ protected:
     wxScopeGuardImpl1& operator=(const wxScopeGuardImpl1&);
 };
 
     wxScopeGuardImpl1& operator=(const wxScopeGuardImpl1&);
 };
 

-template <typename F, typename P1> 
+template <class F, class P1>

 inline wxScopeGuardImpl1<F, P1> wxMakeGuard(F fun, P1 p1)
 {
     return wxScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
 inline wxScopeGuardImpl1<F, P1> wxMakeGuard(F fun, P1 p1)
 {
     return wxScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);


@@ -157,7 +153,7 @@ inline wxScopeGuardImpl1<F, P1> wxMakeGuard(F fun, P1 p1)
 // wxScopeGuardImpl2: scope guard for actions with 2 parameters
 // ----------------------------------------------------------------------------
 
 // wxScopeGuardImpl2: scope guard for actions with 2 parameters
 // ----------------------------------------------------------------------------
 

-template <typename F, typename P1, typename P2>
+template <class F, class P1, class P2>

 class wxScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:
 class wxScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:


@@ -180,7 +176,7 @@ protected:
     wxScopeGuardImpl2& operator=(const wxScopeGuardImpl2&);
 };
 
     wxScopeGuardImpl2& operator=(const wxScopeGuardImpl2&);
 };
 

-template <typename F, typename P1, typename P2>
+template <class F, class P1, class P2>

 inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
 {
     return wxScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
 inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
 {
     return wxScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);


@@ -194,7 +190,7 @@ inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
 // wxObjScopeGuardImpl0
 // ----------------------------------------------------------------------------
 
 // wxObjScopeGuardImpl0
 // ----------------------------------------------------------------------------
 

-template <class Obj, typename MemFun>
+template <class Obj, class MemFun>

 class wxObjScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:
 class wxObjScopeGuardImpl0 : public wxScopeGuardImplBase
 {
 public:


@@ -216,13 +212,13 @@ protected:
     MemFun m_memfun;
 };
 
     MemFun m_memfun;
 };
 

-template <class Obj, typename MemFun>
+template <class Obj, class MemFun>

 inline wxObjScopeGuardImpl0<Obj, MemFun> wxMakeObjGuard(Obj& obj, MemFun memFun)
 {
     return wxObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
 }
 
 inline wxObjScopeGuardImpl0<Obj, MemFun> wxMakeObjGuard(Obj& obj, MemFun memFun)
 {
     return wxObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
 }
 

-template <class Obj, typename MemFun, typename P1>
+template <class Obj, class MemFun, class P1>

 class wxObjScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:
 class wxObjScopeGuardImpl1 : public wxScopeGuardImplBase
 {
 public:


@@ -237,7 +233,7 @@ public:
     void Execute() { (m_obj.*m_memfun)(m_p1); }
 
 protected:
     void Execute() { (m_obj.*m_memfun)(m_p1); }
 
 protected:

-    wxObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) 
+    wxObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1)

         : m_obj(obj), m_memfun(memFun), m_p1(p1) { }
 
     Obj& m_obj;
         : m_obj(obj), m_memfun(memFun), m_p1(p1) { }
 
     Obj& m_obj;


@@ -245,14 +241,14 @@ protected:
     const P1 m_p1;
 };
 
     const P1 m_p1;
 };
 

-template <class Obj, typename MemFun, typename P1>
+template <class Obj, class MemFun, class P1>

 inline wxObjScopeGuardImpl1<Obj, MemFun, P1>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
 {
     return wxObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
 }
 
 inline wxObjScopeGuardImpl1<Obj, MemFun, P1>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
 {
     return wxObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
 }
 

-template <class Obj, typename MemFun, typename P1, typename P2>
+template <class Obj, class MemFun, class P1, class P2>

 class wxObjScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:
 class wxObjScopeGuardImpl2 : public wxScopeGuardImplBase
 {
 public:


@@ -267,7 +263,7 @@ public:
     void Execute() { (m_obj.*m_memfun)(m_p1, m_p2); }
 
 protected:
     void Execute() { (m_obj.*m_memfun)(m_p1, m_p2); }
 
 protected:

-    wxObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) 
+    wxObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2)

         : m_obj(obj), m_memfun(memFun), m_p1(p1), m_p2(p2) { }
 
     Obj& m_obj;
         : m_obj(obj), m_memfun(memFun), m_p1(p1), m_p2(p2) { }
 
     Obj& m_obj;


@@ -276,7 +272,7 @@ protected:
     const P2 m_p2;
 };
 
     const P2 m_p2;
 };
 

-template <class Obj, typename MemFun, typename P1, typename P2>
+template <class Obj, class MemFun, class P1, class P2>

 inline wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
 {
 inline wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>
 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
 {


@@ -297,29 +293,43 @@ typedef const wxScopeGuardImplBase& wxScopeGuard;
 //     but this results in compiler warnings about unused variables and I
 //     didn't find a way to work around this other than by having different
 //     macros with different names
 //     but this results in compiler warnings about unused variables and I
 //     didn't find a way to work around this other than by having different
 //     macros with different names

-#define ON_BLOCK_EXIT0(f) \
-    wxScopeGuard wxMAKE_UNIQUE_NAME(scopeGuard) = wxMakeGuard(f); \
-    wxPrivate::Use(wxMAKE_UNIQUE_NAME(scopeGuard))
-
-#define ON_BLOCK_EXIT_OBJ0(o, m) \
-    wxScopeGuard wxMAKE_UNIQUE_NAME(scopeGuard) = wxMakeObjGuard(o, m); \
-    wxPrivate::Use(wxMAKE_UNIQUE_NAME(scopeGuard))

 
 

-#define ON_BLOCK_EXIT1(f, p1) \
-    wxScopeGuard wxMAKE_UNIQUE_NAME(scopeGuard) = wxMakeGuard(f, p1); \
-    wxPrivate::Use(wxMAKE_UNIQUE_NAME(scopeGuard))
-
-#define ON_BLOCK_EXIT_OBJ1(o, m, p1) \
-    wxScopeGuard wxMAKE_UNIQUE_NAME(scopeGuard) = wxMakeObjGuard(o, m, p1); \
-    wxPrivate::Use(wxMAKE_UNIQUE_NAME(scopeGuard))
-
-#define ON_BLOCK_EXIT2(f, p1, p2) \
-    wxScopeGuard wxMAKE_UNIQUE_NAME(scopeGuard) = wxMakeGuard(f, p1, p2); \
-    wxPrivate::Use(wxMAKE_UNIQUE_NAME(scopeGuard))
-
-#define ON_BLOCK_EXIT_OBJ2(o, m, p1, p2) \
-    wxScopeGuard wxMAKE_UNIQUE_NAME(scopeGuard) = wxMakeObjGuard(o, m, p1, p2); \
-    wxPrivate::Use(wxMAKE_UNIQUE_NAME(scopeGuard))
+#define wxGuardName    wxMAKE_UNIQUE_NAME(scopeGuard)
+
+#define wxON_BLOCK_EXIT0_IMPL(n, f) \
+    wxScopeGuard n = wxMakeGuard(f); \
+    wxPrivate::Use(n)
+#define wxON_BLOCK_EXIT0(f) \
+    wxON_BLOCK_EXIT0_IMPL(wxGuardName, f)
+
+#define wxON_BLOCK_EXIT_OBJ0_IMPL(n, o, m) \
+    wxScopeGuard n = wxMakeObjGuard(o, m); \
+    wxPrivate::Use(n)
+#define wxON_BLOCK_EXIT_OBJ0(o, m) \
+    wxON_BLOCK_EXIT_OBJ0_IMPL(wxGuardName, o, m)
+
+#define wxON_BLOCK_EXIT1_IMPL(n, f, p1) \
+    wxScopeGuard n = wxMakeGuard(f, p1); \
+    wxPrivate::Use(n)
+#define wxON_BLOCK_EXIT1(f, p1) \
+    wxON_BLOCK_EXIT1_IMPL(wxGuardName, f, p1)
+
+#define wxON_BLOCK_EXIT_OBJ1_IMPL(n, o, m, p1) \
+    wxScopeGuard n = wxMakeObjGuard(o, m, p1); \
+    wxPrivate::Use(n)
+#define wxON_BLOCK_EXIT_OBJ1(o, m, p1) \
+    wxON_BLOCK_EXIT_OBJ1_IMPL(wxGuardName, o, m, p1)
+
+#define wxON_BLOCK_EXIT2_IMPL(n, f, p1, p2) \
+    wxScopeGuard n = wxMakeGuard(f, p1, p2); \
+    wxPrivate::Use(n)
+#define wxON_BLOCK_EXIT2(f, p1, p2) \
+    wxON_BLOCK_EXIT2_IMPL(wxGuardName, f, p1, p2)
+
+#define wxON_BLOCK_EXIT_OBJ2_IMPL(n, o, m, p1, p2) \
+    wxScopeGuard n = wxMakeObjGuard(o, m, p1, p2); \
+    wxPrivate::Use(n)
+#define wxON_BLOCK_EXIT_OBJ2(o, m, p1, p2) \
+    wxON_BLOCK_EXIT_OBJ2_IMPL(wxGuardName, o, m, p1, p2)

 
 #endif // _WX_SCOPEGUARD_H_
 
 #endif // _WX_SCOPEGUARD_H_

-