bracket unused function

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

diff --git a/include/wx/scopeguard.h b/include/wx/scopeguard.h
index 45fe82f5bf5d21adcc8a695a5cded0f3eb245f6d..a68c9896d8bf0cd9dee2ab8c416119acd75a993e 100644 (file)
--- a/include/wx/scopeguard.h
+++ b/include/wx/scopeguard.h
@@ -51,17 +51,8 @@
 
 #else
 
 
 #else
 

-// namespace support was first implemented in gcc-2.95,
-// so avoid using it for older versions.
-#if !defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 95)
-
-#define wxHAS_NAMESPACES
-

 namespace wxPrivate
 {
 namespace wxPrivate
 {

-#else
-#define wxPrivate
-#endif

     // 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


@@ -84,9 +75,7 @@ namespace wxPrivate
     void Use(const T& WXUNUSED(t))
     {
     }
     void Use(const T& WXUNUSED(t))
     {
     }

-#if !defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 95)

 } // namespace wxPrivate
 } // namespace wxPrivate

-#endif

 
 #define wxPrivateOnScopeExit(n) wxPrivate::OnScopeExit(n)
 #define wxPrivateUse(n) wxPrivate::Use(n)
 
 #define wxPrivateOnScopeExit(n) wxPrivate::OnScopeExit(n)
 #define wxPrivateUse(n) wxPrivate::Use(n)


@@ -226,6 +215,41 @@ inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
     return wxScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
 }
 
     return wxScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
 }
 

+// ----------------------------------------------------------------------------
+// wxScopeGuardImpl3: scope guard for actions with 3 parameters
+// ----------------------------------------------------------------------------
+
+template <class F, class P1, class P2, class P3>
+class wxScopeGuardImpl3 : public wxScopeGuardImplBase
+{
+public:
+    static wxScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
+    {
+        return wxScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3);
+    }
+
+    ~wxScopeGuardImpl3() { wxPrivateOnScopeExit(*this); }
+
+    void Execute() { m_fun(m_p1, m_p2, m_p3); }
+
+protected:
+    wxScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3)
+        : m_fun(fun), m_p1(p1), m_p2(p2), m_p3(p3) { }
+
+    F m_fun;
+    const P1 m_p1;
+    const P2 m_p2;
+    const P3 m_p3;
+
+    wxScopeGuardImpl3& operator=(const wxScopeGuardImpl3&);
+};
+
+template <class F, class P1, class P2, class P3>
+inline wxScopeGuardImpl3<F, P1, P2, P3> wxMakeGuard(F fun, P1 p1, P2 p2, P3 p3)
+{
+    return wxScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3);
+}
+

 // ============================================================================
 // wxScopeGuards for object methods
 // ============================================================================
 // ============================================================================
 // wxScopeGuards for object methods
 // ============================================================================


@@ -324,13 +348,44 @@ wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
                                             MakeObjGuard(obj, memFun, p1, p2);
 }
 
                                             MakeObjGuard(obj, memFun, p1, p2);
 }
 

+template <class Obj, class MemFun, class P1, class P2, class P3>
+class wxObjScopeGuardImpl3 : public wxScopeGuardImplBase
+{
+public:
+    static wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>
+        MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3)
+    {
+        return wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>(obj, memFun, p1, p2, p3);
+    }
+
+    ~wxObjScopeGuardImpl3() { wxPrivateOnScopeExit(*this); }
+
+    void Execute() { (m_obj.*m_memfun)(m_p1, m_p2, m_p3); }
+
+protected:
+    wxObjScopeGuardImpl3(Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3)
+        : m_obj(obj), m_memfun(memFun), m_p1(p1), m_p2(p2), m_p3(p3) { }
+
+    Obj& m_obj;
+    MemFun m_memfun;
+    const P1 m_p1;
+    const P2 m_p2;
+    const P3 m_p3;
+};
+
+template <class Obj, class MemFun, class P1, class P2, class P3>
+inline wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>
+wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3)
+{
+    return wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>::
+                                        MakeObjGuard(obj, memFun, p1, p2, p3);
+}
+

 // ----------------------------------------------------------------------------
 // wxVariableSetter: use the same technique as for wxScopeGuard to allow
 //                   setting a variable to some value on block exit
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxVariableSetter: use the same technique as for wxScopeGuard to allow
 //                   setting a variable to some value on block exit
 // ----------------------------------------------------------------------------
 

-#ifdef wxHAS_NAMESPACES
-

 namespace wxPrivate
 {
 
 namespace wxPrivate
 {
 


@@ -343,7 +398,7 @@ template <typename T, typename U>
 class VariableSetterImpl : public VariableSetterBase
 {
 public:
 class VariableSetterImpl : public VariableSetterBase
 {
 public:

-    VariableSetterImpl(T& var, const U& value)
+    VariableSetterImpl(T& var, U value)

         : m_var(var),
           m_value(value)
     {
         : m_var(var),
           m_value(value)
     {


@@ -356,7 +411,7 @@ public:
 
 private:
     T& m_var;
 
 private:
     T& m_var;

-    const U& m_value;
+    const U m_value;

 
     // suppress the warning about assignment operator not being generated
     VariableSetterImpl<T, U>& operator=(const VariableSetterImpl<T, U>&);
 
     // suppress the warning about assignment operator not being generated
     VariableSetterImpl<T, U>& operator=(const VariableSetterImpl<T, U>&);


@@ -386,7 +441,7 @@ private:
 
 template <typename T, typename U>
 inline
 
 template <typename T, typename U>
 inline

-wxPrivate::VariableSetterImpl<T, U> wxMakeVarSetter(T& var, const U& value)
+wxPrivate::VariableSetterImpl<T, U> wxMakeVarSetter(T& var, U value)

 {
       return wxPrivate::VariableSetterImpl<T, U>(var, value);
 }
 {
       return wxPrivate::VariableSetterImpl<T, U>(var, value);
 }


@@ -401,8 +456,6 @@ wxPrivate::VariableNullerImpl<T> wxMakeVarNuller(T& var)
     return wxPrivate::VariableNullerImpl<T>(var);
 }
 
     return wxPrivate::VariableNullerImpl<T>(var);
 }
 

-#endif // wxHAS_NAMESPACES
-

 // ============================================================================
 // macros for declaring unnamed scoped guards (which can't be dismissed)
 // ============================================================================
 // ============================================================================
 // macros for declaring unnamed scoped guards (which can't be dismissed)
 // ============================================================================


@@ -465,6 +518,22 @@ wxPrivate::VariableNullerImpl<T> wxMakeVarNuller(T& var)
     wxON_BLOCK_EXIT_OBJ2(*this, m, p1, p2)
 
 
     wxON_BLOCK_EXIT_OBJ2(*this, m, p1, p2)
 
 

+#define wxON_BLOCK_EXIT3_IMPL(n, f, p1, p2, p3) \
+    wxScopeGuard n = wxMakeGuard(f, p1, p2, p3); \
+    wxPrivateUse(n)
+#define wxON_BLOCK_EXIT3(f, p1, p2, p3) \
+    wxON_BLOCK_EXIT3_IMPL(wxGuardName, f, p1, p2, p3)
+
+#define wxON_BLOCK_EXIT_OBJ3_IMPL(n, o, m, p1, p2, p3) \
+    wxScopeGuard n = wxMakeObjGuard(o, m, p1, p2, p3); \
+    wxPrivateUse(n)
+#define wxON_BLOCK_EXIT_OBJ3(o, m, p1, p2, p3) \
+    wxON_BLOCK_EXIT_OBJ3_IMPL(wxGuardName, o, &m, p1, p2, p3)
+
+#define wxON_BLOCK_EXIT_THIS3(m, p1, p2, p3) \
+    wxON_BLOCK_EXIT_OBJ3(*this, m, p1, p2, p3)
+
+

 #define wxSetterName wxMAKE_UNIQUE_NAME(wxVarSetter)
 
 #define wxON_BLOCK_EXIT_SET_IMPL(n, var, value) \
 #define wxSetterName wxMAKE_UNIQUE_NAME(wxVarSetter)
 
 #define wxON_BLOCK_EXIT_SET_IMPL(n, var, value) \