diff options
Diffstat (limited to 'shared/loki/ScopeGuard.h')
| -rw-r--r-- | shared/loki/ScopeGuard.h | 1220 |
1 files changed, 610 insertions, 610 deletions
diff --git a/shared/loki/ScopeGuard.h b/shared/loki/ScopeGuard.h index b530068d..0b5445f5 100644 --- a/shared/loki/ScopeGuard.h +++ b/shared/loki/ScopeGuard.h @@ -4,12 +4,12 @@ // Copyright (c) 2000 Petru Marginean // Copyright (c) 2005 Joshua Lehrer // -// Permission to use, copy, modify, distribute and sell this software for any -// purpose is hereby granted without fee, provided that the above copyright -// notice appear in all copies and that both that copyright notice and this +// Permission to use, copy, modify, distribute and sell this software for any +// purpose is hereby granted without fee, provided that the above copyright +// notice appear in all copies and that both that copyright notice and this // permission notice appear in supporting documentation. -// The author makes no representations about the -// suitability of this software for any purpose. It is provided "as is" +// The author makes no representations about the +// suitability of this software for any purpose. It is provided "as is" // without express or implied warranty. //////////////////////////////////////////////////////////////////////////////// #ifndef LOKI_SCOPEGUARD_INC_ @@ -25,634 +25,634 @@ namespace Loki { - //////////////////////////////////////////////////////////////// - /// - /// \class ScopeGuardImplBase - /// \ingroup ExceptionGroup - /// - /// Base class used by all ScopeGuard implementations. All commonly used - /// functions are in this class (e.g. - Dismiss and SafeExecute). - /// - /// See Andrei's and Petru Marginean's CUJ article - /// http://www.cuj.com/documents/s=8000/cujcexp1812alexandr/alexandr.htm - /// - /// Changes to the original code by Joshua Lehrer: - /// http://www.lehrerfamily.com/scopeguard.html - //////////////////////////////////////////////////////////////// - - class ScopeGuardImplBase - { - /// Copy-assignment operator is not implemented and private. - ScopeGuardImplBase& operator =(const ScopeGuardImplBase&); - - protected: - - ~ScopeGuardImplBase() - {} - - /// Copy-constructor takes over responsibility from other ScopeGuard. - ScopeGuardImplBase(const ScopeGuardImplBase& other) throw() - : dismissed_(other.dismissed_) - { - other.Dismiss(); - } - - template <typename J> - static void SafeExecute(J& j) throw() - { - if (!j.dismissed_) - try - { - j.Execute(); - } - catch(...) +//////////////////////////////////////////////////////////////// +/// +/// \class ScopeGuardImplBase +/// \ingroup ExceptionGroup +/// +/// Base class used by all ScopeGuard implementations. All commonly used +/// functions are in this class (e.g. - Dismiss and SafeExecute). +/// +/// See Andrei's and Petru Marginean's CUJ article +/// http://www.cuj.com/documents/s=8000/cujcexp1812alexandr/alexandr.htm +/// +/// Changes to the original code by Joshua Lehrer: +/// http://www.lehrerfamily.com/scopeguard.html +//////////////////////////////////////////////////////////////// + +class ScopeGuardImplBase +{ + /// Copy-assignment operator is not implemented and private. + ScopeGuardImplBase& operator =(const ScopeGuardImplBase&); + +protected: + + ~ScopeGuardImplBase() + {} + + /// Copy-constructor takes over responsibility from other ScopeGuard. + ScopeGuardImplBase(const ScopeGuardImplBase& other) throw() + : dismissed_(other.dismissed_) + { + other.Dismiss(); + } + + template <typename J> + static void SafeExecute(J& j) throw() + { + if (!j.dismissed_) + try + { + j.Execute(); + } + catch(...) {} - } - - mutable bool dismissed_; - - public: - ScopeGuardImplBase() throw() : dismissed_(false) - {} - - void Dismiss() const throw() - { - dismissed_ = true; - } - }; - - //////////////////////////////////////////////////////////////// - /// - /// \typedef typedef const ScopeGuardImplBase& ScopeGuard - /// \ingroup ExceptionGroup - /// - //////////////////////////////////////////////////////////////// - - typedef const ScopeGuardImplBase& ScopeGuard; - - //////////////////////////////////////////////////////////////// - /// - /// \class ScopeGuardImpl0 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a standalone function or class static function - /// with no parameters. ScopeGuard ignores any value returned from the - /// call within the Execute function. - /// - /// This class has a single standalone helper function, MakeGuard which - /// creates and returns a ScopeGuard. - /// - //////////////////////////////////////////////////////////////// - - template <typename F> - class ScopeGuardImpl0 : public ScopeGuardImplBase - { - public: - static ScopeGuardImpl0<F> MakeGuard(F fun) - { - return ScopeGuardImpl0<F>(fun); - } - - ~ScopeGuardImpl0() throw() - { - SafeExecute(*this); - } - - void Execute() - { - fun_(); - } - - protected: - ScopeGuardImpl0(F fun) : fun_(fun) - {} - - F fun_; - }; - - template <typename F> - inline ScopeGuardImpl0<F> MakeGuard(F fun) - { - return ScopeGuardImpl0<F>::MakeGuard(fun); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ScopeGuardImpl1 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a standalone function or class static function - /// with one parameter. Each parameter is copied by value - use - /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores - /// any value returned from the call within the Execute function. - /// - /// This class has a single standalone helper function, MakeGuard which - /// creates and returns a ScopeGuard. - /// - //////////////////////////////////////////////////////////////// - - template <typename F, typename P1> - class ScopeGuardImpl1 : public ScopeGuardImplBase - { - public: - static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) - { - return ScopeGuardImpl1<F, P1>(fun, p1); - } - - ~ScopeGuardImpl1() throw() - { - SafeExecute(*this); - } - - void Execute() - { - fun_(p1_); - } - - protected: - ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1) - {} - - F fun_; - const P1 p1_; - }; - - template <typename F, typename P1> - inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) - { - return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ScopeGuardImpl2 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a standalone function or class static function - /// with two parameters. Each parameter is copied by value - use - /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores - /// any value returned from the call within the Execute function. - /// - /// This class has a single standalone helper function, MakeGuard which - /// creates and returns a ScopeGuard. - /// - //////////////////////////////////////////////////////////////// - - template <typename F, typename P1, typename P2> - class ScopeGuardImpl2: public ScopeGuardImplBase - { - public: - static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) - { - return ScopeGuardImpl2<F, P1, P2>(fun, p1, p2); - } - - ~ScopeGuardImpl2() throw() - { - SafeExecute(*this); - } - - void Execute() - { - fun_(p1_, p2_); - } - - protected: - ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2) - {} - - F fun_; - const P1 p1_; - const P2 p2_; - }; - - template <typename F, typename P1, typename P2> - inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) - { - return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ScopeGuardImpl3 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a standalone function or class static function - /// with three parameters. Each parameter is copied by value - use - /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores - /// any value returned from the call within the Execute function. - /// - /// This class has a single standalone helper function, MakeGuard which - /// creates and returns a ScopeGuard. - /// - //////////////////////////////////////////////////////////////// - - template <typename F, typename P1, typename P2, typename P3> - class ScopeGuardImpl3 : public ScopeGuardImplBase - { - public: - static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) - { - return ScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3); - } - - ~ScopeGuardImpl3() throw() - { - SafeExecute(*this); - } - - void Execute() - { - fun_(p1_, p2_, p3_); - } - - protected: - ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3) - {} - - F fun_; - const P1 p1_; - const P2 p2_; - const P3 p3_; - }; - - template <typename F, typename P1, typename P2, typename P3> - inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) - { - return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ScopeGuardImpl4 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a standalone function or class static function - /// with four parameters. Each parameter is copied by value - use - /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores - /// any value returned from the call within the Execute function. - /// - /// This class has a single standalone helper function, MakeGuard which - /// creates and returns a ScopeGuard. - /// - //////////////////////////////////////////////////////////////// - - template < typename F, typename P1, typename P2, typename P3, typename P4 > - class ScopeGuardImpl4 : public ScopeGuardImplBase - { - public: - static ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( - F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) - { - return ScopeGuardImpl4< F, P1, P2, P3, P4 >( fun, p1, p2, p3, p4 ); - } - - ~ScopeGuardImpl4() throw() - { - SafeExecute( *this ); - } - - void Execute() - { - fun_( p1_, p2_, p3_, p4_ ); - } - - protected: - ScopeGuardImpl4( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) : - fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ) - {} - - F fun_; - const P1 p1_; - const P2 p2_; - const P3 p3_; - const P4 p4_; - }; - - template < typename F, typename P1, typename P2, typename P3, typename P4 > - inline ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) - { - return ScopeGuardImpl4< F, P1, P2, P3, P4 >::MakeGuard( fun, p1, p2, p3, p4 ); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ScopeGuardImpl5 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a standalone function or class static function - /// with five parameters. Each parameter is copied by value - use - /// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores - /// any value returned from the call within the Execute function. - /// - /// This class has a single standalone helper function, MakeGuard which - /// creates and returns a ScopeGuard. - /// - //////////////////////////////////////////////////////////////// - - template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > - class ScopeGuardImpl5 : public ScopeGuardImplBase - { - public: - static ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( - F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) - { - return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >( fun, p1, p2, p3, p4, p5 ); - } - - ~ScopeGuardImpl5() throw() - { - SafeExecute( *this ); - } - - void Execute() - { - fun_( p1_, p2_, p3_, p4_, p5_ ); - } - - protected: - ScopeGuardImpl5( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) : - fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ), p5_( p5 ) - {} - - F fun_; - const P1 p1_; - const P2 p2_; - const P3 p3_; - const P4 p4_; - const P5 p5_; - }; - - template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > - inline ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) - { - return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >::MakeGuard( fun, p1, p2, p3, p4, p5 ); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ObjScopeGuardImpl0 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a class per-instance member function with no - /// parameters. ScopeGuard ignores any value returned from the call within - /// the Execute function. - /// - /// This class has 3 standalone helper functions which create a ScopeGuard. - /// One is MakeObjGuard, which is deprecated but provided for older code. - /// The other two are MakeGuard overloads, one which takes a pointer to an - /// object, and the other which takes a reference. - /// - //////////////////////////////////////////////////////////////// - - template <class Obj, typename MemFun> - class ObjScopeGuardImpl0 : public ScopeGuardImplBase - { - public: - static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) - { - return ObjScopeGuardImpl0<Obj, MemFun>(obj, memFun); - } - - ~ObjScopeGuardImpl0() throw() - { - SafeExecute(*this); - } - - void Execute() - { - (obj_.*memFun_)(); - } - - protected: - ObjScopeGuardImpl0(Obj& obj, MemFun memFun) : obj_(obj), memFun_(memFun) - {} - - Obj& obj_; - MemFun memFun_; - }; - - template <class Obj, typename MemFun> - inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) - { - return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun); - } - - template <typename Ret, class Obj1, class Obj2> - inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 &obj) - { - return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(obj,memFun); - } - - template <typename Ret, class Obj1, class Obj2> - inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1 *obj) - { - return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(*obj,memFun); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ObjScopeGuardImpl1 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a class per-instance member function with one - /// parameter. The parameter is copied by value - use ::Loki::ByRef if you - /// must use a reference instead. ScopeGuard ignores any value returned - /// from the call within the Execute function. - /// - /// This class has 3 standalone helper functions which create a ScopeGuard. - /// One is MakeObjGuard, which is deprecated but provided for older code. - /// The other two are MakeGuard overloads, one which takes a pointer to an - /// object, and the other which takes a reference. - /// - //////////////////////////////////////////////////////////////// - - template <class Obj, typename MemFun, typename P1> - class ObjScopeGuardImpl1 : public ScopeGuardImplBase - { - public: - static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) - { - return ObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1); - } + } + + mutable bool dismissed_; + +public: + ScopeGuardImplBase() throw() : dismissed_(false) + {} + + void Dismiss() const throw() + { + dismissed_ = true; + } +}; + +//////////////////////////////////////////////////////////////// +/// +/// \typedef typedef const ScopeGuardImplBase& ScopeGuard +/// \ingroup ExceptionGroup +/// +//////////////////////////////////////////////////////////////// + +typedef const ScopeGuardImplBase& ScopeGuard; + +//////////////////////////////////////////////////////////////// +/// +/// \class ScopeGuardImpl0 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a standalone function or class static function +/// with no parameters. ScopeGuard ignores any value returned from the +/// call within the Execute function. +/// +/// This class has a single standalone helper function, MakeGuard which +/// creates and returns a ScopeGuard. +/// +//////////////////////////////////////////////////////////////// + +template <typename F> +class ScopeGuardImpl0 : public ScopeGuardImplBase +{ +public: + static ScopeGuardImpl0<F> MakeGuard(F fun) + { + return ScopeGuardImpl0<F>(fun); + } - ~ObjScopeGuardImpl1() throw() - { - SafeExecute(*this); - } + ~ScopeGuardImpl0() throw() + { + SafeExecute(*this); + } + + void Execute() + { + fun_(); + } - void Execute() - { - (obj_.*memFun_)(p1_); - } +protected: + ScopeGuardImpl0(F fun) : fun_(fun) + {} - protected: - ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) : obj_(obj), memFun_(memFun), p1_(p1) - {} - - Obj& obj_; - MemFun memFun_; - const P1 p1_; - }; - - template <class Obj, typename MemFun, typename P1> - inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) - { - return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1); - } - - template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> - inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 &obj, P1b p1) + F fun_; +}; + +template <typename F> +inline ScopeGuardImpl0<F> MakeGuard(F fun) +{ + return ScopeGuardImpl0<F>::MakeGuard(fun); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ScopeGuardImpl1 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a standalone function or class static function +/// with one parameter. Each parameter is copied by value - use +/// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores +/// any value returned from the call within the Execute function. +/// +/// This class has a single standalone helper function, MakeGuard which +/// creates and returns a ScopeGuard. +/// +//////////////////////////////////////////////////////////////// + +template <typename F, typename P1> +class ScopeGuardImpl1 : public ScopeGuardImplBase +{ +public: + static ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) { - return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(obj,memFun,p1); - } - - template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> - inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1 *obj, P1b p1) - { - return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(*obj,memFun,p1); - } - - //////////////////////////////////////////////////////////////// - /// - /// \class ObjScopeGuardImpl2 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a class per-instance member function with two - /// parameters. Each parameter is copied by value - use ::Loki::ByRef if you - /// must use a reference instead. ScopeGuard ignores any value returned - /// from the call within the Execute function. - /// - /// This class has 3 standalone helper functions which create a ScopeGuard. - /// One is MakeObjGuard, which is deprecated but provided for older code. - /// The other two are MakeGuard overloads, one which takes a pointer to an - /// object, and the other which takes a reference. - /// - //////////////////////////////////////////////////////////////// - - template <class Obj, typename MemFun, typename P1, typename P2> - class ObjScopeGuardImpl2 : public ScopeGuardImplBase - { - public: - static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) - { - return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2); - } - - ~ObjScopeGuardImpl2() throw() - { - SafeExecute(*this); - } - - void Execute() - { - (obj_.*memFun_)(p1_, p2_); - } - - protected: - ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2) - {} - - Obj& obj_; - MemFun memFun_; - const P1 p1_; - const P2 p2_; - }; - - template <class Obj, typename MemFun, typename P1, typename P2> - inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) - { - return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2); - } + return ScopeGuardImpl1<F, P1>(fun, p1); + } - template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> - inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 &obj, P1b p1, P2b p2) - { - return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(obj,memFun,p1,p2); + ~ScopeGuardImpl1() throw() + { + SafeExecute(*this); } - - template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> - inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1 *obj, P1b p1, P2b p2) + + void Execute() { - return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(*obj,memFun,p1,p2); + fun_(p1_); } - //////////////////////////////////////////////////////////////// - /// - /// \class ObjScopeGuardImpl3 - /// \ingroup ExceptionGroup - /// - /// Implementation class for a class per-instance member function with three - /// parameters. Each parameter is copied by value - use ::Loki::ByRef if you - /// must use a reference instead. ScopeGuard ignores any value returned - /// from the call within the Execute function. - /// - /// This class has 3 standalone helper functions which create a ScopeGuard. - /// One is MakeObjGuard, which is deprecated but provided for older code. - /// The other two are MakeGuard overloads, one which takes a pointer to an - /// object, and the other which takes a reference. - /// - //////////////////////////////////////////////////////////////// +protected: + ScopeGuardImpl1(F fun, P1 p1) : fun_(fun), p1_(p1) + {} - template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > - class ObjScopeGuardImpl3 : public ScopeGuardImplBase + F fun_; + const P1 p1_; +}; + +template <typename F, typename P1> +inline ScopeGuardImpl1<F, P1> MakeGuard(F fun, P1 p1) +{ + return ScopeGuardImpl1<F, P1>::MakeGuard(fun, p1); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ScopeGuardImpl2 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a standalone function or class static function +/// with two parameters. Each parameter is copied by value - use +/// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores +/// any value returned from the call within the Execute function. +/// +/// This class has a single standalone helper function, MakeGuard which +/// creates and returns a ScopeGuard. +/// +//////////////////////////////////////////////////////////////// + +template <typename F, typename P1, typename P2> +class ScopeGuardImpl2: public ScopeGuardImplBase +{ +public: + static ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) { - public: - static ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( - Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) - { - return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >( obj, memFun, p1, p2, p3 ); - } + return ScopeGuardImpl2<F, P1, P2>(fun, p1, p2); + } - ~ObjScopeGuardImpl3() throw() - { - SafeExecute( *this ); - } - - void Execute() - { - ( obj_.*memFun_ )( p1_, p2_, p3_ ); - } - - protected: - ObjScopeGuardImpl3( Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) : - obj_( obj ), memFun_( memFun ), p1_( p1 ), p2_( p2 ), p3_( p3 ) - {} - - Obj& obj_; - MemFun memFun_; - const P1 p1_; - const P2 p2_; - const P3 p3_; - }; + ~ScopeGuardImpl2() throw() + { + SafeExecute(*this); + } - template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > - inline ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( - Obj & obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) + void Execute() + { + fun_(p1_, p2_); + } + +protected: + ScopeGuardImpl2(F fun, P1 p1, P2 p2) : fun_(fun), p1_(p1), p2_(p2) + {} + + F fun_; + const P1 p1_; + const P2 p2_; +}; + +template <typename F, typename P1, typename P2> +inline ScopeGuardImpl2<F, P1, P2> MakeGuard(F fun, P1 p1, P2 p2) +{ + return ScopeGuardImpl2<F, P1, P2>::MakeGuard(fun, p1, p2); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ScopeGuardImpl3 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a standalone function or class static function +/// with three parameters. Each parameter is copied by value - use +/// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores +/// any value returned from the call within the Execute function. +/// +/// This class has a single standalone helper function, MakeGuard which +/// creates and returns a ScopeGuard. +/// +//////////////////////////////////////////////////////////////// + +template <typename F, typename P1, typename P2, typename P3> +class ScopeGuardImpl3 : public ScopeGuardImplBase +{ +public: + static ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) + { + return ScopeGuardImpl3<F, P1, P2, P3>(fun, p1, p2, p3); + } + + ~ScopeGuardImpl3() throw() + { + SafeExecute(*this); + } + + void Execute() + { + fun_(p1_, p2_, p3_); + } + +protected: + ScopeGuardImpl3(F fun, P1 p1, P2 p2, P3 p3) : fun_(fun), p1_(p1), p2_(p2), p3_(p3) + {} + + F fun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; +}; + +template <typename F, typename P1, typename P2, typename P3> +inline ScopeGuardImpl3<F, P1, P2, P3> MakeGuard(F fun, P1 p1, P2 p2, P3 p3) +{ + return ScopeGuardImpl3<F, P1, P2, P3>::MakeGuard(fun, p1, p2, p3); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ScopeGuardImpl4 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a standalone function or class static function +/// with four parameters. Each parameter is copied by value - use +/// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores +/// any value returned from the call within the Execute function. +/// +/// This class has a single standalone helper function, MakeGuard which +/// creates and returns a ScopeGuard. +/// +//////////////////////////////////////////////////////////////// + +template < typename F, typename P1, typename P2, typename P3, typename P4 > +class ScopeGuardImpl4 : public ScopeGuardImplBase +{ +public: + static ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( + F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) + { + return ScopeGuardImpl4< F, P1, P2, P3, P4 >( fun, p1, p2, p3, p4 ); + } + + ~ScopeGuardImpl4() throw() + { + SafeExecute( *this ); + } + + void Execute() + { + fun_( p1_, p2_, p3_, p4_ ); + } + +protected: + ScopeGuardImpl4( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) : + fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ) + {} + + F fun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; + const P4 p4_; +}; + +template < typename F, typename P1, typename P2, typename P3, typename P4 > +inline ScopeGuardImpl4< F, P1, P2, P3, P4 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4 ) +{ + return ScopeGuardImpl4< F, P1, P2, P3, P4 >::MakeGuard( fun, p1, p2, p3, p4 ); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ScopeGuardImpl5 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a standalone function or class static function +/// with five parameters. Each parameter is copied by value - use +/// ::Loki::ByRef if you must use a reference instead. ScopeGuard ignores +/// any value returned from the call within the Execute function. +/// +/// This class has a single standalone helper function, MakeGuard which +/// creates and returns a ScopeGuard. +/// +//////////////////////////////////////////////////////////////// + +template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > +class ScopeGuardImpl5 : public ScopeGuardImplBase +{ +public: + static ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( + F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) { - return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >::MakeObjGuard( - obj, memFun, p1, p2, p3 ); + return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >( fun, p1, p2, p3, p4, p5 ); } - template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, - typename P2a, typename P2b, typename P3a, typename P3b > - inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > - MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 & obj, P1b p1, P2b p2, P3b p3 ) + ~ScopeGuardImpl5() throw() { - return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > - ::MakeObjGuard( obj, memFun, p1, p2, p3 ); + SafeExecute( *this ); } - template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, - typename P2a, typename P2b, typename P3a, typename P3b > - inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > - MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1 * obj, P1b p1, P2b p2, P3b p3 ) + void Execute() { - return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > - ::MakeObjGuard( *obj, memFun, p1, p2, p3 ); + fun_( p1_, p2_, p3_, p4_, p5_ ); } +protected: + ScopeGuardImpl5( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) : + fun_( fun ), p1_( p1 ), p2_( p2 ), p3_( p3 ), p4_( p4 ), p5_( p5 ) + {} + + F fun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; + const P4 p4_; + const P5 p5_; +}; + +template < typename F, typename P1, typename P2, typename P3, typename P4, typename P5 > +inline ScopeGuardImpl5< F, P1, P2, P3, P4, P5 > MakeGuard( F fun, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 ) +{ + return ScopeGuardImpl5< F, P1, P2, P3, P4, P5 >::MakeGuard( fun, p1, p2, p3, p4, p5 ); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ObjScopeGuardImpl0 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a class per-instance member function with no +/// parameters. ScopeGuard ignores any value returned from the call within +/// the Execute function. +/// +/// This class has 3 standalone helper functions which create a ScopeGuard. +/// One is MakeObjGuard, which is deprecated but provided for older code. +/// The other two are MakeGuard overloads, one which takes a pointer to an +/// object, and the other which takes a reference. +/// +//////////////////////////////////////////////////////////////// + +template <class Obj, typename MemFun> +class ObjScopeGuardImpl0 : public ScopeGuardImplBase +{ +public: + static ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) + { + return ObjScopeGuardImpl0<Obj, MemFun>(obj, memFun); + } + + ~ObjScopeGuardImpl0() throw() + { + SafeExecute(*this); + } + + void Execute() + { + (obj_.*memFun_)(); + } + +protected: + ObjScopeGuardImpl0(Obj& obj, MemFun memFun) : obj_(obj), memFun_(memFun) + {} + + Obj& obj_; + MemFun memFun_; +}; + +template <class Obj, typename MemFun> +inline ObjScopeGuardImpl0<Obj, MemFun> MakeObjGuard(Obj& obj, MemFun memFun) +{ + return ObjScopeGuardImpl0<Obj, MemFun>::MakeObjGuard(obj, memFun); +} + +template <typename Ret, class Obj1, class Obj2> +inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1& obj) +{ + return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(obj,memFun); +} + +template <typename Ret, class Obj1, class Obj2> +inline ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()> MakeGuard(Ret(Obj2::*memFun)(), Obj1* obj) +{ + return ObjScopeGuardImpl0<Obj1,Ret(Obj2::*)()>::MakeObjGuard(*obj,memFun); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ObjScopeGuardImpl1 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a class per-instance member function with one +/// parameter. The parameter is copied by value - use ::Loki::ByRef if you +/// must use a reference instead. ScopeGuard ignores any value returned +/// from the call within the Execute function. +/// +/// This class has 3 standalone helper functions which create a ScopeGuard. +/// One is MakeObjGuard, which is deprecated but provided for older code. +/// The other two are MakeGuard overloads, one which takes a pointer to an +/// object, and the other which takes a reference. +/// +//////////////////////////////////////////////////////////////// + +template <class Obj, typename MemFun, typename P1> +class ObjScopeGuardImpl1 : public ScopeGuardImplBase +{ +public: + static ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) + { + return ObjScopeGuardImpl1<Obj, MemFun, P1>(obj, memFun, p1); + } + + ~ObjScopeGuardImpl1() throw() + { + SafeExecute(*this); + } + + void Execute() + { + (obj_.*memFun_)(p1_); + } + +protected: + ObjScopeGuardImpl1(Obj& obj, MemFun memFun, P1 p1) : obj_(obj), memFun_(memFun), p1_(p1) + {} + + Obj& obj_; + MemFun memFun_; + const P1 p1_; +}; + +template <class Obj, typename MemFun, typename P1> +inline ObjScopeGuardImpl1<Obj, MemFun, P1> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1) +{ + return ObjScopeGuardImpl1<Obj, MemFun, P1>::MakeObjGuard(obj, memFun, p1); +} + +template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> +inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1& obj, P1b p1) +{ + return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(obj,memFun,p1); +} + +template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b> +inline ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b> MakeGuard(Ret(Obj2::*memFun)(P1a), Obj1* obj, P1b p1) +{ + return ObjScopeGuardImpl1<Obj1,Ret(Obj2::*)(P1a),P1b>::MakeObjGuard(*obj,memFun,p1); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ObjScopeGuardImpl2 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a class per-instance member function with two +/// parameters. Each parameter is copied by value - use ::Loki::ByRef if you +/// must use a reference instead. ScopeGuard ignores any value returned +/// from the call within the Execute function. +/// +/// This class has 3 standalone helper functions which create a ScopeGuard. +/// One is MakeObjGuard, which is deprecated but provided for older code. +/// The other two are MakeGuard overloads, one which takes a pointer to an +/// object, and the other which takes a reference. +/// +//////////////////////////////////////////////////////////////// + +template <class Obj, typename MemFun, typename P1, typename P2> +class ObjScopeGuardImpl2 : public ScopeGuardImplBase +{ +public: + static ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) + { + return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>(obj, memFun, p1, p2); + } + + ~ObjScopeGuardImpl2() throw() + { + SafeExecute(*this); + } + + void Execute() + { + (obj_.*memFun_)(p1_, p2_); + } + +protected: + ObjScopeGuardImpl2(Obj& obj, MemFun memFun, P1 p1, P2 p2) : obj_(obj), memFun_(memFun), p1_(p1), p2_(p2) + {} + + Obj& obj_; + MemFun memFun_; + const P1 p1_; + const P2 p2_; +}; + +template <class Obj, typename MemFun, typename P1, typename P2> +inline ObjScopeGuardImpl2<Obj, MemFun, P1, P2> MakeObjGuard(Obj& obj, MemFun memFun, P1 p1, P2 p2) +{ + return ObjScopeGuardImpl2<Obj, MemFun, P1, P2>::MakeObjGuard(obj, memFun, p1, p2); +} + +template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> +inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1& obj, P1b p1, P2b p2) +{ + return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(obj,memFun,p1,p2); +} + +template <typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, typename P2a, typename P2b> +inline ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b> MakeGuard(Ret(Obj2::*memFun)(P1a,P2a), Obj1* obj, P1b p1, P2b p2) +{ + return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(*obj,memFun,p1,p2); +} + +//////////////////////////////////////////////////////////////// +/// +/// \class ObjScopeGuardImpl3 +/// \ingroup ExceptionGroup +/// +/// Implementation class for a class per-instance member function with three +/// parameters. Each parameter is copied by value - use ::Loki::ByRef if you +/// must use a reference instead. ScopeGuard ignores any value returned +/// from the call within the Execute function. +/// +/// This class has 3 standalone helper functions which create a ScopeGuard. +/// One is MakeObjGuard, which is deprecated but provided for older code. +/// The other two are MakeGuard overloads, one which takes a pointer to an +/// object, and the other which takes a reference. +/// +//////////////////////////////////////////////////////////////// + +template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > +class ObjScopeGuardImpl3 : public ScopeGuardImplBase +{ +public: + static ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( + Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) + { + return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >( obj, memFun, p1, p2, p3 ); + } + + ~ObjScopeGuardImpl3() throw() + { + SafeExecute( *this ); + } + + void Execute() + { + ( obj_.*memFun_ )( p1_, p2_, p3_ ); + } + +protected: + ObjScopeGuardImpl3( Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) : + obj_( obj ), memFun_( memFun ), p1_( p1 ), p2_( p2 ), p3_( p3 ) + {} + + Obj& obj_; + MemFun memFun_; + const P1 p1_; + const P2 p2_; + const P3 p3_; +}; + +template < class Obj, typename MemFun, typename P1, typename P2, typename P3 > +inline ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 > MakeObjGuard( + Obj& obj, MemFun memFun, P1 p1, P2 p2, P3 p3 ) +{ + return ObjScopeGuardImpl3< Obj, MemFun, P1, P2, P3 >::MakeObjGuard( + obj, memFun, p1, p2, p3 ); +} + +template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, + typename P2a, typename P2b, typename P3a, typename P3b > +inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > +MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1& obj, P1b p1, P2b p2, P3b p3 ) +{ + return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > + ::MakeObjGuard( obj, memFun, p1, p2, p3 ); +} + +template < typename Ret, class Obj1, class Obj2, typename P1a, typename P1b, + typename P2a, typename P2b, typename P3a, typename P3b > +inline ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > +MakeGuard( Ret( Obj2::*memFun )( P1a, P2a, P3a ), Obj1* obj, P1b p1, P2b p2, P3b p3 ) +{ + return ObjScopeGuardImpl3< Obj1, Ret( Obj2::* )( P1a, P2a, P3a ), P1b, P2b, P3b > + ::MakeObjGuard( *obj, memFun, p1, p2, p3 ); +} + } // namespace Loki #define LOKI_CONCATENATE_DIRECT(s1, s2) s1##s2 |