From 4f841af78da6aeeeed3557f40e5c00d06ff9ce3c Mon Sep 17 00:00:00 2001 From: avi Date: Tue, 23 Dec 2014 13:47:26 -0800 Subject: [PATCH] Revert of Revert "Update legacy Tuple-using code." (patchset #1 id:1 of https://codereview.chromium.org/826573002/) Reason for revert: The tests should have failed with this. Undoing the revert. Original issue's description: > Revert "Update legacy Tuple-using code." > > This reverts commit 12f4b98357b9dedc93cb546aac0aece2c8d9e850 > > BUG=440675, 444827 > > Committed: https://chromium.googlesource.com/chromium/src/+/85748694f2a119a057088f77f70b97f11607473c TBR= NOTREECHECKS=true NOTRY=true BUG=440675, 444827 Review URL: https://codereview.chromium.org/794073003 Cr-Commit-Position: refs/heads/master@{#309586} --- base/tuple.h | 65 - chrome/common/chrome_utility_messages.h | 6 +- ipc/ipc_message_macros.h | 35 +- ipc/ipc_message_utils.h | 116 +- sandbox/linux/seccomp-bpf/codegen.cc | 16 +- sandbox/linux/seccomp-bpf/codegen.h | 2 +- testing/generate_gmock_mutant.py | 57 +- testing/gmock_mutant.h | 2938 +++++++++++------------ 8 files changed, 1580 insertions(+), 1655 deletions(-) diff --git a/base/tuple.h b/base/tuple.h index a0d22454abde02..4408074335b3bd 100644 --- a/base/tuple.h +++ b/base/tuple.h @@ -124,71 +124,6 @@ struct TupleLeaf { T x; }; -// For legacy compatibility, we name the first 8 tuple elements "a", "b", ... -// TODO(mdempsky): Update users to use get() (crbug.com/440675). - -#define DEFINE_TUPLE_LEAF(N, x) \ - template \ - struct TupleLeaf { \ - TupleLeaf() {} \ - explicit TupleLeaf(typename TupleTraits::ParamType x) : x(x) {} \ - \ - T& get() { return x; } \ - const T& get() const { return x; } \ - \ - T x; \ - } - -DEFINE_TUPLE_LEAF(0, a); -DEFINE_TUPLE_LEAF(1, b); -DEFINE_TUPLE_LEAF(2, c); -DEFINE_TUPLE_LEAF(3, d); -DEFINE_TUPLE_LEAF(4, e); -DEFINE_TUPLE_LEAF(5, f); -DEFINE_TUPLE_LEAF(6, g); -DEFINE_TUPLE_LEAF(7, h); - -#undef DEFINE_TUPLE_LEAF - -// Deprecated compat aliases -// TODO(mdempsky): Update users to just use Tuple instead (crbug.com/440675). - -using Tuple0 = Tuple<>; -template -using Tuple1 = Tuple; -template -using Tuple2 = Tuple; -template -using Tuple3 = Tuple; -template -using Tuple4 = Tuple; -template -using Tuple5 = Tuple; -template -using Tuple6 = Tuple; -template -using Tuple7 = Tuple; -template -using Tuple8 = Tuple; - // Tuple getters -------------------------------------------------------------- // // Allows accessing an arbitrary tuple element by index. diff --git a/chrome/common/chrome_utility_messages.h b/chrome/common/chrome_utility_messages.h index b0d0eb20c3eb0e..b276d3891ef609 100644 --- a/chrome/common/chrome_utility_messages.h +++ b/chrome/common/chrome_utility_messages.h @@ -26,7 +26,7 @@ #ifndef CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_ #define CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_ -typedef std::vector > DecodedImages; +typedef std::vector> DecodedImages; #endif // CHROME_COMMON_CHROME_UTILITY_MESSAGES_H_ @@ -38,9 +38,9 @@ IPC_STRUCT_TRAITS_END() #if defined(OS_WIN) -// A vector of filters, each being a Tuple2 containing a display string (i.e. +// A vector of filters, each being a Tuple containing a display string (i.e. // "Text Files") and a filter pattern (i.e. "*.txt"). -typedef std::vector > +typedef std::vector> GetOpenFileNameFilter; IPC_STRUCT_BEGIN(ChromeUtilityMsg_GetSaveFileName_Params) diff --git a/ipc/ipc_message_macros.h b/ipc/ipc_message_macros.h index 20c83350733453..01789cbb6e3689 100644 --- a/ipc/ipc_message_macros.h +++ b/ipc/ipc_message_macros.h @@ -457,7 +457,7 @@ void (T::*func)(P*, TA)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, p.a); \ + (obj->*func)(parameter, get<0>(p)); \ return true; \ } \ return false; \ @@ -469,7 +469,7 @@ void (T::*func)(P*, TA, TB)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, p.a, p.b); \ + (obj->*func)(parameter, get<0>(p), get<1>(p)); \ return true; \ } \ return false; \ @@ -481,7 +481,7 @@ void (T::*func)(P*, TA, TB, TC)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, p.a, p.b, p.c); \ + (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p)); \ return true; \ } \ return false; \ @@ -494,7 +494,7 @@ void (T::*func)(P*, TA, TB, TC, TD)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, p.a, p.b, p.c, p.d); \ + (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p)); \ return true; \ } \ return false; \ @@ -507,7 +507,8 @@ void (T::*func)(P*, TA, TB, TC, TD, TE)) { \ Schema::Param p; \ if (Read(msg, &p)) { \ - (obj->*func)(parameter, p.a, p.b, p.c, p.d, p.e); \ + (obj->*func)(parameter, get<0>(p), get<1>(p), get<2>(p), get<3>(p), \ + get<4>(p)); \ return true; \ } \ return false; \ @@ -817,18 +818,18 @@ #define IPC_TYPE_OUT_3(t1, t2, t3) t1* arg6, t2* arg7, t3* arg8 #define IPC_TYPE_OUT_4(t1, t2, t3, t4) t1* arg6, t2* arg7, t3* arg8, t4* arg9 -#define IPC_TUPLE_IN_0() Tuple0 -#define IPC_TUPLE_IN_1(t1) Tuple1 -#define IPC_TUPLE_IN_2(t1, t2) Tuple2 -#define IPC_TUPLE_IN_3(t1, t2, t3) Tuple3 -#define IPC_TUPLE_IN_4(t1, t2, t3, t4) Tuple4 -#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5) Tuple5 - -#define IPC_TUPLE_OUT_0() Tuple0 -#define IPC_TUPLE_OUT_1(t1) Tuple1 -#define IPC_TUPLE_OUT_2(t1, t2) Tuple2 -#define IPC_TUPLE_OUT_3(t1, t2, t3) Tuple3 -#define IPC_TUPLE_OUT_4(t1, t2, t3, t4) Tuple4 +#define IPC_TUPLE_IN_0() Tuple<> +#define IPC_TUPLE_IN_1(t1) Tuple +#define IPC_TUPLE_IN_2(t1, t2) Tuple +#define IPC_TUPLE_IN_3(t1, t2, t3) Tuple +#define IPC_TUPLE_IN_4(t1, t2, t3, t4) Tuple +#define IPC_TUPLE_IN_5(t1, t2, t3, t4, t5) Tuple + +#define IPC_TUPLE_OUT_0() Tuple<> +#define IPC_TUPLE_OUT_1(t1) Tuple +#define IPC_TUPLE_OUT_2(t1, t2) Tuple +#define IPC_TUPLE_OUT_3(t1, t2, t3) Tuple +#define IPC_TUPLE_OUT_4(t1, t2, t3, t4) Tuple #define IPC_NAME_IN_0() MakeTuple() #define IPC_NAME_IN_1(t1) MakeRefTuple(arg1) diff --git a/ipc/ipc_message_utils.h b/ipc/ipc_message_utils.h index c78192a9c3d435..d4c6268ba0f6fd 100644 --- a/ipc/ipc_message_utils.h +++ b/ipc/ipc_message_utils.h @@ -520,8 +520,8 @@ struct IPC_EXPORT ParamTraits { }; template <> -struct ParamTraits { - typedef Tuple0 param_type; +struct ParamTraits> { + typedef Tuple<> param_type; static void Write(Message* m, const param_type& p) { } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { @@ -532,112 +532,112 @@ struct ParamTraits { }; template -struct ParamTraits< Tuple1 > { - typedef Tuple1 param_type; +struct ParamTraits> { + typedef Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, p.a); + WriteParam(m, get<0>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return ReadParam(m, iter, &r->a); + return ReadParam(m, iter, &get<0>(*r)); } static void Log(const param_type& p, std::string* l) { - LogParam(p.a, l); + LogParam(get<0>(p), l); } }; template -struct ParamTraits< Tuple2 > { - typedef Tuple2 param_type; +struct ParamTraits< Tuple > { + typedef Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, p.a); - WriteParam(m, p.b); + WriteParam(m, get<0>(p)); + WriteParam(m, get<1>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &r->a) && - ReadParam(m, iter, &r->b)); + return (ReadParam(m, iter, &get<0>(*r)) && + ReadParam(m, iter, &get<1>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(p.a, l); + LogParam(get<0>(p), l); l->append(", "); - LogParam(p.b, l); + LogParam(get<1>(p), l); } }; template -struct ParamTraits< Tuple3 > { - typedef Tuple3 param_type; +struct ParamTraits< Tuple > { + typedef Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, p.a); - WriteParam(m, p.b); - WriteParam(m, p.c); + WriteParam(m, get<0>(p)); + WriteParam(m, get<1>(p)); + WriteParam(m, get<2>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &r->a) && - ReadParam(m, iter, &r->b) && - ReadParam(m, iter, &r->c)); + return (ReadParam(m, iter, &get<0>(*r)) && + ReadParam(m, iter, &get<1>(*r)) && + ReadParam(m, iter, &get<2>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(p.a, l); + LogParam(get<0>(p), l); l->append(", "); - LogParam(p.b, l); + LogParam(get<1>(p), l); l->append(", "); - LogParam(p.c, l); + LogParam(get<2>(p), l); } }; template -struct ParamTraits< Tuple4 > { - typedef Tuple4 param_type; +struct ParamTraits< Tuple > { + typedef Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, p.a); - WriteParam(m, p.b); - WriteParam(m, p.c); - WriteParam(m, p.d); + WriteParam(m, get<0>(p)); + WriteParam(m, get<1>(p)); + WriteParam(m, get<2>(p)); + WriteParam(m, get<3>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &r->a) && - ReadParam(m, iter, &r->b) && - ReadParam(m, iter, &r->c) && - ReadParam(m, iter, &r->d)); + return (ReadParam(m, iter, &get<0>(*r)) && + ReadParam(m, iter, &get<1>(*r)) && + ReadParam(m, iter, &get<2>(*r)) && + ReadParam(m, iter, &get<3>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(p.a, l); + LogParam(get<0>(p), l); l->append(", "); - LogParam(p.b, l); + LogParam(get<1>(p), l); l->append(", "); - LogParam(p.c, l); + LogParam(get<2>(p), l); l->append(", "); - LogParam(p.d, l); + LogParam(get<3>(p), l); } }; template -struct ParamTraits< Tuple5 > { - typedef Tuple5 param_type; +struct ParamTraits< Tuple > { + typedef Tuple param_type; static void Write(Message* m, const param_type& p) { - WriteParam(m, p.a); - WriteParam(m, p.b); - WriteParam(m, p.c); - WriteParam(m, p.d); - WriteParam(m, p.e); + WriteParam(m, get<0>(p)); + WriteParam(m, get<1>(p)); + WriteParam(m, get<2>(p)); + WriteParam(m, get<3>(p)); + WriteParam(m, get<4>(p)); } static bool Read(const Message* m, PickleIterator* iter, param_type* r) { - return (ReadParam(m, iter, &r->a) && - ReadParam(m, iter, &r->b) && - ReadParam(m, iter, &r->c) && - ReadParam(m, iter, &r->d) && - ReadParam(m, iter, &r->e)); + return (ReadParam(m, iter, &get<0>(*r)) && + ReadParam(m, iter, &get<1>(*r)) && + ReadParam(m, iter, &get<2>(*r)) && + ReadParam(m, iter, &get<3>(*r)) && + ReadParam(m, iter, &get<4>(*r))); } static void Log(const param_type& p, std::string* l) { - LogParam(p.a, l); + LogParam(get<0>(p), l); l->append(", "); - LogParam(p.b, l); + LogParam(get<1>(p), l); l->append(", "); - LogParam(p.c, l); + LogParam(get<2>(p), l); l->append(", "); - LogParam(p.d, l); + LogParam(get<3>(p), l); l->append(", "); - LogParam(p.e, l); + LogParam(get<4>(p), l); } }; @@ -912,7 +912,7 @@ class SyncMessageSchema { Method func) { Message* reply = SyncMessage::GenerateReply(msg); if (ok) { - Tuple1 t = MakeRefTuple(*reply); + Tuple t = MakeRefTuple(*reply); ConnectMessageAndReply(msg, reply); DispatchToMethod(obj, func, send_params, &t); } else { diff --git a/sandbox/linux/seccomp-bpf/codegen.cc b/sandbox/linux/seccomp-bpf/codegen.cc index df9676017a07a1..055aa71e11c743 100644 --- a/sandbox/linux/seccomp-bpf/codegen.cc +++ b/sandbox/linux/seccomp-bpf/codegen.cc @@ -145,14 +145,14 @@ size_t CodeGen::Offset(Node target) const { // TODO(mdempsky): Move into a general base::Tuple helper library. bool CodeGen::MemoKeyLess::operator()(const MemoKey& lhs, const MemoKey& rhs) const { - if (lhs.a != rhs.a) - return lhs.a < rhs.a; - if (lhs.b != rhs.b) - return lhs.b < rhs.b; - if (lhs.c != rhs.c) - return lhs.c < rhs.c; - if (lhs.d != rhs.d) - return lhs.d < rhs.d; + if (get<0>(lhs) != get<0>(rhs)) + return get<0>(lhs) < get<0>(rhs); + if (get<1>(lhs) != get<1>(rhs)) + return get<1>(lhs) < get<1>(rhs); + if (get<2>(lhs) != get<2>(rhs)) + return get<2>(lhs) < get<2>(rhs); + if (get<3>(lhs) != get<3>(rhs)) + return get<3>(lhs) < get<3>(rhs); return false; } diff --git a/sandbox/linux/seccomp-bpf/codegen.h b/sandbox/linux/seccomp-bpf/codegen.h index e67966471a4ac1..ef04a5db4c5442 100644 --- a/sandbox/linux/seccomp-bpf/codegen.h +++ b/sandbox/linux/seccomp-bpf/codegen.h @@ -81,7 +81,7 @@ class SANDBOX_EXPORT CodeGen { void Compile(Node head, Program* program); private: - using MemoKey = Tuple4; + using MemoKey = Tuple; struct MemoKeyLess { bool operator()(const MemoKey& lhs, const MemoKey& rhs) const; }; diff --git a/testing/generate_gmock_mutant.py b/testing/generate_gmock_mutant.py index 6d814f082970c7..a6ee4c3cd3a967 100755 --- a/testing/generate_gmock_mutant.py +++ b/testing/generate_gmock_mutant.py @@ -56,8 +56,8 @@ // } // // void QuitMessageLoop(int seconds) { -// MessageLoop* loop = MessageLoop::current(); -// loop->PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(), +// base::MessageLoop* loop = base::MessageLoop::current(); +// loop->PostDelayedTask(FROM_HERE, base::MessageLoop::QuitClosure(), // 1000 * seconds); // } // }; @@ -202,7 +202,7 @@ class MutantLateObjectBind : public MutantRunner { } inline R operator()() { - return impl_->RunWithParams(Tuple0()); + return impl_->RunWithParams(Tuple<>()); } template @@ -241,8 +241,8 @@ class MutantLateObjectBind : public MutantRunner { # Templates for DispatchToMethod/DispatchToFunction functions. # template_params - typename P1, typename P2.. typename C1.. -# prebound - TupleN -# calltime - TupleN +# prebound - Tuple +# calltime - Tuple # args - p.a, p.b.., c.a, c.b.. DISPATCH_TO_METHOD_TEMPLATE = """\ template @@ -264,8 +264,8 @@ class MutantLateObjectBind : public MutantRunner { # Templates for CreateFunctor functions. # template_params - typename P1, typename P2.. typename C1.. typename X1.. -# prebound - TupleN -# calltime - TupleN +# prebound - Tuple +# calltime - Tuple # params - X1,.. , A1, .. # args - const P1& p1 .. # call_args - p1, p2, p3.. @@ -305,7 +305,7 @@ def SplitLine(line, width): return (line[:n], line[n + 1:]) -def Wrap(s, width, subsequent_offset=4): +def Wrap(s, width, subsequent_offset): """Wraps a single line |s| at commas so every line is at most |width| characters long. """ @@ -324,10 +324,8 @@ def Clean(s): Our simple string formatting/concatenation may introduce extra commas. """ - s = s.replace("<>", "") s = s.replace(", >", ">") s = s.replace(", )", ")") - s = s.replace(">>", "> >") return s @@ -339,23 +337,13 @@ def ExpandPattern(pattern, it): return [pattern.replace("%", x) for x in it] -def Gen(pattern, n): - """Expands pattern replacing '%' with sequential integers. +def Gen(pattern, n, start): + """Expands pattern replacing '%' with sequential integers starting with start. Expanded patterns will be joined with comma separator. - GenAlphs("X%", 3) will return "X1, X2, X3". + Gen("X%", 3, 1) will return "X1, X2, X3". """ - it = string.hexdigits[1:n + 1] - return ", ".join(ExpandPattern(pattern, it)) - - -def GenAlpha(pattern, n): - """Expands pattern replacing '%' with sequential small ASCII letters. - - Expanded patterns will be joined with comma separator. - GenAlphs("X%", 3) will return "Xa, Xb, Xc". - """ - it = string.ascii_lowercase[0:n] + it = string.hexdigits[start:n + start] return ", ".join(ExpandPattern(pattern, it)) @@ -364,7 +352,7 @@ def Merge(a): def GenTuple(pattern, n): - return Clean("Tuple%d<%s>" % (n, Gen(pattern, n))) + return Clean("Tuple<%s>" % (Gen(pattern, n, 1))) def FixCode(s): @@ -378,11 +366,12 @@ def FixCode(s): def GenerateDispatch(prebound, calltime): print "\n// %d - %d" % (prebound, calltime) args = { - "template_params": Merge([Gen("typename P%", prebound), - Gen("typename C%", calltime)]), + "template_params": Merge([Gen("typename P%", prebound, 1), + Gen("typename C%", calltime, 1)]), "prebound": GenTuple("P%", prebound), "calltime": GenTuple("C%", calltime), - "args": Merge([GenAlpha("p.%", prebound), GenAlpha("c.%", calltime)]), + "args": Merge([Gen("get<%>(p)", prebound, 0), + Gen("get<%>(c)", calltime, 0)]), } print FixCode(DISPATCH_TO_METHOD_TEMPLATE % args) @@ -394,12 +383,12 @@ def GenerateCreateFunctor(prebound, calltime): args = { "calltime": GenTuple("A%", calltime), "prebound": GenTuple("P%", prebound), - "params": Merge([Gen("X%", prebound), Gen("A%", calltime)]), - "args": Gen("const P%& p%", prebound), - "call_args": Gen("p%", prebound), - "template_params": Merge([Gen("typename P%", prebound), - Gen("typename A%", calltime), - Gen("typename X%", prebound)]) + "params": Merge([Gen("X%", prebound, 1), Gen("A%", calltime, 1)]), + "args": Gen("const P%& p%", prebound, 1), + "call_args": Gen("p%", prebound, 1), + "template_params": Merge([Gen("typename P%", prebound, 1), + Gen("typename A%", calltime, 1), + Gen("typename X%", prebound, 1)]) } mutant = FixCode(CREATE_METHOD_FUNCTOR_TEMPLATE % args) diff --git a/testing/gmock_mutant.h b/testing/gmock_mutant.h index 90d303efec3b58..964d56b3388ac8 100644 --- a/testing/gmock_mutant.h +++ b/testing/gmock_mutant.h @@ -111,306 +111,306 @@ namespace testing { // 0 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple0& p, - const Tuple0& c) { + const Tuple<>& p, + const Tuple<>& c) { return (obj->*method)(); } template inline R DispatchToFunction(Function function, - const Tuple0& p, - const Tuple0& c) { + const Tuple<>& p, + const Tuple<>& c) { return (*function)(); } // 0 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple0& p, - const Tuple1& c) { - return (obj->*method)(c.a); + const Tuple<>& p, + const Tuple& c) { + return (obj->*method)(get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple0& p, - const Tuple1& c) { - return (*function)(c.a); + const Tuple<>& p, + const Tuple& c) { + return (*function)(get<0>(c)); } // 0 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple0& p, - const Tuple2& c) { - return (obj->*method)(c.a, c.b); + const Tuple<>& p, + const Tuple& c) { + return (obj->*method)(get<0>(c), get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple0& p, - const Tuple2& c) { - return (*function)(c.a, c.b); + const Tuple<>& p, + const Tuple& c) { + return (*function)(get<0>(c), get<1>(c)); } // 0 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple0& p, - const Tuple3& c) { - return (obj->*method)(c.a, c.b, c.c); + const Tuple<>& p, + const Tuple& c) { + return (obj->*method)(get<0>(c), get<1>(c), get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple0& p, - const Tuple3& c) { - return (*function)(c.a, c.b, c.c); + const Tuple<>& p, + const Tuple& c) { + return (*function)(get<0>(c), get<1>(c), get<2>(c)); } // 0 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple0& p, - const Tuple4& c) { - return (obj->*method)(c.a, c.b, c.c, c.d); + const Tuple<>& p, + const Tuple& c) { + return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple0& p, - const Tuple4& c) { - return (*function)(c.a, c.b, c.c, c.d); + const Tuple<>& p, + const Tuple& c) { + return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } // 0 - 5 template inline R DispatchToMethod(T* obj, Method method, - const Tuple0& p, - const Tuple5& c) { - return (obj->*method)(c.a, c.b, c.c, c.d, c.e); + const Tuple<>& p, + const Tuple& c) { + return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple0& p, - const Tuple5& c) { - return (*function)(c.a, c.b, c.c, c.d, c.e); + const Tuple<>& p, + const Tuple& c) { + return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } // 0 - 6 template inline R DispatchToMethod(T* obj, Method method, - const Tuple0& p, - const Tuple6& c) { - return (obj->*method)(c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple<>& p, + const Tuple& c) { + return (obj->*method)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple0& p, - const Tuple6& c) { - return (*function)(c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple<>& p, + const Tuple& c) { + return (*function)(get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } // 1 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple1& p, - const Tuple0& c) { - return (obj->*method)(p.a); + const Tuple& p, + const Tuple<>& c) { + return (obj->*method)(get<0>(p)); } template inline R DispatchToFunction(Function function, - const Tuple1& p, - const Tuple0& c) { - return (*function)(p.a); + const Tuple& p, + const Tuple<>& c) { + return (*function)(get<0>(p)); } // 1 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple1& p, - const Tuple1& c) { - return (obj->*method)(p.a, c.a); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple1& p, - const Tuple1& c) { - return (*function)(p.a, c.a); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<0>(c)); } // 1 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple1& p, - const Tuple2& c) { - return (obj->*method)(p.a, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<0>(c), get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple1& p, - const Tuple2& c) { - return (*function)(p.a, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<0>(c), get<1>(c)); } // 1 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple1& p, - const Tuple3& c) { - return (obj->*method)(p.a, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple1& p, - const Tuple3& c) { - return (*function)(p.a, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c)); } // 1 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple1& p, - const Tuple4& c) { - return (obj->*method)(p.a, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple1& p, - const Tuple4& c) { - return (*function)(p.a, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } // 1 - 5 template inline R DispatchToMethod(T* obj, Method method, - const Tuple1& p, - const Tuple5& c) { - return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple1& p, - const Tuple5& c) { - return (*function)(p.a, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } // 1 - 6 template inline R DispatchToMethod(T* obj, Method method, - const Tuple1& p, - const Tuple6& c) { - return (obj->*method)(p.a, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple1& p, - const Tuple6& c) { - return (*function)(p.a, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } // 2 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple2& p, - const Tuple0& c) { - return (obj->*method)(p.a, p.b); + const Tuple& p, + const Tuple<>& c) { + return (obj->*method)(get<0>(p), get<1>(p)); } template inline R DispatchToFunction(Function function, - const Tuple2& p, - const Tuple0& c) { - return (*function)(p.a, p.b); + const Tuple& p, + const Tuple<>& c) { + return (*function)(get<0>(p), get<1>(p)); } // 2 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple2& p, - const Tuple1& c) { - return (obj->*method)(p.a, p.b, c.a); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple2& p, - const Tuple1& c) { - return (*function)(p.a, p.b, c.a); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<0>(c)); } // 2 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple2& p, - const Tuple2& c) { - return (obj->*method)(p.a, p.b, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple2& p, - const Tuple2& c) { - return (*function)(p.a, p.b, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c)); } // 2 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple2& p, - const Tuple3& c) { - return (obj->*method)(p.a, p.b, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple2& p, - const Tuple3& c) { - return (*function)(p.a, p.b, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c)); } // 2 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple2& p, - const Tuple4& c) { - return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple2& p, - const Tuple4& c) { - return (*function)(p.a, p.b, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } // 2 - 5 template inline R DispatchToMethod(T* obj, Method method, - const Tuple2& p, - const Tuple5& c) { - return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple2& p, - const Tuple5& c) { - return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } // 2 - 6 @@ -418,95 +418,95 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple2& p, - const Tuple6& c) { - return (obj->*method)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple2& p, - const Tuple6& c) { - return (*function)(p.a, p.b, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } // 3 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple3& p, - const Tuple0& c) { - return (obj->*method)(p.a, p.b, p.c); + const Tuple& p, + const Tuple<>& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p)); } template inline R DispatchToFunction(Function function, - const Tuple3& p, - const Tuple0& c) { - return (*function)(p.a, p.b, p.c); + const Tuple& p, + const Tuple<>& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p)); } // 3 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple3& p, - const Tuple1& c) { - return (obj->*method)(p.a, p.b, p.c, c.a); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple3& p, - const Tuple1& c) { - return (*function)(p.a, p.b, p.c, c.a); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c)); } // 3 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple3& p, - const Tuple2& c) { - return (obj->*method)(p.a, p.b, p.c, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple3& p, - const Tuple2& c) { - return (*function)(p.a, p.b, p.c, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c)); } // 3 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple3& p, - const Tuple3& c) { - return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple3& p, - const Tuple3& c) { - return (*function)(p.a, p.b, p.c, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c)); } // 3 - 4 template inline R DispatchToMethod(T* obj, Method method, - const Tuple3& p, - const Tuple4& c) { - return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple3& p, - const Tuple4& c) { - return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } // 3 - 5 @@ -514,16 +514,16 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple3& p, - const Tuple5& c) { - return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple3& p, - const Tuple5& c) { - return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } // 3 - 6 @@ -531,81 +531,81 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple3& p, - const Tuple6& c) { - return (obj->*method)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple3& p, - const Tuple6& c) { - return (*function)(p.a, p.b, p.c, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } // 4 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple4& p, - const Tuple0& c) { - return (obj->*method)(p.a, p.b, p.c, p.d); + const Tuple& p, + const Tuple<>& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p)); } template inline R DispatchToFunction(Function function, - const Tuple4& p, - const Tuple0& c) { - return (*function)(p.a, p.b, p.c, p.d); + const Tuple& p, + const Tuple<>& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p)); } // 4 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple4& p, - const Tuple1& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, c.a); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple4& p, - const Tuple1& c) { - return (*function)(p.a, p.b, p.c, p.d, c.a); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c)); } // 4 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple4& p, - const Tuple2& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple4& p, - const Tuple2& c) { - return (*function)(p.a, p.b, p.c, p.d, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c)); } // 4 - 3 template inline R DispatchToMethod(T* obj, Method method, - const Tuple4& p, - const Tuple3& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple4& p, - const Tuple3& c) { - return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c)); } // 4 - 4 @@ -613,16 +613,16 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple4& p, - const Tuple4& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple4& p, - const Tuple4& c) { - return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } // 4 - 5 @@ -630,17 +630,17 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple4& p, - const Tuple5& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple4& p, - const Tuple5& c) { - return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } // 4 - 6 @@ -648,65 +648,65 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple4& p, - const Tuple6& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple4& p, - const Tuple6& c) { - return (*function)(p.a, p.b, p.c, p.d, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } // 5 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple5& p, - const Tuple0& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e); + const Tuple& p, + const Tuple<>& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p)); } template inline R DispatchToFunction(Function function, - const Tuple5& p, - const Tuple0& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e); + const Tuple& p, + const Tuple<>& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p)); } // 5 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple5& p, - const Tuple1& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple5& p, - const Tuple1& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, c.a); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c)); } // 5 - 2 template inline R DispatchToMethod(T* obj, Method method, - const Tuple5& p, - const Tuple2& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple5& p, - const Tuple2& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c)); } // 5 - 3 @@ -714,16 +714,16 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple5& p, - const Tuple3& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple5& p, - const Tuple3& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c)); } // 5 - 4 @@ -731,17 +731,17 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple5& p, - const Tuple4& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple5& p, - const Tuple4& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } // 5 - 5 @@ -749,17 +749,17 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple5& p, - const Tuple5& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple5& p, - const Tuple5& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } // 5 - 6 @@ -767,49 +767,49 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple5& p, - const Tuple6& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple5& p, - const Tuple6& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } // 6 - 0 template inline R DispatchToMethod(T* obj, Method method, - const Tuple6& p, - const Tuple0& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f); + const Tuple& p, + const Tuple<>& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p)); } template inline R DispatchToFunction(Function function, - const Tuple6& p, - const Tuple0& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, p.f); + const Tuple& p, + const Tuple<>& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p)); } // 6 - 1 template inline R DispatchToMethod(T* obj, Method method, - const Tuple6& p, - const Tuple1& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c)); } template inline R DispatchToFunction(Function function, - const Tuple6& p, - const Tuple1& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c)); } // 6 - 2 @@ -817,16 +817,16 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple6& p, - const Tuple2& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c)); } template inline R DispatchToFunction(Function function, - const Tuple6& p, - const Tuple2& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c)); } // 6 - 3 @@ -834,17 +834,17 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple6& p, - const Tuple3& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c)); } template inline R DispatchToFunction(Function function, - const Tuple6& p, - const Tuple3& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c)); } // 6 - 4 @@ -852,17 +852,17 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple6& p, - const Tuple4& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } template inline R DispatchToFunction(Function function, - const Tuple6& p, - const Tuple4& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c)); } // 6 - 5 @@ -870,17 +870,17 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple6& p, - const Tuple5& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } template inline R DispatchToFunction(Function function, - const Tuple6& p, - const Tuple5& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c)); } // 6 - 6 @@ -888,17 +888,17 @@ template inline R DispatchToMethod(T* obj, Method method, - const Tuple6& p, - const Tuple6& c) { - return (obj->*method)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (obj->*method)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } template inline R DispatchToFunction(Function function, - const Tuple6& p, - const Tuple6& c) { - return (*function)(p.a, p.b, p.c, p.d, p.e, p.f, c.a, c.b, c.c, c.d, c.e, c.f); + const Tuple& p, + const Tuple& c) { + return (*function)(get<0>(p), get<1>(p), get<2>(p), get<3>(p), get<4>(p), get<5>(p), get<0>(c), get<1>(c), get<2>(c), get<3>(c), get<4>(c), get<5>(c)); } // Interface that is exposed to the consumer, that does the actual calling @@ -984,7 +984,7 @@ struct MutantFunctor { } inline R operator()() { - return impl_->RunWithParams(Tuple0()); + return impl_->RunWithParams(Tuple<>()); } template @@ -1017,198 +1017,198 @@ struct MutantFunctor { // 0 - 0 template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)()) { - MutantRunner* t = + MutantRunner>* t = new Mutant + Tuple<>, Tuple<>> (obj, method, MakeTuple()); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (*function)()) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction + Tuple<>, Tuple<>> (function, MakeTuple()); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)()) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind + Tuple<>, Tuple<>> (obj, method, MakeTuple()); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)()) { - MutantRunner* t = + MutantRunner>* t = new Mutant + Tuple<>, Tuple<>> (obj, method, MakeTuple()); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (__stdcall *function)()) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction + Tuple<>, Tuple<>> (function, MakeTuple()); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)()) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind + Tuple<>, Tuple<>> (obj, method, MakeTuple()); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) // 0 - 1 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(A1)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) // 0 - 2 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1216,69 +1216,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2)) { // 0 - 3 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1286,69 +1286,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3)) { // 0 - 4 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3, A4)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1356,71 +1356,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4)) { // 0 - 5 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3, A4, A5)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1428,137 +1428,137 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5)) { // 0 - 6 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(A1, A2, A3, A4, A5, A6)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner >* t = + MutantRunner>* t = new Mutant > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(A1, A2, A3, A4, A5, A6)) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction > + Tuple<>, Tuple> (function, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(A1, A2, A3, A4, A5, A6)) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind > + Tuple<>, Tuple> (obj, method, MakeTuple()); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) // 1 - 0 template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1), const P1& p1) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (*function)(X1), const P1& p1) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1), const P1& p1) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1), const P1& p1) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1), const P1& p1) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1566,69 +1566,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1), const P1& p1) { // 1 - 1 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1636,69 +1636,69 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1), const P1& p1) { // 1 - 2 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1706,71 +1706,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2), const P1& p1) { // 1 - 3 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1778,73 +1778,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3), const P1& p1) { // 1 - 4 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1852,73 +1852,73 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4), // 1 - 5 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -1927,39 +1927,39 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -1967,39 +1967,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, A1, A2, A3, A4, A5, A6), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6), const P1& p1) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2007,71 +2007,71 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, A1, A2, A3, A4, A5, A6), // 2 - 0 template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1, const P2& p2) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2079,74 +2079,74 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2), const P1& p1, // 2 - 1 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2154,76 +2154,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1), const P1& p1, // 2 - 2 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2231,76 +2231,76 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2), const P1& p1, // 2 - 3 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2309,40 +2309,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2350,39 +2350,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2391,40 +2391,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2432,39 +2432,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2473,41 +2473,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2515,40 +2515,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2556,77 +2556,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, A1, A2, A3, A4, A5, A6), // 3 - 0 template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2634,77 +2634,77 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3), const P1& p1, // 3 - 1 template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #if defined (OS_WIN) && !defined (ARCH_CPU_X86_64) template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2713,40 +2713,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2754,39 +2754,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2795,40 +2795,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2836,39 +2836,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2877,41 +2877,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -2919,40 +2919,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -2961,41 +2961,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3003,40 +3003,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3045,41 +3045,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3087,40 +3087,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3129,40 +3129,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, A1, A2, A3, A4, A5, template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3170,39 +3170,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4), const P1& p1, template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3211,40 +3211,40 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3252,39 +3252,39 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3293,41 +3293,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3335,40 +3335,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3377,41 +3377,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3419,40 +3419,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3461,41 +3461,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3503,40 +3503,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3546,27 +3546,27 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3574,14 +3574,14 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3590,41 +3590,41 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3634,27 +3634,27 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3662,14 +3662,14 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3678,41 +3678,41 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3721,41 +3721,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, A1, A2, A3, A4, template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3763,40 +3763,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5), const P1& p1, template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3805,41 +3805,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3847,40 +3847,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3889,41 +3889,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1), template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -3931,40 +3931,40 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -3974,27 +3974,27 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4002,14 +4002,14 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4018,41 +4018,41 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4062,27 +4062,27 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4090,14 +4090,14 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4106,43 +4106,43 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4152,28 +4152,28 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4181,14 +4181,14 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4197,44 +4197,44 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4244,29 +4244,29 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4274,15 +4274,15 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4291,45 +4291,45 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4338,41 +4338,41 @@ CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, A1, A2, A3, template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4380,42 +4380,42 @@ CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner* t = + MutantRunner>* t = new Mutant, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor(t); + return MutantFunctor>(t); } template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner* t = + MutantRunner>* t = new MutantFunction, Tuple0> + Tuple, Tuple<>> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple0> + Tuple, Tuple<>> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4425,27 +4425,27 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4453,14 +4453,14 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4469,43 +4469,43 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple1 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple1 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4515,28 +4515,28 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4544,15 +4544,15 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4561,44 +4561,44 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple2 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple2 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4608,29 +4608,29 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4638,15 +4638,15 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4655,45 +4655,45 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple3 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple3 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4703,30 +4703,30 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4734,15 +4734,15 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4751,45 +4751,45 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple4 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple4 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4799,30 +4799,30 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4830,15 +4830,15 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4847,45 +4847,45 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple5 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple5 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64) @@ -4896,30 +4896,30 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (*function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4928,15 +4928,15 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING @@ -4946,30 +4946,30 @@ template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T* obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new Mutant, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(R (__stdcall *function)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantFunction, Tuple6 > + Tuple, Tuple> (function, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #ifdef GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING template -inline MutantFunctor > +inline MutantFunctor> CreateFunctor(T** obj, R (__stdcall U::*method)(X1, X2, X3, X4, X5, X6, A1, A2, A3, A4, A5, A6), const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6) { - MutantRunner >* t = + MutantRunner>* t = new MutantLateObjectBind, Tuple6 > + Tuple, Tuple> (obj, method, MakeTuple(p1, p2, p3, p4, p5, p6)); - return MutantFunctor >(t); + return MutantFunctor>(t); } #endif // GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING #endif // defined (OS_WIN) && !defined (ARCH_CPU_X86_64)