]>
git.saurik.com Git - wxWidgets.git/blob - include/wx/scopeguard.h
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: wx/scopeguard.h
3 // Purpose: declares wxwxScopeGuard and related macros
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
13 Acknowledgements: this header is heavily based on (well, almost the exact
14 copy of) ScopeGuard.h by Andrei Alexandrescu and Petru Marginean published
15 in December 2000 issue of C/C++ Users Journal.
16 http://www.cuj.com/documents/cujcexp1812alexandr/
19 #ifndef _WX_SCOPEGUARD_H_
20 #define _WX_SCOPEGUARD_H_
24 #include "wx/except.h"
26 // ----------------------------------------------------------------------------
28 // ----------------------------------------------------------------------------
32 // WATCOM-FIXME: C++ of Open Watcom 1.3 doesn't like OnScopeExit() created
33 // through template so it must be workarounded with dedicated inlined macro.
34 // For compatibility with Watcom compilers wxPrivate::OnScopeExit must be
35 // replaced with wxPrivateOnScopeExit but in user code (for everyone who
36 // doesn't care about OW compatibility) wxPrivate::OnScopeExit still works.
38 #define wxPrivateOnScopeExit(guard) \
40 if ( !(guard).WasDismissed() ) \
50 #define wxPrivateUse(n) wxUnusedVar(n)
56 // in the original implementation this was a member template function of
57 // ScopeGuardImplBase but gcc 2.8 which is still used for OS/2 doesn't
58 // support member templates and so we must make it global
59 template <class ScopeGuardImpl
>
60 void OnScopeExit(ScopeGuardImpl
& guard
)
62 if ( !guard
.WasDismissed() )
64 // we're called from ScopeGuardImpl dtor and so we must not throw
69 wxCATCH_ALL(;) // do nothing, just eat the exception
73 // just to avoid the warning about unused variables
75 void Use(const T
& WXUNUSED(t
))
78 } // namespace wxPrivate
80 #define wxPrivateOnScopeExit(n) wxPrivate::OnScopeExit(n)
81 #define wxPrivateUse(n) wxPrivate::Use(n)
85 // ============================================================================
86 // wxScopeGuard for functions and functors
87 // ============================================================================
89 // ----------------------------------------------------------------------------
90 // wxScopeGuardImplBase: used by wxScopeGuardImpl[0..N] below
91 // ----------------------------------------------------------------------------
93 class wxScopeGuardImplBase
96 wxScopeGuardImplBase() : m_wasDismissed(false) { }
98 void Dismiss() const { m_wasDismissed
= true; }
100 // for OnScopeExit() only (we can't make it friend, unfortunately)!
101 bool WasDismissed() const { return m_wasDismissed
; }
104 ~wxScopeGuardImplBase() { }
106 wxScopeGuardImplBase(const wxScopeGuardImplBase
& other
)
107 : m_wasDismissed(other
.m_wasDismissed
)
112 // must be mutable for copy ctor to work
113 mutable bool m_wasDismissed
;
116 wxScopeGuardImplBase
& operator=(const wxScopeGuardImplBase
&);
119 // ----------------------------------------------------------------------------
120 // wxScopeGuardImpl0: scope guard for actions without parameters
121 // ----------------------------------------------------------------------------
124 class wxScopeGuardImpl0
: public wxScopeGuardImplBase
127 static wxScopeGuardImpl0
<F
> MakeGuard(F fun
)
129 return wxScopeGuardImpl0
<F
>(fun
);
132 ~wxScopeGuardImpl0() { wxPrivateOnScopeExit(*this); }
134 void Execute() { m_fun(); }
137 wxScopeGuardImpl0(F fun
) : m_fun(fun
) { }
141 wxScopeGuardImpl0
& operator=(const wxScopeGuardImpl0
&);
145 inline wxScopeGuardImpl0
<F
> wxMakeGuard(F fun
)
147 return wxScopeGuardImpl0
<F
>::MakeGuard(fun
);
150 // ----------------------------------------------------------------------------
151 // wxScopeGuardImpl1: scope guard for actions with 1 parameter
152 // ----------------------------------------------------------------------------
154 template <class F
, class P1
>
155 class wxScopeGuardImpl1
: public wxScopeGuardImplBase
158 static wxScopeGuardImpl1
<F
, P1
> MakeGuard(F fun
, P1 p1
)
160 return wxScopeGuardImpl1
<F
, P1
>(fun
, p1
);
163 ~wxScopeGuardImpl1() { wxPrivateOnScopeExit(* this); }
165 void Execute() { m_fun(m_p1
); }
168 wxScopeGuardImpl1(F fun
, P1 p1
) : m_fun(fun
), m_p1(p1
) { }
173 wxScopeGuardImpl1
& operator=(const wxScopeGuardImpl1
&);
176 template <class F
, class P1
>
177 inline wxScopeGuardImpl1
<F
, P1
> wxMakeGuard(F fun
, P1 p1
)
179 return wxScopeGuardImpl1
<F
, P1
>::MakeGuard(fun
, p1
);
182 // ----------------------------------------------------------------------------
183 // wxScopeGuardImpl2: scope guard for actions with 2 parameters
184 // ----------------------------------------------------------------------------
186 template <class F
, class P1
, class P2
>
187 class wxScopeGuardImpl2
: public wxScopeGuardImplBase
190 static wxScopeGuardImpl2
<F
, P1
, P2
> MakeGuard(F fun
, P1 p1
, P2 p2
)
192 return wxScopeGuardImpl2
<F
, P1
, P2
>(fun
, p1
, p2
);
195 ~wxScopeGuardImpl2() { wxPrivateOnScopeExit(*this); }
197 void Execute() { m_fun(m_p1
, m_p2
); }
200 wxScopeGuardImpl2(F fun
, P1 p1
, P2 p2
) : m_fun(fun
), m_p1(p1
), m_p2(p2
) { }
206 wxScopeGuardImpl2
& operator=(const wxScopeGuardImpl2
&);
209 template <class F
, class P1
, class P2
>
210 inline wxScopeGuardImpl2
<F
, P1
, P2
> wxMakeGuard(F fun
, P1 p1
, P2 p2
)
212 return wxScopeGuardImpl2
<F
, P1
, P2
>::MakeGuard(fun
, p1
, p2
);
215 // ============================================================================
216 // wxScopeGuards for object methods
217 // ============================================================================
219 // ----------------------------------------------------------------------------
220 // wxObjScopeGuardImpl0
221 // ----------------------------------------------------------------------------
223 template <class Obj
, class MemFun
>
224 class wxObjScopeGuardImpl0
: public wxScopeGuardImplBase
227 static wxObjScopeGuardImpl0
<Obj
, MemFun
>
228 MakeObjGuard(Obj
& obj
, MemFun memFun
)
230 return wxObjScopeGuardImpl0
<Obj
, MemFun
>(obj
, memFun
);
233 ~wxObjScopeGuardImpl0() { wxPrivateOnScopeExit(*this); }
235 void Execute() { (m_obj
.*m_memfun
)(); }
238 wxObjScopeGuardImpl0(Obj
& obj
, MemFun memFun
)
239 : m_obj(obj
), m_memfun(memFun
) { }
245 template <class Obj
, class MemFun
>
246 inline wxObjScopeGuardImpl0
<Obj
, MemFun
> wxMakeObjGuard(Obj
& obj
, MemFun memFun
)
248 return wxObjScopeGuardImpl0
<Obj
, MemFun
>::MakeObjGuard(obj
, memFun
);
251 template <class Obj
, class MemFun
, class P1
>
252 class wxObjScopeGuardImpl1
: public wxScopeGuardImplBase
255 static wxObjScopeGuardImpl1
<Obj
, MemFun
, P1
>
256 MakeObjGuard(Obj
& obj
, MemFun memFun
, P1 p1
)
258 return wxObjScopeGuardImpl1
<Obj
, MemFun
, P1
>(obj
, memFun
, p1
);
261 ~wxObjScopeGuardImpl1() { wxPrivateOnScopeExit(*this); }
263 void Execute() { (m_obj
.*m_memfun
)(m_p1
); }
266 wxObjScopeGuardImpl1(Obj
& obj
, MemFun memFun
, P1 p1
)
267 : m_obj(obj
), m_memfun(memFun
), m_p1(p1
) { }
274 template <class Obj
, class MemFun
, class P1
>
275 inline wxObjScopeGuardImpl1
<Obj
, MemFun
, P1
>
276 wxMakeObjGuard(Obj
& obj
, MemFun memFun
, P1 p1
)
278 return wxObjScopeGuardImpl1
<Obj
, MemFun
, P1
>::MakeObjGuard(obj
, memFun
, p1
);
281 template <class Obj
, class MemFun
, class P1
, class P2
>
282 class wxObjScopeGuardImpl2
: public wxScopeGuardImplBase
285 static wxObjScopeGuardImpl2
<Obj
, MemFun
, P1
, P2
>
286 MakeObjGuard(Obj
& obj
, MemFun memFun
, P1 p1
, P2 p2
)
288 return wxObjScopeGuardImpl2
<Obj
, MemFun
, P1
, P2
>(obj
, memFun
, p1
, p2
);
291 ~wxObjScopeGuardImpl2() { wxPrivateOnScopeExit(*this); }
293 void Execute() { (m_obj
.*m_memfun
)(m_p1
, m_p2
); }
296 wxObjScopeGuardImpl2(Obj
& obj
, MemFun memFun
, P1 p1
, P2 p2
)
297 : m_obj(obj
), m_memfun(memFun
), m_p1(p1
), m_p2(p2
) { }
305 template <class Obj
, class MemFun
, class P1
, class P2
>
306 inline wxObjScopeGuardImpl2
<Obj
, MemFun
, P1
, P2
>
307 wxMakeObjGuard(Obj
& obj
, MemFun memFun
, P1 p1
, P2 p2
)
309 return wxObjScopeGuardImpl2
<Obj
, MemFun
, P1
, P2
>::
310 MakeObjGuard(obj
, memFun
, p1
, p2
);
313 // ============================================================================
315 // ============================================================================
317 // wxScopeGuard is just a reference, see the explanation in CUJ article
318 typedef const wxScopeGuardImplBase
& wxScopeGuard
;
320 // when an unnamed scope guard is needed, the macros below may be used
322 // NB: the original code has a single (and much nicer) ON_BLOCK_EXIT macro
323 // but this results in compiler warnings about unused variables and I
324 // didn't find a way to work around this other than by having different
325 // macros with different names
327 #define wxGuardName wxMAKE_UNIQUE_NAME(scopeGuard)
329 #define wxON_BLOCK_EXIT0_IMPL(n, f) \
330 wxScopeGuard n = wxMakeGuard(f); \
332 #define wxON_BLOCK_EXIT0(f) \
333 wxON_BLOCK_EXIT0_IMPL(wxGuardName, f)
335 #define wxON_BLOCK_EXIT_OBJ0_IMPL(n, o, m) \
336 wxScopeGuard n = wxMakeObjGuard(o, m); \
338 #define wxON_BLOCK_EXIT_OBJ0(o, m) \
339 wxON_BLOCK_EXIT_OBJ0_IMPL(wxGuardName, o, m)
341 #define wxON_BLOCK_EXIT1_IMPL(n, f, p1) \
342 wxScopeGuard n = wxMakeGuard(f, p1); \
344 #define wxON_BLOCK_EXIT1(f, p1) \
345 wxON_BLOCK_EXIT1_IMPL(wxGuardName, f, p1)
347 #define wxON_BLOCK_EXIT_OBJ1_IMPL(n, o, m, p1) \
348 wxScopeGuard n = wxMakeObjGuard(o, m, p1); \
350 #define wxON_BLOCK_EXIT_OBJ1(o, m, p1) \
351 wxON_BLOCK_EXIT_OBJ1_IMPL(wxGuardName, o, m, p1)
353 #define wxON_BLOCK_EXIT2_IMPL(n, f, p1, p2) \
354 wxScopeGuard n = wxMakeGuard(f, p1, p2); \
356 #define wxON_BLOCK_EXIT2(f, p1, p2) \
357 wxON_BLOCK_EXIT2_IMPL(wxGuardName, f, p1, p2)
359 #define wxON_BLOCK_EXIT_OBJ2_IMPL(n, o, m, p1, p2) \
360 wxScopeGuard n = wxMakeObjGuard(o, m, p1, p2); \
362 #define wxON_BLOCK_EXIT_OBJ2(o, m, p1, p2) \
363 wxON_BLOCK_EXIT_OBJ2_IMPL(wxGuardName, o, m, p1, p2)
365 #endif // _WX_SCOPEGUARD_H_