1 | //////////////////////////////////////////////////////////////////////////////// |
---|
2 | // The Loki Library |
---|
3 | // Copyright (c) 2000 Andrei Alexandrescu |
---|
4 | // Copyright (c) 2000 Petru Marginean |
---|
5 | // Copyright (c) 2005 Joshua Lehrer |
---|
6 | // |
---|
7 | // Permission to use, copy, modify, distribute and sell this software for any |
---|
8 | // purpose is hereby granted without fee, provided that the above copyright |
---|
9 | // notice appear in all copies and that both that copyright notice and this |
---|
10 | // permission notice appear in supporting documentation. |
---|
11 | // The author makes no representations about the |
---|
12 | // suitability of this software for any purpose. It is provided "as is" |
---|
13 | // without express or implied warranty. |
---|
14 | //////////////////////////////////////////////////////////////////////////////// |
---|
15 | #ifndef LOKI_SCOPEGUARD_INC_ |
---|
16 | #define LOKI_SCOPEGUARD_INC_ |
---|
17 | |
---|
18 | // $Id: ScopeGuard.h 799 2006-12-20 00:37:13Z rich_sposato $ |
---|
19 | |
---|
20 | |
---|
21 | #include "RefToValue.h" |
---|
22 | |
---|
23 | /// \defgroup ExceptionGroup Exception-safe code |
---|
24 | |
---|
25 | namespace Loki |
---|
26 | { |
---|
27 | |
---|
28 | //////////////////////////////////////////////////////////////// |
---|
29 | /// |
---|
30 | /// \class ScopeGuardImplBase |
---|
31 | /// \ingroup ExceptionGroup |
---|
32 | /// |
---|
33 | /// Base class used by all ScopeGuard implementations. All commonly used |
---|
34 | /// functions are in this class (e.g. - Dismiss and SafeExecute). |
---|
35 | /// |
---|
36 | /// See Andrei's and Petru Marginean's CUJ article |
---|
37 | /// http://www.cuj.com/documents/s=8000/cujcexp1812alexandr/alexandr.htm |
---|
38 | /// |
---|
39 | /// Changes to the original code by Joshua Lehrer: |
---|
40 | /// http://www.lehrerfamily.com/scopeguard.html |
---|
41 | //////////////////////////////////////////////////////////////// |
---|
42 | |
---|
43 | class ScopeGuardImplBase |
---|
44 | { |
---|
45 | /// Copy-assignment operator is not implemented and private. |
---|
46 | ScopeGuardImplBase& operator =(const ScopeGuardImplBase&); |
---|
47 | |
---|
48 | protected: |
---|
49 | |
---|
50 | ~ScopeGuardImplBase() |
---|
51 | {} |
---|
52 | |
---|
53 | /// Copy-constructor takes over responsibility from other ScopeGuard. |
---|
54 | ScopeGuardImplBase(const ScopeGuardImplBase& other) throw() |
---|
55 | : dismissed_(other.dismissed_) |
---|
56 | { |
---|
57 | other.Dismiss(); |
---|
58 | } |
---|
59 | |
---|
60 | template <typename J> |
---|
61 | static void SafeExecute(J& j) throw() |
---|
62 | { |
---|
63 | if (!j.dismissed_) |
---|
64 | try |
---|
65 | { |
---|
66 | j.Execute(); |
---|
67 | } |
---|
68 | catch(...) |
---|
69 | {} |
---|
70 | } |
---|
71 | |
---|
72 | mutable bool dismissed_; |
---|
73 | |
---|
74 | public: |
---|
75 | ScopeGuardImplBase() throw() : dismissed_(false) |
---|
76 | {} |
---|
77 | |
---|
78 | void Dismiss() const throw() |
---|
79 | { |
---|
80 | dismissed_ = true; |
---|
81 | } |
---|
82 | }; |
---|
83 | |
---|
84 | //////////////////////////////////////////////////////////////// |
---|
85 | /// |
---|
86 | /// \typedef typedef const ScopeGuardImplBase& ScopeGuard |
---|
87 | /// \ingroup ExceptionGroup |
---|
88 | /// |
---|
89 | //////////////////////////////////////////////////////////////// |
---|
90 | |
---|
91 | typedef const ScopeGuardImplBase& ScopeGuard; |
---|
92 | |
---|
93 | //////////////////////////////////////////////////////////////// |
---|
94 | /// |
---|
95 | /// \class ScopeGuardImpl0 |
---|
96 | /// \ingroup ExceptionGroup |
---|
97 | /// |
---|
98 | /// Implementation class for a standalone function or class static function |
---|
99 | /// with no parameters. ScopeGuard ignores any value returned from the |
---|
100 | /// call within the Execute function. |
---|
101 | /// |
---|
102 | /// This class has a single standalone helper function, MakeGuard which |
---|
103 | /// creates and returns a ScopeGuard. |
---|
104 | /// |
---|
105 | //////////////////////////////////////////////////////////////// |
---|
106 | |
---|
107 | template <typename F> |
---|
108 | class ScopeGuardImpl0 : public ScopeGuardImplBase |
---|
109 | { |
---|
110 | public: |
---|
111 | static ScopeGuardImpl0<F> MakeGuard(F fun) |
---|
112 | { |
---|
113 | return ScopeGuardImpl0<F>(fun); |
---|
114 | } |
---|
115 | |
---|
116 | ~ScopeGuardImpl0() throw() |
---|
117 | { |
---|
118 | SafeExecute(*this); |
---|
119 | } |
---|
120 | |
---|
121 | void Execute() |
---|
122 | { |
---|
123 | fun_(); |
---|
124 | } |
---|
125 | |
---|
126 | protected: |
---|
127 | ScopeGuardImpl0(F fun) : fun_(fun) |
---|
128 | {} |
---|
129 | |
---|
130 | F fun_; |
---|
131 | }; |
---|
132 | |
---|
133 | template <typename F> |
---|
134 | inline ScopeGuardImpl0<F> MakeGuard(F fun) |
---|
135 | { |
---|
136 | return ScopeGuardImpl0<F>::MakeGuard(fun); |
---|
137 | } |
---|
138 | |
---|
139 | //////////////////////////////////////////////////////////////// |
---|
140 | /// |
---|
141 | /// \class ScopeGuardImpl1 |
---|
142 | /// \ingroup ExceptionGroup |
---|
143 | /// |
---|
144 | /// Implementation class for a standalone function or class static function |
---|
145 | /// with one parameter. Each parameter is copied by value - use |
---|
146 | /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores |
---|
147 | /// any value returned from the call within the Execute function. |
---|
148 | /// |
---|
149 | /// This class has a single standalone helper function, MakeGuard which |
---|
150 | /// creates and returns a ScopeGuard. |
---|
151 | /// |
---|
152 | //////////////////////////////////////////////////////////////// |
---|
153 | |
---|
154 | template <typename F, typename P1> |
---|
155 | class ScopeGuardImpl1 : public ScopeGuardImplBase |
---|
156 | { |
---|
157 | public: |
---|
158 | static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) |
---|
159 | { |
---|
160 | return ScopeGuardImpl1<F, P1>(fun, p1); |
---|
161 | } |
---|
162 | |
---|
163 | ~ScopeGuardImpl1() throw() |
---|
164 | { |
---|
165 | SafeExecute(*this); |
---|
166 | } |
---|
167 | |
---|
168 | void Execute() |
---|
169 | { |
---|
170 | fun_(p1_); |
---|
171 | } |
---|
172 | |
---|
173 | protected: |
---|
174 | ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1) |
---|
175 | {} |
---|
176 | |
---|
177 | F fun_; |
---|
178 | const P1 p1_; |
---|
179 | }; |
---|
180 | |
---|
181 | template <typename F, typename P1> |
---|
182 | inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) |
---|
183 | { |
---|
184 | return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1); |
---|
185 | } |
---|
186 | |
---|
187 | //////////////////////////////////////////////////////////////// |
---|
188 | /// |
---|
189 | /// \class ScopeGuardImpl2 |
---|
190 | /// \ingroup ExceptionGroup |
---|
191 | /// |
---|
192 | /// Implementation class for a standalone function or class static function |
---|
193 | /// with two parameters. Each parameter is copied by value - use |
---|
194 | /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores |
---|
195 | /// any value returned from the call within the Execute function. |
---|
196 | /// |
---|
197 | /// This class has a single standalone helper function, MakeGuard which |
---|
198 | /// creates and returns a ScopeGuard. |
---|
199 | /// |
---|
200 | //////////////////////////////////////////////////////////////// |
---|
201 | |
---|
202 | template <typename F, typename P1, typename P2> |
---|
203 | class ScopeGuardImpl2: public ScopeGuardImplBase |
---|
204 | { |
---|
205 | public: |
---|
206 | static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) |
---|
207 | { |
---|
208 | return ScopeGuardImpl2<F, P1, P2>(fun, p1, p2); |
---|
209 | } |
---|
210 | |
---|
211 | ~ScopeGuardImpl2() throw() |
---|
212 | { |
---|
213 | SafeExecute(*this); |
---|
214 | } |
---|
215 | |
---|
216 | void Execute() |
---|
217 | { |
---|
218 | fun_(p1_, p2_); |
---|
219 | } |
---|
220 | |
---|
221 | protected: |
---|
222 | ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2) |
---|
223 | {} |
---|
224 | |
---|
225 | F fun_; |
---|
226 | const P1 p1_; |
---|
227 | const P2 p2_; |
---|
228 | }; |
---|
229 | |
---|
230 | template <typename F, typename P1, typename P2> |
---|
231 | inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) |
---|
232 | { |
---|
233 | return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2); |
---|
234 | } |
---|
235 | |
---|
236 | //////////////////////////////////////////////////////////////// |
---|
237 | /// |
---|
238 | /// \class ScopeGuardImpl3 |
---|
239 | /// \ingroup ExceptionGroup |
---|
240 | /// |
---|
241 | /// Implementation class for a standalone function or class static function |
---|
242 | /// with three parameters. Each parameter is copied by value - use |
---|
243 | /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores |
---|
244 | /// any value returned from the call within the Execute function. |
---|
245 | /// |
---|
246 | /// This class has a single standalone helper function, MakeGuard which |
---|
247 | /// creates and returns a ScopeGuard. |
---|
248 | /// |
---|
249 | //////////////////////////////////////////////////////////////// |
---|
250 | |
---|
251 | template <typename F, typename P1, typename P2, typename P3> |
---|
252 | class ScopeGuardImpl3 : public ScopeGuardImplBase |
---|
253 | { |
---|
254 | public: |
---|
255 | static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) |
---|
256 | { |
---|
257 | return ScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3); |
---|
258 | } |
---|
259 | |
---|
260 | ~ScopeGuardImpl3() throw() |
---|
261 | { |
---|
262 | SafeExecute(*this); |
---|
263 | } |
---|
264 | |
---|
265 | void Execute() |
---|
266 | { |
---|
267 | fun_(p1_, p2_, p3_); |
---|
268 | } |
---|
269 | |
---|
270 | protected: |
---|
271 | ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3) |
---|
272 | {} |
---|
273 | |
---|
274 | F fun_; |
---|
275 | const P1 p1_; |
---|
276 | const P2 p2_; |
---|
277 | const P3 p3_; |
---|
278 | }; |
---|
279 | |
---|
280 | template <typename F, typename P1, typename P2, typename P3> |
---|
281 | inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) |
---|
282 | { |
---|
283 | return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3); |
---|
284 | } |
---|
285 | |
---|
286 | //////////////////////////////////////////////////////////////// |
---|
287 | /// |
---|
288 | /// \class ScopeGuardImpl4 |
---|
289 | /// \ingroup ExceptionGroup |
---|
290 | /// |
---|
291 | /// Implementation class for a standalone function or class static function |
---|
292 | /// with four parameters. Each parameter is copied by value - use |
---|
293 | /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores |
---|
294 | /// any value returned from the call within the Execute function. |
---|
295 | /// |
---|
296 | /// This class has a single standalone helper function, MakeGuard which |
---|
297 | /// creates and returns a ScopeGuard. |
---|
298 | /// |
---|
299 | //////////////////////////////////////////////////////////////// |
---|
300 | |
---|
301 | template < typename F, typename P1, typename P2, typename P3, typename P4 > |
---|
302 | class ScopeGuardImpl4 : public ScopeGuardImplBase |
---|
303 | { |
---|
304 | public: |
---|
305 | static ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( |
---|
306 | F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) |
---|
307 | { |
---|
308 | return ScopeGuardImpl4< F, P1, P2, P3, P4 >( fun, p1, p2, p3, p4 ); |
---|
309 | } |
---|
310 | |
---|
311 | ~ScopeGuardImpl4() throw() |
---|
312 | { |
---|
313 | SafeExecute( *this ); |
---|
314 | } |
---|
315 | |
---|
316 | void Execute() |
---|
317 | { |
---|
318 | fun_( p1_, p2_, p3_, p4_ ); |
---|
319 | } |
---|
320 | |
---|
321 | protected: |
---|
322 | ScopeGuardImpl4( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) : |
---|
323 | fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ) |
---|
324 | {} |
---|
325 | |
---|
326 | F fun_; |
---|
327 | const P1 p1_; |
---|
328 | const P2 p2_; |
---|
329 | const P3 p3_; |
---|
330 | const P4 p4_; |
---|
331 | }; |
---|
332 | |
---|
333 | template < typename F, typename P1, typename P2, typename P3, typename P4 > |
---|
334 | inline ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) |
---|
335 | { |
---|
336 | return ScopeGuardImpl4< F, P1, P2, P3, P4 >::MakeGuard( fun, p1, p2, p3, p4 ); |
---|
337 | } |
---|
338 | |
---|
339 | //////////////////////////////////////////////////////////////// |
---|
340 | /// |
---|
341 | /// \class ScopeGuardImpl5 |
---|
342 | /// \ingroup ExceptionGroup |
---|
343 | /// |
---|
344 | /// Implementation class for a standalone function or class static function |
---|
345 | /// with five parameters. Each parameter is copied by value - use |
---|
346 | /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores |
---|
347 | /// any value returned from the call within the Execute function. |
---|
348 | /// |
---|
349 | /// This class has a single standalone helper function, MakeGuard which |
---|
350 | /// creates and returns a ScopeGuard. |
---|
351 | /// |
---|
352 | //////////////////////////////////////////////////////////////// |
---|
353 | |
---|
354 | template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > |
---|
355 | class ScopeGuardImpl5 : public ScopeGuardImplBase |
---|
356 | { |
---|
357 | public: |
---|
358 | static ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( |
---|
359 | F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) |
---|
360 | { |
---|
361 | return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >( fun, p1, p2, p3, p4, p5 ); |
---|
362 | } |
---|
363 | |
---|
364 | ~ScopeGuardImpl5() throw() |
---|
365 | { |
---|
366 | SafeExecute( *this ); |
---|
367 | } |
---|
368 | |
---|
369 | void Execute() |
---|
370 | { |
---|
371 | fun_( p1_, p2_, p3_, p4_, p5_ ); |
---|
372 | } |
---|
373 | |
---|
374 | protected: |
---|
375 | ScopeGuardImpl5( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) : |
---|
376 | fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ), p5_( p5 ) |
---|
377 | {} |
---|
378 | |
---|
379 | F fun_; |
---|
380 | const P1 p1_; |
---|
381 | const P2 p2_; |
---|
382 | const P3 p3_; |
---|
383 | const P4 p4_; |
---|
384 | const P5 p5_; |
---|
385 | }; |
---|
386 | |
---|
387 | template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > |
---|
388 | inline ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) |
---|
389 | { |
---|
390 | return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >::MakeGuard( fun, p1, p2, p3, p4, p5 ); |
---|
391 | } |
---|
392 | |
---|
393 | //////////////////////////////////////////////////////////////// |
---|
394 | /// |
---|
395 | /// \class ObjScopeGuardImpl0 |
---|
396 | /// \ingroup ExceptionGroup |
---|
397 | /// |
---|
398 | /// Implementation class for a class per-instance member function with no |
---|
399 | /// parameters. ScopeGuard ignores any value returned from the call within |
---|
400 | /// the Execute function. |
---|
401 | /// |
---|
402 | /// This class has 3 standalone helper functions which create a ScopeGuard. |
---|
403 | /// One is MakeObjGuard, which is deprecated but provided for older code. |
---|
404 | /// The other two are MakeGuard overloads, one which takes a pointer to an |
---|
405 | /// object, and the other which takes a reference. |
---|
406 | /// |
---|
407 | //////////////////////////////////////////////////////////////// |
---|
408 | |
---|
409 | template <class Obj, typename MemFun> |
---|
410 | class ObjScopeGuardImpl0 : public ScopeGuardImplBase |
---|
411 | { |
---|
412 | public: |
---|
413 | static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) |
---|
414 | { |
---|
415 | return ObjScopeGuardImpl0<Obj, MemFun>(obj, memFun); |
---|
416 | } |
---|
417 | |
---|
418 | ~ObjScopeGuardImpl0() throw() |
---|
419 | { |
---|
420 | SafeExecute(*this); |
---|
421 | } |
---|
422 | |
---|
423 | void Execute() |
---|
424 | { |
---|
425 | (obj_.*memFun_)(); |
---|
426 | } |
---|
427 | |
---|
428 | protected: |
---|
429 | ObjScopeGuardImpl0(Obj& obj, MemFun memFun) : obj_(obj), memFun_(memFun) |
---|
430 | {} |
---|
431 | |
---|
432 | Obj& obj_; |
---|
433 | MemFun memFun_; |
---|
434 | }; |
---|
435 | |
---|
436 | template <class Obj, typename MemFun> |
---|
437 | inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) |
---|
438 | { |
---|
439 | return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun); |
---|
440 | } |
---|
441 | |
---|
442 | template <typename Ret, class Obj1, class Obj2> |
---|
443 | inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 &obj) |
---|
444 | { |
---|
445 | return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(obj,memFun); |
---|
446 | } |
---|
447 | |
---|
448 | template <typename Ret, class Obj1, class Obj2> |
---|
449 | inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 *obj) |
---|
450 | { |
---|
451 | return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(*obj,memFun); |
---|
452 | } |
---|
453 | |
---|
454 | //////////////////////////////////////////////////////////////// |
---|
455 | /// |
---|
456 | /// \class ObjScopeGuardImpl1 |
---|
457 | /// \ingroup ExceptionGroup |
---|
458 | /// |
---|
459 | /// Implementation class for a class per-instance member function with one |
---|
460 | /// parameter. The parameter is copied by value - use ::Loki::ByRef if you |
---|
461 | /// must use a reference instead. ScopeGuard ignores any value returned |
---|
462 | /// from the call within the Execute function. |
---|
463 | /// |
---|
464 | /// This class has 3 standalone helper functions which create a ScopeGuard. |
---|
465 | /// One is MakeObjGuard, which is deprecated but provided for older code. |
---|
466 | /// The other two are MakeGuard overloads, one which takes a pointer to an |
---|
467 | /// object, and the other which takes a reference. |
---|
468 | /// |
---|
469 | //////////////////////////////////////////////////////////////// |
---|
470 | |
---|
471 | template <class Obj, typename MemFun, typename P1> |
---|
472 | class ObjScopeGuardImpl1 : public ScopeGuardImplBase |
---|
473 | { |
---|
474 | public: |
---|
475 | static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) |
---|
476 | { |
---|
477 | return ObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1); |
---|
478 | } |
---|
479 | |
---|
480 | ~ObjScopeGuardImpl1() throw() |
---|
481 | { |
---|
482 | SafeExecute(*this); |
---|
483 | } |
---|
484 | |
---|
485 | void Execute() |
---|
486 | { |
---|
487 | (obj_.*memFun_)(p1_); |
---|
488 | } |
---|
489 | |
---|
490 | protected: |
---|
491 | ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) : obj_(obj), memFun_(memFun), p1_(p1) |
---|
492 | {} |
---|
493 | |
---|
494 | Obj& obj_; |
---|
495 | MemFun memFun_; |
---|
496 | const P1 p1_; |
---|
497 | }; |
---|
498 | |
---|
499 | template <class Obj, typename MemFun, typename P1> |
---|
500 | inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) |
---|
501 | { |
---|
502 | return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1); |
---|
503 | } |
---|
504 | |
---|
505 | template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> |
---|
506 | inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 &obj, P1b p1) |
---|
507 | { |
---|
508 | return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(obj,memFun,p1); |
---|
509 | } |
---|
510 | |
---|
511 | template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> |
---|
512 | inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 *obj, P1b p1) |
---|
513 | { |
---|
514 | return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(*obj,memFun,p1); |
---|
515 | } |
---|
516 | |
---|
517 | //////////////////////////////////////////////////////////////// |
---|
518 | /// |
---|
519 | /// \class ObjScopeGuardImpl2 |
---|
520 | /// \ingroup ExceptionGroup |
---|
521 | /// |
---|
522 | /// Implementation class for a class per-instance member function with two |
---|
523 | /// parameters. Each parameter is copied by value - use ::Loki::ByRef if you |
---|
524 | /// must use a reference instead. ScopeGuard ignores any value returned |
---|
525 | /// from the call within the Execute function. |
---|
526 | /// |
---|
527 | /// This class has 3 standalone helper functions which create a ScopeGuard. |
---|
528 | /// One is MakeObjGuard, which is deprecated but provided for older code. |
---|
529 | /// The other two are MakeGuard overloads, one which takes a pointer to an |
---|
530 | /// object, and the other which takes a reference. |
---|
531 | /// |
---|
532 | //////////////////////////////////////////////////////////////// |
---|
533 | |
---|
534 | template <class Obj, typename MemFun, typename P1, typename P2> |
---|
535 | class ObjScopeGuardImpl2 : public ScopeGuardImplBase |
---|
536 | { |
---|
537 | public: |
---|
538 | static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) |
---|
539 | { |
---|
540 | return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2); |
---|
541 | } |
---|
542 | |
---|
543 | ~ObjScopeGuardImpl2() throw() |
---|
544 | { |
---|
545 | SafeExecute(*this); |
---|
546 | } |
---|
547 | |
---|
548 | void Execute() |
---|
549 | { |
---|
550 | (obj_.*memFun_)(p1_, p2_); |
---|
551 | } |
---|
552 | |
---|
553 | protected: |
---|
554 | ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2) |
---|
555 | {} |
---|
556 | |
---|
557 | Obj& obj_; |
---|
558 | MemFun memFun_; |
---|
559 | const P1 p1_; |
---|
560 | const P2 p2_; |
---|
561 | }; |
---|
562 | |
---|
563 | template <class Obj, typename MemFun, typename P1, typename P2> |
---|
564 | inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) |
---|
565 | { |
---|
566 | return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2); |
---|
567 | } |
---|
568 | |
---|
569 | template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> |
---|
570 | inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 &obj, P1b p1, P2b p2) |
---|
571 | { |
---|
572 | return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(obj,memFun,p1,p2); |
---|
573 | } |
---|
574 | |
---|
575 | template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> |
---|
576 | inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 *obj, P1b p1, P2b p2) |
---|
577 | { |
---|
578 | return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(*obj,memFun,p1,p2); |
---|
579 | } |
---|
580 | |
---|
581 | //////////////////////////////////////////////////////////////// |
---|
582 | /// |
---|
583 | /// \class ObjScopeGuardImpl3 |
---|
584 | /// \ingroup ExceptionGroup |
---|
585 | /// |
---|
586 | /// Implementation class for a class per-instance member function with three |
---|
587 | /// parameters. Each parameter is copied by value - use ::Loki::ByRef if you |
---|
588 | /// must use a reference instead. ScopeGuard ignores any value returned |
---|
589 | /// from the call within the Execute function. |
---|
590 | /// |
---|
591 | /// This class has 3 standalone helper functions which create a ScopeGuard. |
---|
592 | /// One is MakeObjGuard, which is deprecated but provided for older code. |
---|
593 | /// The other two are MakeGuard overloads, one which takes a pointer to an |
---|
594 | /// object, and the other which takes a reference. |
---|
595 | /// |
---|
596 | //////////////////////////////////////////////////////////////// |
---|
597 | |
---|
598 | template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > |
---|
599 | class ObjScopeGuardImpl3 : public ScopeGuardImplBase |
---|
600 | { |
---|
601 | public: |
---|
602 | static ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( |
---|
603 | Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) |
---|
604 | { |
---|
605 | return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >( obj, memFun, p1, p2, p3 ); |
---|
606 | } |
---|
607 | |
---|
608 | ~ObjScopeGuardImpl3() throw() |
---|
609 | { |
---|
610 | SafeExecute( *this ); |
---|
611 | } |
---|
612 | |
---|
613 | void Execute() |
---|
614 | { |
---|
615 | ( obj_.*memFun_ )( p1_, p2_, p3_ ); |
---|
616 | } |
---|
617 | |
---|
618 | protected: |
---|
619 | ObjScopeGuardImpl3( Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) : |
---|
620 | obj_( obj ), memFun_( memFun ), p1_( p1 ), p2_( p2 ), p3_( p3 ) |
---|
621 | {} |
---|
622 | |
---|
623 | Obj& obj_; |
---|
624 | MemFun memFun_; |
---|
625 | const P1 p1_; |
---|
626 | const P2 p2_; |
---|
627 | const P3 p3_; |
---|
628 | }; |
---|
629 | |
---|
630 | template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > |
---|
631 | inline ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( |
---|
632 | Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) |
---|
633 | { |
---|
634 | return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >::MakeObjGuard( |
---|
635 | obj, memFun, p1, p2, p3 ); |
---|
636 | } |
---|
637 | |
---|
638 | template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, |
---|
639 | typename P2a, typename P2b, typename P3a, typename P3b > |
---|
640 | inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > |
---|
641 | MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 & obj, P1b p1, P2b p2, P3b p3 ) |
---|
642 | { |
---|
643 | return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > |
---|
644 | ::MakeObjGuard( obj, memFun, p1, p2, p3 ); |
---|
645 | } |
---|
646 | |
---|
647 | template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, |
---|
648 | typename P2a, typename P2b, typename P3a, typename P3b > |
---|
649 | inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > |
---|
650 | MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 * obj, P1b p1, P2b p2, P3b p3 ) |
---|
651 | { |
---|
652 | return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > |
---|
653 | ::MakeObjGuard( *obj, memFun, p1, p2, p3 ); |
---|
654 | } |
---|
655 | |
---|
656 | } // namespace Loki |
---|
657 | |
---|
658 | #define LOKI_CONCATENATE_DIRECT(s1, s2) s1##s2 |
---|
659 | #define LOKI_CONCATENATE(s1, s2) LOKI_CONCATENATE_DIRECT(s1, s2) |
---|
660 | #define LOKI_ANONYMOUS_VARIABLE(str) LOKI_CONCATENATE(str, __LINE__) |
---|
661 | |
---|
662 | #define LOKI_ON_BLOCK_EXIT ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeGuard |
---|
663 | #define LOKI_ON_BLOCK_EXIT_OBJ ::Loki::ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = ::Loki::MakeObjGuard |
---|
664 | |
---|
665 | #endif // end file guardian |
---|
666 | |
---|