include/wx/scopeguard.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/scopeguard.h
   3 // Purpose:     declares wxwxScopeGuard and related macros
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     03.07.2003
   7 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org>
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 /*
  12     Acknowledgements: this header is heavily based on (well, almost the exact
  13     copy of) ScopeGuard.h by Andrei Alexandrescu and Petru Marginean published
  14     in December 2000 issue of C/C++ Users Journal.
  15     http://www.cuj.com/documents/cujcexp1812alexandr/
  16  */
  17
  18 #ifndef _WX_SCOPEGUARD_H_
  19 #define _WX_SCOPEGUARD_H_
  20
  21 #include "wx/defs.h"
  22
  23 #include "wx/except.h"
  24
  25 // ----------------------------------------------------------------------------
  26 // helpers
  27 // ----------------------------------------------------------------------------
  28
  29 #ifdef __WATCOMC__
  30
  31 // WATCOM-FIXME: C++ of Open Watcom 1.3 doesn't like OnScopeExit() created
  32 // through template so it must be workarounded with dedicated inlined macro.
  33 // For compatibility with Watcom compilers wxPrivate::OnScopeExit must be
  34 // replaced with wxPrivateOnScopeExit but in user code (for everyone who
  35 // doesn't care about OW compatibility) wxPrivate::OnScopeExit still works.
  36
  37 #define wxPrivateOnScopeExit(guard)          \
  38     {                                        \
  39         if ( !(guard).WasDismissed() )       \
  40         {                                    \
  41             wxTRY                            \
  42             {                                \
  43                 (guard).Execute();           \
  44             }                                \
  45             wxCATCH_ALL(;)                   \
  46         }                                    \
  47     }
  48
  49 #define wxPrivateUse(n) wxUnusedVar(n)
  50
  51 #else
  52
  53 namespace wxPrivate
  54 {
  55     // in the original implementation this was a member template function of
  56     // ScopeGuardImplBase but gcc 2.8 which is still used for OS/2 doesn't
  57     // support member templates and so we must make it global
  58     template <class ScopeGuardImpl>
  59     void OnScopeExit(ScopeGuardImpl& guard)
  60     {
  61         if ( !guard.WasDismissed() )
  62         {
  63             // we're called from ScopeGuardImpl dtor and so we must not throw
  64             wxTRY
  65             {
  66                 guard.Execute();
  67             }
  68             wxCATCH_ALL(;) // do nothing, just eat the exception
  69         }
  70     }
  71
  72     // just to avoid the warning about unused variables
  73     template <class T>
  74     void Use(const T& WXUNUSED(t))
  75     {
  76     }
  77 } // namespace wxPrivate
  78
  79 #define wxPrivateOnScopeExit(n) wxPrivate::OnScopeExit(n)
  80 #define wxPrivateUse(n) wxPrivate::Use(n)
  81
  82 #endif
  83
  84 // ============================================================================
  85 // wxScopeGuard for functions and functors
  86 // ============================================================================
  87
  88 // ----------------------------------------------------------------------------
  89 // wxScopeGuardImplBase: used by wxScopeGuardImpl[0..N] below
  90 // ----------------------------------------------------------------------------
  91
  92 class wxScopeGuardImplBase
  93 {
  94 public:
  95     wxScopeGuardImplBase() : m_wasDismissed(false) { }
  96
  97     wxScopeGuardImplBase(const wxScopeGuardImplBase& other)
  98         : m_wasDismissed(other.m_wasDismissed)
  99     {
 100         other.Dismiss();
 101     }
 102
 103     void Dismiss() const { m_wasDismissed = true; }
 104
 105     // for OnScopeExit() only (we can't make it friend, unfortunately)!
 106     bool WasDismissed() const { return m_wasDismissed; }
 107
 108 protected:
 109     ~wxScopeGuardImplBase() { }
 110
 111     // must be mutable for copy ctor to work
 112     mutable bool m_wasDismissed;
 113
 114 private:
 115     wxScopeGuardImplBase& operator=(const wxScopeGuardImplBase&);
 116 };
 117
 118 // wxScopeGuard is just a reference, see the explanation in CUJ article
 119 typedef const wxScopeGuardImplBase& wxScopeGuard;
 120
 121 // ----------------------------------------------------------------------------
 122 // wxScopeGuardImpl0: scope guard for actions without parameters
 123 // ----------------------------------------------------------------------------
 124
 125 template <class F>
 126 class wxScopeGuardImpl0 : public wxScopeGuardImplBase
 127 {
 128 public:
 129     static wxScopeGuardImpl0<F> MakeGuard(F fun)
 130     {
 131         return wxScopeGuardImpl0<F>(fun);
 132     }
 133
 134     ~wxScopeGuardImpl0() { wxPrivateOnScopeExit(*this); }
 135
 136     void Execute() { m_fun(); }
 137
 138 protected:
 139     wxScopeGuardImpl0(F fun) : m_fun(fun) { }
 140
 141     F m_fun;
 142
 143     wxScopeGuardImpl0& operator=(const wxScopeGuardImpl0&);
 144 };
 145
 146 template <class F>
 147 inline wxScopeGuardImpl0<F> wxMakeGuard(F fun)
 148 {
 149     return wxScopeGuardImpl0<F>::MakeGuard(fun);
 150 }
 151
 152 // ----------------------------------------------------------------------------
 153 // wxScopeGuardImpl1: scope guard for actions with 1 parameter
 154 // ----------------------------------------------------------------------------
 155
 156 template <class F, class P1>
 157 class wxScopeGuardImpl1 : public wxScopeGuardImplBase
 158 {
 159 public:
 160     static wxScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1)
 161     {
 162         return wxScopeGuardImpl1<F, P1>(fun, p1);
 163     }
 164
 165     ~wxScopeGuardImpl1() { wxPrivateOnScopeExit(* this); }
 166
 167     void Execute() { m_fun(m_p1); }
 168
 169 protected:
 170     wxScopeGuardImpl1(F fun, P1 p1) : m_fun(fun), m_p1(p1) { }
 171
 172     F m_fun;
 173     const P1 m_p1;
 174
 175     wxScopeGuardImpl1& operator=(const wxScopeGuardImpl1&);
 176 };
 177
 178 template <class F, class P1>
 179 inline wxScopeGuardImpl1<F, P1> wxMakeGuard(F fun, P1 p1)
 180 {
 181     return wxScopeGuardImpl1<F, P1>::MakeGuard(fun, p1);
 182 }
 183
 184 // ----------------------------------------------------------------------------
 185 // wxScopeGuardImpl2: scope guard for actions with 2 parameters
 186 // ----------------------------------------------------------------------------
 187
 188 template <class F, class P1, class P2>
 189 class wxScopeGuardImpl2 : public wxScopeGuardImplBase
 190 {
 191 public:
 192     static wxScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2)
 193     {
 194         return wxScopeGuardImpl2<F, P1, P2>(fun, p1, p2);
 195     }
 196
 197     ~wxScopeGuardImpl2() { wxPrivateOnScopeExit(*this); }
 198
 199     void Execute() { m_fun(m_p1, m_p2); }
 200
 201 protected:
 202     wxScopeGuardImpl2(F fun, P1 p1, P2 p2) : m_fun(fun), m_p1(p1), m_p2(p2) { }
 203
 204     F m_fun;
 205     const P1 m_p1;
 206     const P2 m_p2;
 207
 208     wxScopeGuardImpl2& operator=(const wxScopeGuardImpl2&);
 209 };
 210
 211 template <class F, class P1, class P2>
 212 inline wxScopeGuardImpl2<F, P1, P2> wxMakeGuard(F fun, P1 p1, P2 p2)
 213 {
 214     return wxScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2);
 215 }
 216
 217 // ----------------------------------------------------------------------------
 218 // wxScopeGuardImpl3: scope guard for actions with 3 parameters
 219 // ----------------------------------------------------------------------------
 220
 221 template <class F, class P1, class P2, class P3>
 222 class wxScopeGuardImpl3 : public wxScopeGuardImplBase
 223 {
 224 public:
 225     static wxScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3)
 226     {
 227         return wxScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3);
 228     }
 229
 230     ~wxScopeGuardImpl3() { wxPrivateOnScopeExit(*this); }
 231
 232     void Execute() { m_fun(m_p1, m_p2, m_p3); }
 233
 234 protected:
 235     wxScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3)
 236         : m_fun(fun), m_p1(p1), m_p2(p2), m_p3(p3) { }
 237
 238     F m_fun;
 239     const P1 m_p1;
 240     const P2 m_p2;
 241     const P3 m_p3;
 242
 243     wxScopeGuardImpl3& operator=(const wxScopeGuardImpl3&);
 244 };
 245
 246 template <class F, class P1, class P2, class P3>
 247 inline wxScopeGuardImpl3<F, P1, P2, P3> wxMakeGuard(F fun, P1 p1, P2 p2, P3 p3)
 248 {
 249     return wxScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3);
 250 }
 251
 252 // ============================================================================
 253 // wxScopeGuards for object methods
 254 // ============================================================================
 255
 256 // ----------------------------------------------------------------------------
 257 // wxObjScopeGuardImpl0
 258 // ----------------------------------------------------------------------------
 259
 260 template <class Obj, class MemFun>
 261 class wxObjScopeGuardImpl0 : public wxScopeGuardImplBase
 262 {
 263 public:
 264     static wxObjScopeGuardImpl0<Obj, MemFun>
 265         MakeObjGuard(Obj& obj, MemFun memFun)
 266     {
 267         return wxObjScopeGuardImpl0<Obj, MemFun>(obj, memFun);
 268     }
 269
 270     ~wxObjScopeGuardImpl0() { wxPrivateOnScopeExit(*this); }
 271
 272     void Execute() { (m_obj.*m_memfun)(); }
 273
 274 protected:
 275     wxObjScopeGuardImpl0(Obj& obj, MemFun memFun)
 276         : m_obj(obj), m_memfun(memFun) { }
 277
 278     Obj& m_obj;
 279     MemFun m_memfun;
 280 };
 281
 282 template <class Obj, class MemFun>
 283 inline wxObjScopeGuardImpl0<Obj, MemFun> wxMakeObjGuard(Obj& obj, MemFun memFun)
 284 {
 285     return wxObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun);
 286 }
 287
 288 template <class Obj, class MemFun, class P1>
 289 class wxObjScopeGuardImpl1 : public wxScopeGuardImplBase
 290 {
 291 public:
 292     static wxObjScopeGuardImpl1<Obj, MemFun, P1>
 293         MakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
 294     {
 295         return wxObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1);
 296     }
 297
 298     ~wxObjScopeGuardImpl1() { wxPrivateOnScopeExit(*this); }
 299
 300     void Execute() { (m_obj.*m_memfun)(m_p1); }
 301
 302 protected:
 303     wxObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1)
 304         : m_obj(obj), m_memfun(memFun), m_p1(p1) { }
 305
 306     Obj& m_obj;
 307     MemFun m_memfun;
 308     const P1 m_p1;
 309 };
 310
 311 template <class Obj, class MemFun, class P1>
 312 inline wxObjScopeGuardImpl1<Obj, MemFun, P1>
 313 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1)
 314 {
 315     return wxObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1);
 316 }
 317
 318 template <class Obj, class MemFun, class P1, class P2>
 319 class wxObjScopeGuardImpl2 : public wxScopeGuardImplBase
 320 {
 321 public:
 322     static wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>
 323         MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
 324     {
 325         return wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2);
 326     }
 327
 328     ~wxObjScopeGuardImpl2() { wxPrivateOnScopeExit(*this); }
 329
 330     void Execute() { (m_obj.*m_memfun)(m_p1, m_p2); }
 331
 332 protected:
 333     wxObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2)
 334         : m_obj(obj), m_memfun(memFun), m_p1(p1), m_p2(p2) { }
 335
 336     Obj& m_obj;
 337     MemFun m_memfun;
 338     const P1 m_p1;
 339     const P2 m_p2;
 340 };
 341
 342 template <class Obj, class MemFun, class P1, class P2>
 343 inline wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>
 344 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2)
 345 {
 346     return wxObjScopeGuardImpl2<Obj, MemFun, P1, P2>::
 347                                             MakeObjGuard(obj, memFun, p1, p2);
 348 }
 349
 350 template <class Obj, class MemFun, class P1, class P2, class P3>
 351 class wxObjScopeGuardImpl3 : public wxScopeGuardImplBase
 352 {
 353 public:
 354     static wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>
 355         MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3)
 356     {
 357         return wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>(obj, memFun, p1, p2, p3);
 358     }
 359
 360     ~wxObjScopeGuardImpl3() { wxPrivateOnScopeExit(*this); }
 361
 362     void Execute() { (m_obj.*m_memfun)(m_p1, m_p2, m_p3); }
 363
 364 protected:
 365     wxObjScopeGuardImpl3(Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3)
 366         : m_obj(obj), m_memfun(memFun), m_p1(p1), m_p2(p2), m_p3(p3) { }
 367
 368     Obj& m_obj;
 369     MemFun m_memfun;
 370     const P1 m_p1;
 371     const P2 m_p2;
 372     const P3 m_p3;
 373 };
 374
 375 template <class Obj, class MemFun, class P1, class P2, class P3>
 376 inline wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>
 377 wxMakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3)
 378 {
 379     return wxObjScopeGuardImpl3<Obj, MemFun, P1, P2, P3>::
 380                                         MakeObjGuard(obj, memFun, p1, p2, p3);
 381 }
 382
 383 // ----------------------------------------------------------------------------
 384 // wxVariableSetter: use the same technique as for wxScopeGuard to allow
 385 //                   setting a variable to some value on block exit
 386 // ----------------------------------------------------------------------------
 387
 388 namespace wxPrivate
 389 {
 390
 391 // empty class just to be able to define a reference to it
 392 class VariableSetterBase : public wxScopeGuardImplBase { };
 393
 394 typedef const VariableSetterBase& VariableSetter;
 395
 396 template <typename T, typename U>
 397 class VariableSetterImpl : public VariableSetterBase
 398 {
 399 public:
 400     VariableSetterImpl(T& var, U value)
 401         : m_var(var),
 402           m_value(value)
 403     {
 404     }
 405
 406     ~VariableSetterImpl() { wxPrivateOnScopeExit(*this); }
 407
 408     void Execute() { m_var = m_value; }
 409
 410 private:
 411     T& m_var;
 412     const U m_value;
 413
 414     // suppress the warning about assignment operator not being generated
 415     VariableSetterImpl<T, U>& operator=(const VariableSetterImpl<T, U>&);
 416 };
 417
 418 template <typename T>
 419 class VariableNullerImpl : public VariableSetterBase
 420 {
 421 public:
 422     VariableNullerImpl(T& var)
 423         : m_var(var)
 424     {
 425     }
 426
 427     ~VariableNullerImpl() { wxPrivateOnScopeExit(*this); }
 428
 429     void Execute() { m_var = NULL; }
 430
 431 private:
 432     T& m_var;
 433
 434     VariableNullerImpl<T>& operator=(const VariableNullerImpl<T>&);
 435 };
 436
 437 } // namespace wxPrivate
 438
 439 template <typename T, typename U>
 440 inline
 441 wxPrivate::VariableSetterImpl<T, U> wxMakeVarSetter(T& var, U value)
 442 {
 443       return wxPrivate::VariableSetterImpl<T, U>(var, value);
 444 }
 445
 446 // calling wxMakeVarSetter(ptr, NULL) doesn't work because U is deduced to be
 447 // "int" and subsequent assignment of "U" to "T *" fails, so provide a special
 448 // function for this special case
 449 template <typename T>
 450 inline
 451 wxPrivate::VariableNullerImpl<T> wxMakeVarNuller(T& var)
 452 {
 453     return wxPrivate::VariableNullerImpl<T>(var);
 454 }
 455
 456 // ============================================================================
 457 // macros for declaring unnamed scoped guards (which can't be dismissed)
 458 // ============================================================================
 459
 460 // NB: the original code has a single (and much nicer) ON_BLOCK_EXIT macro
 461 //     but this results in compiler warnings about unused variables and I
 462 //     didn't find a way to work around this other than by having different
 463 //     macros with different names or using a less natural syntax for passing
 464 //     the arguments (e.g. as Boost preprocessor sequences, which would mean
 465 //     having to write wxON_BLOCK_EXIT(fwrite, (buf)(size)(n)(fp)) instead of
 466 //     wxON_BLOCK_EXIT4(fwrite, buf, size, n, fp)).
 467
 468 #define wxGuardName    wxMAKE_UNIQUE_NAME(wxScopeGuard)
 469
 470 #define wxON_BLOCK_EXIT0_IMPL(n, f) \
 471     wxScopeGuard n = wxMakeGuard(f); \
 472     wxPrivateUse(n)
 473 #define wxON_BLOCK_EXIT0(f) \
 474     wxON_BLOCK_EXIT0_IMPL(wxGuardName, f)
 475
 476 #define wxON_BLOCK_EXIT_OBJ0_IMPL(n, o, m) \
 477     wxScopeGuard n = wxMakeObjGuard(o, m); \
 478     wxPrivateUse(n)
 479 #define wxON_BLOCK_EXIT_OBJ0(o, m) \
 480     wxON_BLOCK_EXIT_OBJ0_IMPL(wxGuardName, o, &m)
 481
 482 #define wxON_BLOCK_EXIT_THIS0(m) \
 483     wxON_BLOCK_EXIT_OBJ0(*this, m)
 484
 485
 486 #define wxON_BLOCK_EXIT1_IMPL(n, f, p1) \
 487     wxScopeGuard n = wxMakeGuard(f, p1); \
 488     wxPrivateUse(n)
 489 #define wxON_BLOCK_EXIT1(f, p1) \
 490     wxON_BLOCK_EXIT1_IMPL(wxGuardName, f, p1)
 491
 492 #define wxON_BLOCK_EXIT_OBJ1_IMPL(n, o, m, p1) \
 493     wxScopeGuard n = wxMakeObjGuard(o, m, p1); \
 494     wxPrivateUse(n)
 495 #define wxON_BLOCK_EXIT_OBJ1(o, m, p1) \
 496     wxON_BLOCK_EXIT_OBJ1_IMPL(wxGuardName, o, &m, p1)
 497
 498 #define wxON_BLOCK_EXIT_THIS1(m, p1) \
 499     wxON_BLOCK_EXIT_OBJ1(*this, m, p1)
 500
 501
 502 #define wxON_BLOCK_EXIT2_IMPL(n, f, p1, p2) \
 503     wxScopeGuard n = wxMakeGuard(f, p1, p2); \
 504     wxPrivateUse(n)
 505 #define wxON_BLOCK_EXIT2(f, p1, p2) \
 506     wxON_BLOCK_EXIT2_IMPL(wxGuardName, f, p1, p2)
 507
 508 #define wxON_BLOCK_EXIT_OBJ2_IMPL(n, o, m, p1, p2) \
 509     wxScopeGuard n = wxMakeObjGuard(o, m, p1, p2); \
 510     wxPrivateUse(n)
 511 #define wxON_BLOCK_EXIT_OBJ2(o, m, p1, p2) \
 512     wxON_BLOCK_EXIT_OBJ2_IMPL(wxGuardName, o, &m, p1, p2)
 513
 514 #define wxON_BLOCK_EXIT_THIS2(m, p1, p2) \
 515     wxON_BLOCK_EXIT_OBJ2(*this, m, p1, p2)
 516
 517
 518 #define wxON_BLOCK_EXIT3_IMPL(n, f, p1, p2, p3) \
 519     wxScopeGuard n = wxMakeGuard(f, p1, p2, p3); \
 520     wxPrivateUse(n)
 521 #define wxON_BLOCK_EXIT3(f, p1, p2, p3) \
 522     wxON_BLOCK_EXIT3_IMPL(wxGuardName, f, p1, p2, p3)
 523
 524 #define wxON_BLOCK_EXIT_OBJ3_IMPL(n, o, m, p1, p2, p3) \
 525     wxScopeGuard n = wxMakeObjGuard(o, m, p1, p2, p3); \
 526     wxPrivateUse(n)
 527 #define wxON_BLOCK_EXIT_OBJ3(o, m, p1, p2, p3) \
 528     wxON_BLOCK_EXIT_OBJ3_IMPL(wxGuardName, o, &m, p1, p2, p3)
 529
 530 #define wxON_BLOCK_EXIT_THIS3(m, p1, p2, p3) \
 531     wxON_BLOCK_EXIT_OBJ3(*this, m, p1, p2, p3)
 532
 533
 534 #define wxSetterName wxMAKE_UNIQUE_NAME(wxVarSetter)
 535
 536 #define wxON_BLOCK_EXIT_SET_IMPL(n, var, value) \
 537     wxPrivate::VariableSetter n = wxMakeVarSetter(var, value); \
 538     wxPrivateUse(n)
 539
 540 #define wxON_BLOCK_EXIT_SET(var, value) \
 541     wxON_BLOCK_EXIT_SET_IMPL(wxSetterName, var, value)
 542
 543 #define wxON_BLOCK_EXIT_NULL_IMPL(n, var) \
 544     wxPrivate::VariableSetter n = wxMakeVarNuller(var); \
 545     wxPrivateUse(n)
 546
 547 #define wxON_BLOCK_EXIT_NULL(ptr) \
 548     wxON_BLOCK_EXIT_NULL_IMPL(wxSetterName, ptr)
 549
 550 #endif // _WX_SCOPEGUARD_H_