SERVER-18579: Clang-Format - reformat code, no comment reflow

1 files changed, 342 insertions, 385 deletions

diff --git a/src/mongo/util/scopeguard.h b/src/mongo/util/scopeguard.h
index 9147e0fc72e..167db24c9b5 100644
--- a/src/mongo/util/scopeguard.h
+++ b/src/mongo/util/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_H_
@@ -17,415 +17,372 @@
 
 #include "mongo/platform/compiler.h"
 
-namespace mongo
-{
-
-    ////////////////////////////////////////////////////////////////////////////////
-    ///  \class RefToValue
-    ///
-    ///  Transports a reference as a value
-    ///  Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard
-    ////////////////////////////////////////////////////////////////////////////////
-
-    template <class T>
-        class RefToValue
-    {   
-    public:
-    
-    RefToValue(T& ref) : ref_(ref) 
-        {}
-
-    RefToValue(const RefToValue& rhs) : ref_(rhs.ref_)
-        {}
-
-        operator T& () const 
-        {
-            return ref_;
-        }
-
-    private:
-        // Disable - not implemented
-        RefToValue();
-        RefToValue& operator=(const RefToValue&);
-        
-        T& ref_;
-    };
-
-
-    ////////////////////////////////////////////////////////////////////////////////
-    ///  RefToValue creator.
-    ////////////////////////////////////////////////////////////////////////////////
-
-    template <class T>
-        inline RefToValue<T> ByRef(T& t)
-    {
-        return RefToValue<T>(t);
-    }  
-
-
-
-
-    ////////////////////////////////////////////
-    ///  ScopeGuard
-    /*
-      Trivial example for use:
-      
-      FILE* f = fopen("myfile.txt", "w+");
-      if (!f)
-          return error;
-      ON_BLOCK_EXIT(fclose, f);
-
-
-      More complicated example:
-
-      ScopeGuard guard = MakeGuard(my_rollback_func, myparam);
-      ...
-      if (successful) {
-         guard.Dismiss();
-         return;
-      }
-      // guard is still active here and will fire at scope exit
-      ...
-
-
-    */
-
-
-    class ScopeGuardImplBase
-    {
-        ScopeGuardImplBase& operator =(const ScopeGuardImplBase&);
-
-    protected:
-
-        ~ScopeGuardImplBase()
-        {}
-
-        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
-    ///
-    /// 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
-    ////////////////////////////////////////////////////////////////
-    
-    typedef const ScopeGuardImplBase& 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);
+namespace mongo {
+
+////////////////////////////////////////////////////////////////////////////////
+///  \class RefToValue
+///
+///  Transports a reference as a value
+///  Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+class RefToValue {
+public:
+    RefToValue(T& ref) : ref_(ref) {}
+
+    RefToValue(const RefToValue& rhs) : ref_(rhs.ref_) {}
+
+    operator T&() const {
+        return ref_;
+    }
+
+private:
+    // Disable - not implemented
+    RefToValue();
+    RefToValue& operator=(const RefToValue&);
+
+    T& ref_;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+///  RefToValue creator.
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+inline RefToValue<T> ByRef(T& t) {
+    return RefToValue<T>(t);
+}
+
+
+////////////////////////////////////////////
+///  ScopeGuard
+/*
+  Trivial example for use:
+
+  FILE* f = fopen("myfile.txt", "w+");
+  if (!f)
+      return error;
+  ON_BLOCK_EXIT(fclose, f);
+
+
+  More complicated example:
+
+  ScopeGuard guard = MakeGuard(my_rollback_func, myparam);
+  ...
+  if (successful) {
+     guard.Dismiss();
+     return;
+  }
+  // guard is still active here and will fire at scope exit
+  ...
+
+
+*/
+
+
+class ScopeGuardImplBase {
+    ScopeGuardImplBase& operator=(const ScopeGuardImplBase&);
+
+protected:
+    ~ScopeGuardImplBase() {}
+
+    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
+///
+/// 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
+////////////////////////////////////////////////////////////////
+
+typedef const ScopeGuardImplBase& 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);
+}
+
+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_);
     }
 
-    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);
+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);
+}
+
+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);
     }
 
-    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);
+    ~ScopeGuardImpl2() throw() {
+        SafeExecute(*this);
     }
 
-    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);
+    void Execute() {
+        fun_(p1_, p2_);
     }
 
-    //************************************************************
-
-    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);
+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);
+}
+
+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);
     }
 
-    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);
+    ~ScopeGuardImpl3() throw() {
+        SafeExecute(*this);
     }
 
-    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);
+    void Execute() {
+        fun_(p1_, p2_, p3_);
     }
 
-    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);
+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);
+}
+
+//************************************************************
+
+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);
     }
 
-    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);
+    ~ObjScopeGuardImpl0() throw() {
+        SafeExecute(*this);
     }
 
-    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);
+    void Execute() {
+        (obj_.*memFun_)();
     }
 
-    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);
+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);
+}
+
+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);
     }
 
-    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);
+    ~ObjScopeGuardImpl1() 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) 
-    {
-        return ObjScopeGuardImpl2<Obj1,Ret(Obj2::*)(P1a,P2a),P1b,P2b>::MakeObjGuard(*obj,memFun,p1,p2);
+    void Execute() {
+        (obj_.*memFun_)(p1_);
     }
 
-} // namespace Loki
+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);
+}
+
+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);
+    }
 
-#define LOKI_CONCATENATE_DIRECT(s1, s2)  s1##s2
-#define LOKI_CONCATENATE(s1, s2)         LOKI_CONCATENATE_DIRECT(s1, s2)
-#define LOKI_ANONYMOUS_VARIABLE(str)     LOKI_CONCATENATE(str, __LINE__)
+    ~ObjScopeGuardImpl2() throw() {
+        SafeExecute(*this);
+    }
+
+    void Execute() {
+        (obj_.*memFun_)(p1_, p2_);
+    }
 
-#define ON_BLOCK_EXIT                                                   \
+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);
+}
+
+}  // namespace Loki
+
+#define LOKI_CONCATENATE_DIRECT(s1, s2) s1##s2
+#define LOKI_CONCATENATE(s1, s2) LOKI_CONCATENATE_DIRECT(s1, s2)
+#define LOKI_ANONYMOUS_VARIABLE(str) LOKI_CONCATENATE(str, __LINE__)
+
+#define ON_BLOCK_EXIT \
     MONGO_COMPILER_VARIABLE_UNUSED ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = MakeGuard
 #define ON_BLOCK_EXIT_OBJ \
     MONGO_COMPILER_VARIABLE_UNUSED ScopeGuard LOKI_ANONYMOUS_VARIABLE(scopeGuard) = MakeObjGuard
 
-#endif //LOKI_SCOPEGUARD_H_
+#endif  // LOKI_SCOPEGUARD_H_