diff --git a/uppsrc/Core/Callback0.h b/uppsrc/Core/Callback0.h index 388a6d07e..86c331401 100644 --- a/uppsrc/Core/Callback0.h +++ b/uppsrc/Core/Callback0.h @@ -16,6 +16,11 @@ Callback pteback(O *object, void (M::*method)()) { return Callback(new CallbackMethodActionPte(object, method)); } +template +Callback pteback(O *object, void (M::*method)() const) { + return Callback(new CallbackMethodActionPte(object, method)); +} + template struct CallbackMethodAction : public CallbackAction { O *object; @@ -77,6 +82,11 @@ Callback1 pteback(O *object, void (M::*method)(P1 p1)) { return Callback1(new Callback1MethodActionPte(object, method)); } +template +Callback1 pteback(O *object, void (M::*method)(P1 p1) const) { + return Callback1(new Callback1MethodActionPte(object, method)); +} + template struct Callback1MethodAction : public Callback1Action { O *object; @@ -145,6 +155,11 @@ Callback2 pteback(O *object, void (M::*method)(P1 p1, P2 p2)) { return Callback2(new Callback2MethodActionPte(object, method)); } +template +Callback2 pteback(O *object, void (M::*method)(P1 p1, P2 p2) const) { + return Callback2(new Callback2MethodActionPte(object, method)); +} + template struct Callback2MethodAction : public Callback2Action { O *object; @@ -213,6 +228,11 @@ Callback3 pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3)) return Callback3(new Callback3MethodActionPte(object, method)); } +template +Callback3 pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3) const) { + return Callback3(new Callback3MethodActionPte(object, method)); +} + template struct Callback3MethodAction : public Callback3Action { O *object; @@ -281,6 +301,11 @@ Callback4 pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 return Callback4(new Callback4MethodActionPte(object, method)); } +template +Callback4 pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) { + return Callback4(new Callback4MethodActionPte(object, method)); +} + template struct Callback4MethodAction : public Callback4Action { O *object; @@ -370,6 +395,11 @@ Gate pteback(O *object, bool (M::*method)()) { return Gate(new GateMethodActionPte(object, method)); } +template +Gate pteback(O *object, bool (M::*method)() const) { + return Gate(new GateMethodActionPte(object, method)); +} + template Gate callback(O *object, bool (M::*method)()) { return Gate(new GateMethodAction(object, method)); @@ -413,6 +443,11 @@ Gate1 pteback(O *object, bool (M::*method)(P1 p1)) { return Gate1(new Gate1MethodActionPte(object, method)); } +template +Gate1 pteback(O *object, bool (M::*method)(P1 p1) const) { + return Gate1(new Gate1MethodActionPte(object, method)); +} + template struct Gate1MethodAction : public Gate1Action { O *object; @@ -481,6 +516,11 @@ Gate2 pteback(O *object, bool (M::*method)(P1 p1, P2 p2)) { return Gate2(new Gate2MethodActionPte(object, method)); } +template +Gate2 pteback(O *object, bool (M::*method)(P1 p1, P2 p2) const) { + return Gate2(new Gate2MethodActionPte(object, method)); +} + template struct Gate2MethodAction : public Gate2Action { O *object; @@ -549,6 +589,11 @@ Gate3 pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3)) { return Gate3(new Gate3MethodActionPte(object, method)); } +template +Gate3 pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3) const) { + return Gate3(new Gate3MethodActionPte(object, method)); +} + template struct Gate3MethodAction : public Gate3Action { O *object; @@ -617,6 +662,11 @@ Gate4 pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, return Gate4(new Gate4MethodActionPte(object, method)); } +template +Gate4 pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) { + return Gate4(new Gate4MethodActionPte(object, method)); +} + template struct Gate4MethodAction : public Gate4Action { O *object; diff --git a/uppsrc/Core/Callback1.h b/uppsrc/Core/Callback1.h index 29eb9359c..8b54f97bb 100644 --- a/uppsrc/Core/Callback1.h +++ b/uppsrc/Core/Callback1.h @@ -17,6 +17,11 @@ Callback pteback1(O *object, void (M::*method)(Q), T arg) { return Callback(new CallbackMethodActionArgPte(object, method, pick(arg))); } +template +Callback pteback1(O *object, void (M::*method)(Q) const, T arg) { + return Callback(new CallbackMethodActionArgPte(object, method, pick(arg))); +} + template struct CallbackMethodActionArg : public CallbackAction { O *object; @@ -36,9 +41,9 @@ Callback callback1(O *object, void (M::*method)(Q), T arg) { } template -Callback callback1(const O *object, void (M::*method)(Q) const, T arg) { - return Callback(new CallbackMethodActionArg - (object, method, arg)); +Callback callback1(O *object, void (M::*method)(Q) const, T arg) { + return Callback(new CallbackMethodActionArg + (object, method, pick(arg))); } template @@ -81,6 +86,11 @@ Callback1 pteback1(O *object, void (M::*method)(P1, Q), T arg) { return Callback1(new Callback1MethodActionArgPte (object, method, pick(arg))); } +template +Callback1 pteback1(O *object, void (M::*method)(P1, Q) const, T arg) { + return Callback1(new Callback1MethodActionArgPte (object, method, pick(arg))); +} + template struct Callback1MethodActionArg : public Callback1Action { O *object; @@ -99,8 +109,8 @@ Callback1 callback1(O *object, void (M::*method)(P1, Q), T arg) { } template -Callback1 callback1(const O *object, void (M::*method)(P1, Q) const, T arg) { - return Callback1(new Callback1MethodActionArg +Callback1 callback1(O *object, void (M::*method)(P1, Q) const, T arg) { + return Callback1(new Callback1MethodActionArg (object, method, pick(arg))); } @@ -143,6 +153,11 @@ Callback2 pteback1(O *object, void (M::*method)(P1, P2, Q), T arg) { return Callback2(new Callback2MethodActionArgPte (object, method, pick(arg))); } +template +Callback2 pteback1(O *object, void (M::*method)(P1, P2, Q) const, T arg) { + return Callback2(new Callback2MethodActionArgPte (object, method, pick(arg))); +} + template struct Callback2MethodActionArg : public Callback2Action { O *object; @@ -161,8 +176,8 @@ Callback2 callback1(O *object, void (M::*method)(P1, P2, Q), T arg) { } template -Callback2 callback1(const O *object, void (M::*method)(P1, P2, Q) const, T arg) { - return Callback2(new Callback2MethodActionArg +Callback2 callback1(O *object, void (M::*method)(P1, P2, Q) const, T arg) { + return Callback2(new Callback2MethodActionArg (object, method, pick(arg))); } @@ -206,6 +221,12 @@ Callback3 pteback1(O *object, void (M::*method)(P1, P2, P3, Q), T ar (object, method, pick(arg))); } +template +Callback3 pteback1(O *object, void (M::*method)(P1, P2, P3, Q) const, T arg) { + return Callback3(new Callback3MethodActionArgPte + (object, method, pick(arg))); +} + template struct Callback3MethodActionArg : public Callback3Action { O *object; @@ -224,8 +245,8 @@ Callback3 callback1(O *object, void (M::*method)(P1, P2, P3, Q), T a } template -Callback3 callback1(const O *object, void (M::*method)(P1, P2, P3, Q) const, T arg) { - return Callback3(new Callback3MethodActionArg +Callback3 callback1(O *object, void (M::*method)(P1, P2, P3, Q) const, T arg) { + return Callback3(new Callback3MethodActionArg (object, method, pick(arg))); } @@ -269,6 +290,12 @@ Callback4 pteback1(O *object, void (M::*method)(P1, P2, P3, P4, (object, method, pick(arg))); } +template +Callback4 pteback1(O *object, void (M::*method)(P1, P2, P3, P4, Q) const, T arg) { + return Callback4(new Callback4MethodActionArgPte + (object, method, pick(arg))); +} + template struct Callback4MethodActionArg : public Callback4Action { O *object; @@ -287,8 +314,8 @@ Callback4 callback1(O *object, void (M::*method)(P1, P2, P3, P4, } template -Callback4 callback1(const O *object, void (M::*method)(P1, P2, P3, P4, Q) const, T arg) { - return Callback4(new Callback4MethodActionArg +Callback4 callback1(O *object, void (M::*method)(P1, P2, P3, P4, Q) const, T arg) { + return Callback4(new Callback4MethodActionArg (object, method, pick(arg))); } @@ -315,62 +342,67 @@ template struct GateMethodActionArgPte : public GateAction { Ptr object; M method; - T arg; + T arg; bool Execute() { return object? (object->*method)(arg) : false; } GateMethodActionArgPte(O *object, M method, T arg) - : object(object), method(method), arg(arg) {} + : object(object), method(method), arg(pick(arg)) {} }; template Gate pteback1(O *object, bool (M::*method)(Q), T arg) { - return Gate(new GateMethodActionArgPte(object, method, arg)); + return Gate(new GateMethodActionArgPte(object, method, pick(arg))); +} + +template +Gate pteback1(O *object, bool (M::*method)(Q) const, T arg) { + return Gate(new GateMethodActionArgPte(object, method, pick(arg))); } template struct GateMethodActionArg : public GateAction { - O *object; - M method; + O *object; + M method; T arg; bool Execute() { return object ? (object->*method)(arg) : false; } GateMethodActionArg(O *object, M method, T arg) - : object(object), method(method), arg(arg) {} + : object(object), method(method), arg(pick(arg)) {} }; template Gate callback1(O *object, bool (M::*method)(Q), T arg) { return Gate(new GateMethodActionArg - (object, method, arg)); + (object, method, pick(arg))); } template -Gate callback1(const O *object, bool (M::*method)(Q) const, T arg) { - return Gate(new GateMethodActionArg - (object, method, arg)); +Gate callback1(O *object, bool (M::*method)(Q) const, T arg) { + return Gate(new GateMethodActionArg + (object, method, pick(arg))); } template struct GateActionCallArg : public GateAction { - F fn; - T arg; + F fn; + T arg; bool Execute() { return fn(arg); } - GateActionCallArg(F fn, T arg) : fn(fn), arg(arg) {} + GateActionCallArg(F fn, T arg) : fn(fn), arg(pick(arg)) {} }; template Gate callback1(bool (*fn)(Q), T arg) { - return Gate(new GateActionCallArg(fn, arg)); + return Gate(new GateActionCallArg(fn, pick(arg))); } //reduct template Gate callback1(Gate1 cb, T arg) { - return Gate(new GateActionCallArg, T>(cb, arg)); + return Gate(new GateActionCallArg, T>(cb, pick(arg))); } //1 arg to Gate1 @@ -379,85 +411,113 @@ template struct Gate1MethodActionArgPte : public Gate1Action { Ptr object; M method; - T arg; + T arg; bool Execute(P1 p1) { return object ? (object->*method)(p1, arg) : false; } Gate1MethodActionArgPte(O *object, M method, T arg) - : object(object), method(method), arg(arg) {} + : object(object), method(method), arg(pick(arg)) {} }; template Gate1 pteback1(O *object, bool (M::*method)(P1, Q), T arg) { - return Gate1(new Gate1MethodActionArgPte (object, method, arg)); + return Gate1(new Gate1MethodActionArgPte (object, method, pick(arg))); +} + +template +Gate1 pteback1(O *object, bool (M::*method)(P1, Q) const, T arg) { + return Gate1(new Gate1MethodActionArgPte (object, method, pick(arg))); } template struct Gate1MethodActionArg : public Gate1Action { - O *object; - M method; + O *object; + M method; T arg; bool Execute(P1 p1) { return object ? (object->*method)(p1, arg) : false; } Gate1MethodActionArg(O *object, M method, T arg) - : object(object), method(method), arg(arg) {} + : object(object), method(method), arg(pick(arg)) {} }; template Gate1 callback1(O *object, bool (M::*method)(P1, Q), T arg) { return Gate1(new Gate1MethodActionArg - (object, method, arg)); + (object, method, pick(arg))); } template -Gate1 callback1(const O *object, bool (M::*method)(P1, Q) const, T arg) { - return Gate1(new Gate1MethodActionArg - (object, method, arg)); +Gate1 callback1(O *object, bool (M::*method)(P1, Q) const, T arg) { + return Gate1(new Gate1MethodActionArg + (object, method, pick(arg))); } template struct Gate1ActionCallArg : public Gate1Action { - F fn; - T arg; + F fn; + T arg; bool Execute(P1 p1) { return fn(p1, arg); } - Gate1ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {} + Gate1ActionCallArg(F fn, T arg) : fn(fn), arg(pick(arg)) {} }; template Gate1 callback1(bool (*fn)(P1, Q), T arg) { - return Gate1(new Gate1ActionCallArg(fn, arg)); + return Gate1(new Gate1ActionCallArg(fn, pick(arg))); } //reduct template Gate1 callback1(Gate2 cb, T arg) { - return Gate1(new Gate1ActionCallArg, P1, T>(cb, arg)); + return Gate1(new Gate1ActionCallArg, P1, T>(cb, pick(arg))); } //1 arg to Gate2 +template +struct Gate2MethodActionArgPte : public Gate2Action { + Ptr object; + M method; + T arg; + bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg) : false; } + + Gate2MethodActionArgPte(O *object, M method, T arg) + : object(object), method(method), arg(pick(arg)) {} +}; + +template +Gate2 pteback1(O *object, bool (M::*method)(P1, P2, Q), T arg) { + return Gate2(new Gate2MethodActionArgPte + (object, method, pick(arg))); +} + +template +Gate2 pteback1(O *object, bool (M::*method)(P1, P2, Q) const, T arg) { + return Gate2(new Gate2MethodActionArgPte + (object, method, pick(arg))); +} + template struct Gate2MethodActionArg : public Gate2Action { - O *object; - M method; - T arg; + O *object; + M method; + T arg; bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg) : false; } Gate2MethodActionArg(O *object, M method, T arg) - : object(object), method(method), arg(arg) {} + : object(object), method(method), arg(pick(arg)) {} }; template Gate2 callback1(O *object, bool (M::*method)(P1, P2, Q), T arg) { return Gate2(new Gate2MethodActionArg - (object, method, arg)); + (object, method, pick(arg))); } template -Gate2 callback1(const O *object, bool (M::*method)(P1, P2, Q) const, T arg) { - return Gate2(new Gate2MethodActionArg - (object, method, arg)); +Gate2 callback1(O *object, bool (M::*method)(P1, P2, Q) const, T arg) { + return Gate2(new Gate2MethodActionArg + (object, method, pick(arg))); } template @@ -466,23 +526,46 @@ struct Gate2ActionCallArg : Gate2Action { T arg; bool Execute(P1 p1, P2 p2) { return fn(p1, p2, arg); } - Gate2ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {} + Gate2ActionCallArg(F fn, T arg) : fn(fn), arg(pick(arg)) {} }; template Gate2 callback1(bool (*fn)(P1, P2, Q), T arg) { - return Gate2(new Gate2ActionCallArg(fn, arg)); + return Gate2(new Gate2ActionCallArg(fn, pick(arg))); } //reduct template Gate2 callback1(Gate3 cb, T arg) { - return Gate2(new Gate2ActionCallArg, P1, P2, T>(cb, arg)); + return Gate2(new Gate2ActionCallArg, P1, P2, T>(cb, pick(arg))); } //1 arg to Gate3 +template +struct Gate3MethodActionArgPte : public Gate3Action { + Ptr object; + M method; + T arg; + bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg) : false; } + + Gate3MethodActionArgPte(O *object, M method, T arg) + : object(object), method(method), arg(pick(arg)) {} +}; + +template +Gate3 pteback1(O *object, bool (M::*method)(P1, P2, P3, Q), T arg) { + return Gate3(new Gate3MethodActionArgPte + (object, method, pick(arg))); +} + +template +Gate3 pteback1(O *object, bool (M::*method)(P1, P2, P3, Q) const, T arg) { + return Gate3(new Gate3MethodActionArgPte + (object, method, pick(arg))); +} + template struct Gate3MethodActionArg : public Gate3Action { O *object; @@ -491,65 +574,88 @@ struct Gate3MethodActionArg : public Gate3Action { bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg) : false; } Gate3MethodActionArg(O *object, M method, T arg) - : object(object), method(method), arg(arg) {} + : object(object), method(method), arg(pick(arg)) {} }; template Gate3 callback1(O *object, bool (M::*method)(P1, P2, P3, Q), T arg) { return Gate3(new Gate3MethodActionArg - (object, method, arg)); + (object, method, pick(arg))); } template -Gate3 callback1(const O *object, bool (M::*method)(P1, P2, P3, Q) const, T arg) { - return Gate3(new Gate3MethodActionArg - (object, method, arg)); +Gate3 callback1(O *object, bool (M::*method)(P1, P2, P3, Q) const, T arg) { + return Gate3(new Gate3MethodActionArg + (object, method, pick(arg))); } template struct Gate3ActionCallArg : Gate3Action { - F fn; - T arg; + F fn; + T arg; bool Execute(P1 p1, P2 p2, P3 p3) { return fn(p1, p2, p3, arg); } - Gate3ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {} + Gate3ActionCallArg(F fn, T arg) : fn(fn), arg(pick(arg)) {} }; template Gate3 callback1(bool (*fn)(P1, P2, P3, Q), T arg) { - return Gate3(new Gate3ActionCallArg(fn, arg)); + return Gate3(new Gate3ActionCallArg(fn, pick(arg))); } //reduct template Gate3 callback1(Gate4 cb, T arg) { - return Gate3(new Gate3ActionCallArg, P1, P2, P3, T>(cb, arg)); + return Gate3(new Gate3ActionCallArg, P1, P2, P3, T>(cb, pick(arg))); } //1 arg to Gate4 +template +struct Gate4MethodActionArgPte : public Gate4Action { + Ptr object; + M method; + T arg; + bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg) : false; } + + Gate4MethodActionArgPte(O *object, M method, T arg) + : object(object), method(method), arg(pick(arg)) {} +}; + +template +Gate4 pteback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q), T arg) { + return Gate4(new Gate4MethodActionArgPte + (object, method, pick(arg))); +} + +template +Gate4 pteback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q) const, T arg) { + return Gate4(new Gate4MethodActionArgPte + (object, method, pick(arg))); +} + template struct Gate4MethodActionArg : public Gate4Action { - O *object; - M method; - T arg; + O *object; + M method; + T arg; bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg) : false; } Gate4MethodActionArg(O *object, M method, T arg) - : object(object), method(method), arg(arg) {} + : object(object), method(method), arg(pick(arg)) {} }; template Gate4 callback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q), T arg) { return Gate4(new Gate4MethodActionArg - (object, method, arg)); + (object, method, pick(arg))); } template -Gate4 callback1(const O *object, bool (M::*method)(P1, P2, P3, P4, Q) const, T arg) { - return Gate4(new Gate4MethodActionArg - (object, method, arg)); +Gate4 callback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q) const, T arg) { + return Gate4(new Gate4MethodActionArg + (object, method, pick(arg))); } template @@ -558,11 +664,11 @@ struct Gate4ActionCallArg : Gate4Action { T arg; bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return fn(p1, p2, p3, p4, arg); } - Gate4ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {} + Gate4ActionCallArg(F fn, T arg) : fn(fn), arg(pick(arg)) {} }; template Gate4 callback1(bool (*fn)(P1, P2, P3, P4, Q), T arg) { - return Gate4(new Gate4ActionCallArg(fn, arg)); + return Gate4(new Gate4ActionCallArg(fn, pick(arg))); } diff --git a/uppsrc/Core/Callback2.h b/uppsrc/Core/Callback2.h index f27c9cdc3..6efc625d2 100644 --- a/uppsrc/Core/Callback2.h +++ b/uppsrc/Core/Callback2.h @@ -4,26 +4,25 @@ template struct CallbackMethodActionArg2Pte : public CallbackAction { Ptr object; M method; - T1 arg1; - T2 arg2; + T1 arg1; + T2 arg2; + void Execute() { if(object) (object->*method)(arg1, arg2); } CallbackMethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* wrong type R? -template -Callback pteback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { - return Callback(new CallbackMethodActionArg2Pte - (object, method, arg1, arg2)); -} -*/ - template Callback pteback2(O *object, void (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { return Callback(new CallbackMethodActionArg2Pte - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); +} + +template +Callback pteback2(O *object, void (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback(new CallbackMethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); } template @@ -35,33 +34,19 @@ struct CallbackMethodActionArg2 : public CallbackAction { void Execute() { (object->*method)(arg1, arg2); } CallbackMethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* wrong type R? -template -Callback callback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { - return Callback(new CallbackMethodActionArg2 - (object, method, arg1, arg2)); -} - -template -Callback callback2(const O *object, R (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { - return Callback(new CallbackMethodActionArg2 - (object, method, arg1, arg2)); -} -*/ - template Callback callback2(O *object, void (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { return Callback(new CallbackMethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Callback callback2(const O *object, void (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { - return Callback(new CallbackMethodActionArg2 - (object, method, arg1, arg2)); +Callback callback2(O *object, void (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback(new CallbackMethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -71,50 +56,67 @@ struct CallbackActionCallArg2 : public CallbackAction { T2 arg2; void Execute() { x(arg1, arg2); } - CallbackActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + CallbackActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* wrong type R? -template -Callback callback2(R (*fn)(Q1, Q2), T1 arg1, T2 arg2) { - return Callback(new CallbackActionCallArg2(fn, arg1, arg2)); -} -*/ - template Callback callback2(void (*fn)(Q1, Q2), T1 arg1, T2 arg2) { - return Callback(new CallbackActionCallArg2(fn, arg1, arg2)); + return Callback(new CallbackActionCallArg2(fn, pick(arg1), pick(arg2))); } template Callback callback2(Callback2 cb, T1 arg1, T2 arg2) { - return Callback(new CallbackActionCallArg2, T1, T2>(cb, arg1, arg2)); + return Callback(new CallbackActionCallArg2, T1, T2>(cb, pick(arg1), pick(arg2))); } //2 args to Callback1 +template +struct Callback1MethodActionArg2Pte : public Callback1Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + void Execute(P1 p1) { if(object) (object->*method)(p1, arg1, arg2); } + + Callback1MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Callback1 pteback2(O *object, void (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) { + return Callback1(new Callback1MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Callback1 pteback2(O *object, void (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback1(new Callback1MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Callback1MethodActionArg2 : public Callback1Action { - O *object; - M method; + O *object; + M method; T1 arg1; T2 arg2; void Execute(P1 p1) { (object->*method)(p1, arg1, arg2); } Callback1MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Callback1 callback2(O *object, void (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) { return Callback1(new Callback1MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Callback1 callback2(const O *object, void (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) { - return Callback1(new Callback1MethodActionArg2 - (object, method, arg1, arg2)); +Callback1 callback2(O *object, void (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback1(new Callback1MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -124,28 +126,45 @@ struct Callback1ActionCallArg2 : public Callback1Action { T2 arg2; void Execute(P1 p1) { x(p1, arg1, arg2); } - Callback1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Callback1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* wrong type R? -template -Callback1 callback2(R (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) { - return Callback1(new Callback1ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Callback1 callback2(void (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) { - return Callback1(new Callback1ActionCallArg2(fn, arg1, arg2)); + return Callback1(new Callback1ActionCallArg2(fn, pick(arg1), pick(arg2))); } template Callback1 callback2(Callback3 cb, T1 arg1, T2 arg2) { - return Callback1(new Callback1ActionCallArg2, P1, T1, T2>(cb, arg1, arg2)); + return Callback1(new Callback1ActionCallArg2, P1, T1, T2>(cb, pick(arg1), pick(arg2))); } //2 args to Callback2 +template +struct Callback2MethodActionArg2Pte : public Callback2Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + void Execute(P1 p1, P2 p2) { if(object) (object->*method)(p1, p2, arg1, arg2); } + + Callback2MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Callback2 pteback2(O *object, void (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { + return Callback2(new Callback2MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Callback2 pteback2(O *object, void (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback2(new Callback2MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Callback2MethodActionArg2 : public Callback2Action { O *object; @@ -155,19 +174,19 @@ struct Callback2MethodActionArg2 : public Callback2Action { void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2); } Callback2MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Callback2 callback2(O *object, void (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { return Callback2(new Callback2MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Callback2 callback2(const O *object, void (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) { - return Callback2(new Callback2MethodActionArg2 - (object, method, arg1, arg2)); +Callback2 callback2(O *object, void (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback2(new Callback2MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -177,28 +196,45 @@ struct Callback2ActionCallArg2 : public Callback2Action { T2 arg2; void Execute(P1 p1, P2 p2) { x(p1, p2, arg1, arg2); } - Callback2ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Callback2ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* wrong type R? -template -Callback2 callback2(R (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { - return Callback2(new Callback2ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Callback2 callback2(void (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { - return Callback2(new Callback2ActionCallArg2(fn, arg1, arg2)); + return Callback2(new Callback2ActionCallArg2(fn, pick(arg1), pick(arg2))); } template Callback2 callback2(Callback4 cb, T1 arg1, T2 arg2) { - return Callback2(new Callback2ActionCallArg2, P1, P2, T1, T2>(cb, arg1, arg2)); + return Callback2(new Callback2ActionCallArg2, P1, P2, T1, T2>(cb, pick(arg1), pick(arg2))); } //2 args to Callback3 +template +struct Callback3MethodActionArg2Pte : public Callback3Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + void Execute(P1 p1, P2 p2, P3 p3) { if(object) (object->*method)(p1, p2, p3, arg1, arg2); } + + Callback3MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Callback3 pteback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { + return Callback3(new Callback3MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Callback3 pteback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback3(new Callback3MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Callback3MethodActionArg2 : public Callback3Action { O *object; @@ -208,19 +244,19 @@ struct Callback3MethodActionArg2 : public Callback3Action { void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2); } Callback3MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Callback3 callback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { return Callback3(new Callback3MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Callback3 callback2(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) { - return Callback3(new Callback3MethodActionArg2 - (object, method, arg1, arg2)); +Callback3 callback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback3(new Callback3MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -230,23 +266,40 @@ struct Callback3ActionCallArg2 : public Callback3Action { T2 arg2; void Execute(P1 p1, P2 p2, P3 p3) { x(p1, p2, p3, arg1, arg2); } - Callback3ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Callback3ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* wrong type R? -template -Callback3 callback2(R (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { - return Callback3(new Callback3ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Callback3 callback2(void (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { - return Callback3(new Callback3ActionCallArg2(fn, arg1, arg2)); + return Callback3(new Callback3ActionCallArg2(fn, pick(arg1), pick(arg2))); } //2 args to Callback4 +template +struct Callback4MethodActionArg2Pte : public Callback4Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { if(object) (object->*method)(p1, p2, p3, p4, arg1, arg2); } + + Callback4MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Callback4 pteback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { + return Callback4(new Callback4MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Callback4 pteback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback4(new Callback4MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Callback4MethodActionArg2 : public Callback4Action { O *object; @@ -256,19 +309,19 @@ struct Callback4MethodActionArg2 : public Callback4Action { void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2); } Callback4MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Callback4 callback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { return Callback4(new Callback4MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Callback4 callback2(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) { - return Callback4(new Callback4MethodActionArg2 - (object, method, arg1, arg2)); +Callback4 callback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) { + return Callback4(new Callback4MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -278,19 +331,12 @@ struct Callback4ActionCallArg2 : public Callback4Action { T2 arg2; void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { x(p1, p2, p3, p4, arg1, arg2); } - Callback4ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Callback4ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* wrong type R? -template -Callback4 callback2(R (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { - return Callback4(new Callback4ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Callback4 callback2(void (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { - return Callback4(new Callback4ActionCallArg2(fn, arg1, arg2)); + return Callback4(new Callback4ActionCallArg2(fn, pick(arg1), pick(arg2))); } // --------------------------------------------------------- @@ -301,27 +347,24 @@ template struct GateMethodActionArg2Pte : public GateAction { Ptr object; M method; - T1 arg1; - T2 arg2; + T1 arg1; + T2 arg2; bool Execute() { return object ? (object->*method)(arg1, arg2) : false; } GateMethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* ambigiuous with Callback versions - -template -Gate pteback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { - return Gate(new GateMethodActionArg2Pte - (object, method, arg1, arg2)); -} -*/ - template Gate pteback2(O *object, bool (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { return Gate(new GateMethodActionArg2Pte - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); +} + +template +Gate pteback2(O *object, bool (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate(new GateMethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); } template @@ -333,34 +376,19 @@ struct GateMethodActionArg2 : public GateAction { bool Execute() { return object ? (object->*method)(arg1, arg2) : false; } GateMethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* ambigiuous with Callback versions - -template -Gate callback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { - return Gate(new GateMethodActionArg2 - (object, method, arg1, arg2)); -} - -template -Gate callback2(const O *object, R (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { - return Gate(new GateMethodActionArg2 - (object, method, arg1, arg2)); -} -*/ - template Gate callback2(O *object, bool (M::*method)(Q1, Q2), T1 arg1, T2 arg2) { return Gate(new GateMethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Gate callback2(const O *object, bool (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { - return Gate(new GateMethodActionArg2 - (object, method, arg1, arg2)); +Gate callback2(O *object, bool (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate(new GateMethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -370,29 +398,45 @@ struct GateActionCallArg2 : public GateAction { T2 arg2; bool Execute() { return x(arg1, arg2); } - GateActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + GateActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* ambigiuous with Callback versions - -template -Gate callback2(R (*fn)(Q1, Q2), T1 arg1, T2 arg2) { - return Gate(new GateActionCallArg2(fn, arg1, arg2)); -} -*/ - template Gate callback2(bool (*fn)(Q1, Q2), T1 arg1, T2 arg2) { - return Gate(new GateActionCallArg2(fn, arg1, arg2)); + return Gate(new GateActionCallArg2(fn, pick(arg1), pick(arg2))); } template Gate callback2(Gate2 cb, T1 arg1, T2 arg2) { - return Gate(new GateActionCallArg2, T1, T2>(cb, arg1, arg2)); + return Gate(new GateActionCallArg2, T1, T2>(cb, pick(arg1), pick(arg2))); } //2 args to Gate1 +template +struct Gate1MethodActionArg2Pte : public Gate1Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + bool Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2) : false; } + + Gate1MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Gate1 pteback2(O *object, bool (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) { + return Gate1(new Gate1MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Gate1 pteback2(O *object, bool (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate1(new Gate1MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Gate1MethodActionArg2 : public Gate1Action { O *object; @@ -402,19 +446,19 @@ struct Gate1MethodActionArg2 : public Gate1Action { bool Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2) : false; } Gate1MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Gate1 callback2(O *object, bool (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) { return Gate1(new Gate1MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Gate1 callback2(const O *object, bool (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) { - return Gate1(new Gate1MethodActionArg2 - (object, method, arg1, arg2)); +Gate1 callback2(O *object, bool (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate1(new Gate1MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -424,29 +468,45 @@ struct Gate1ActionCallArg2 : public Gate1Action { T2 arg2; bool Execute(P1 p1) { return x(p1, arg1, arg2); } - Gate1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Gate1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* ambigiuous with Callback versions - -template -Gate1 callback2(R (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) { - return Gate1(new Gate1ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Gate1 callback2(bool (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) { - return Gate1(new Gate1ActionCallArg2(fn, arg1, arg2)); + return Gate1(new Gate1ActionCallArg2(fn, pick(arg1), pick(arg2))); } template Gate1 callback2(Gate3 cb, T1 arg1, T2 arg2) { - return Gate1(new Gate1ActionCallArg2, P1, T1, T2>(cb, arg1, arg2)); + return Gate1(new Gate1ActionCallArg2, P1, T1, T2>(cb, pick(arg1), pick(arg2))); } //2 args to Gate2 +template +struct Gate2MethodActionArg2Pte : public Gate2Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2) : false; } + + Gate2MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Gate2 pteback2(O *object, bool (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { + return Gate2(new Gate2MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Gate2 pteback2(O *object, bool (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate2(new Gate2MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Gate2MethodActionArg2 : public Gate2Action { O *object; @@ -456,19 +516,19 @@ struct Gate2MethodActionArg2 : public Gate2Action { bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2) : false; } Gate2MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Gate2 callback2(O *object, bool (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { return Gate2(new Gate2MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Gate2 callback2(const O *object, bool (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) { - return Gate2(new Gate2MethodActionArg2 - (object, method, arg1, arg2)); +Gate2 callback2(O *object, bool (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate2(new Gate2MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -478,29 +538,45 @@ struct Gate2ActionCallArg2 : public Gate2Action { T2 arg2; bool Execute(P1 p1, P2 p2) { return x(p1, p2, arg1, arg2); } - Gate2ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Gate2ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* ambigiuous with Callback versions - -template -Gate2 callback2(R (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { - return Gate2(new Gate2ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Gate2 callback2(bool (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) { - return Gate2(new Gate2ActionCallArg2(fn, arg1, arg2)); + return Gate2(new Gate2ActionCallArg2(fn, pick(arg1), pick(arg2))); } template Gate2 callback2(Gate4 cb, T1 arg1, T2 arg2) { - return Gate2(new Gate2ActionCallArg2, P1, P2, T1, T2>(cb, arg1, arg2)); + return Gate2(new Gate2ActionCallArg2, P1, P2, T1, T2>(cb, pick(arg1), pick(arg2))); } //2 args to Gate3 +template +struct Gate3MethodActionArg2Pte : public Gate3Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg1, arg2) : false; } + + Gate3MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Gate3 pteback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { + return Gate3(new Gate3MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Gate3 pteback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate3(new Gate3MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Gate3MethodActionArg2 : public Gate3Action { O *object; @@ -510,19 +586,19 @@ struct Gate3MethodActionArg2 : public Gate3Action { bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg1, arg2) : false; } Gate3MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Gate3 callback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { return Gate3(new Gate3MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Gate3 callback2(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) { - return Gate3(new Gate3MethodActionArg2 - (object, method, arg1, arg2)); +Gate3 callback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate3(new Gate3MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -532,24 +608,40 @@ struct Gate3ActionCallArg2 : public Gate3Action { T2 arg2; bool Execute(P1 p1, P2 p2, P3 p3) { return x(p1, p2, p3, arg1, arg2); } - Gate3ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Gate3ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* ambigiuous with Callback versions - -template -Gate3 callback2(R (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { - return Gate3(new Gate3ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Gate3 callback2(bool (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) { - return Gate3(new Gate3ActionCallArg2(fn, arg1, arg2)); + return Gate3(new Gate3ActionCallArg2(fn, pick(arg1), pick(arg2))); } //2 args to Gate4 +template +struct Gate4MethodActionArg2Pte : public Gate4Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg1, arg2) : false; } + + Gate4MethodActionArg2Pte(O *object, M method, T1 arg1, T2 arg2) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} +}; + +template +Gate4 pteback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { + return Gate4(new Gate4MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + +template +Gate4 pteback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate4(new Gate4MethodActionArg2Pte + (object, method, pick(arg1), pick(arg2))); +} + template struct Gate4MethodActionArg2 : public Gate4Action { O *object; @@ -559,19 +651,19 @@ struct Gate4MethodActionArg2 : public Gate4Action { bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg1, arg2) : false; } Gate4MethodActionArg2(O *object, M method, T1 arg1, T2 arg2) - : object(object), method(method), arg1(arg1), arg2(arg2) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)) {} }; template Gate4 callback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { return Gate4(new Gate4MethodActionArg2 - (object, method, arg1, arg2)); + (object, method, pick(arg1), pick(arg2))); } template -Gate4 callback2(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) { - return Gate4(new Gate4MethodActionArg2 - (object, method, arg1, arg2)); +Gate4 callback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) { + return Gate4(new Gate4MethodActionArg2 + (object, method, pick(arg1), pick(arg2))); } template @@ -581,18 +673,10 @@ struct Gate4ActionCallArg2 : public Gate4Action { T2 arg2; bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return x(p1, p2, p3, p4, arg1, arg2); } - Gate4ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {} + Gate4ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(pick(arg1)), arg2(pick(arg2)) {} }; -/* ambigiuous with Callback versions - -template -Gate4 callback2(R (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { - return Gate4(new Gate4ActionCallArg2(fn, arg1, arg2)); -} -*/ - template Gate4 callback2(bool (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) { - return Gate4(new Gate4ActionCallArg2(fn, arg1, arg2)); + return Gate4(new Gate4ActionCallArg2(fn, pick(arg1), pick(arg2))); } diff --git a/uppsrc/Core/Callback3.h b/uppsrc/Core/Callback3.h index c71ba6ff9..a41635271 100644 --- a/uppsrc/Core/Callback3.h +++ b/uppsrc/Core/Callback3.h @@ -10,21 +10,19 @@ struct CallbackMethodActionArg3Pte : public CallbackAction { void Execute() { if(object) (object->*method)(arg1, arg2, arg3); } CallbackMethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; -/* wrong type R? -template -Callback pteback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { - return Callback(new CallbackMethodActionArg3Pte - (object, method, arg1, arg2, arg3)); -} -*/ - template Callback pteback3(O *object, void (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Callback(new CallbackMethodActionArg3Pte - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +Callback pteback3(O *object, void (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback(new CallbackMethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template @@ -39,35 +37,20 @@ struct CallbackMethodActionArg3 : public CallbackAction void Execute() { (object->*method)(arg1, arg2, arg3); } CallbackMethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; -/* wrong type R? -template -Callback callback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) -{ - return Callback( - new CallbackMethodActionArg3(object, method, arg1, arg2, arg3)); -} - -template -Callback callback3(const O *object, R (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Callback(new CallbackMethodActionArg3 - (object, method, arg1, arg2, arg3)); -} -*/ - template Callback callback3(O *object, void (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Callback( - new CallbackMethodActionArg3(object, method, arg1, arg2, arg3)); + new CallbackMethodActionArg3(object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Callback callback3(const O *object, void (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Callback(new CallbackMethodActionArg3 - (object, method, arg1, arg2, arg3)); +Callback callback3(O *object, void (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback(new CallbackMethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template @@ -78,59 +61,112 @@ struct CallbackActionCallArg3 : public CallbackAction { T3 arg3; void Execute() { x(arg1, arg2, arg3); } - CallbackActionCallArg3(X x, T1 arg1, T2 arg2, T3 arg3) - : x(x), arg1(arg1), arg2(arg2), arg3(arg3) {} + CallbackActionCallArg3(X x, T1 arg1, T2 arg2, T3 arg3) + : x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; -/* wrong type R? -template -Callback callback3(R (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { - return Callback( - new CallbackActionCallArg3(fn, arg1, arg2, arg3)); -} -*/ - template Callback callback3(void (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Callback( - new CallbackActionCallArg3(fn, arg1, arg2, arg3)); + new CallbackActionCallArg3(fn, pick(arg1), pick(arg2), pick(arg3))); } template Callback callback3(Callback3 cb, T1 arg1, T2 arg2, T3 arg3) { return Callback( - new CallbackActionCallArg3, T1, T2, T3>(cb, arg1, arg2, arg3)); + new CallbackActionCallArg3, T1, T2, T3>(cb, pick(arg1), pick(arg2), pick(arg3))); } //3 args to Callback1 +template +struct Callback1FnActionArg3 : public Callback1Action { + X fn; + T1 arg1; + T2 arg2; + T3 arg3; + void Execute(P1 p1) { fn(p1, arg1, arg2, arg3); } + + Callback1FnActionArg3(X fn, T1 arg1, T2 arg2, T3 arg3) + : fn(fn), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Callback1 callback3(void (*fn)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Callback1(new Callback1FnActionArg3 + (fn, pick(arg1), pick(arg2), pick(arg3))); +} + template struct Callback1MethodActionArg3 : public Callback1Action { - O *object; - M method; + O *object; + M method; T1 arg1; T2 arg2; T3 arg3; void Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3); } Callback1MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Callback1 callback3(O *object, void (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Callback1(new Callback1MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Callback1 callback3(const O *object, void (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Callback1(new Callback1MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Callback1 callback3(O *object, void (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback1(new Callback1MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +struct Callback1MethodActionArg3Pte : public Callback1Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + void Execute(P1 p1) { if(object) (object->*method)(p1, arg1, arg2, arg3); } + + Callback1MethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Callback1 pteback3(O *object, void (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Callback1(new Callback1MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +Callback1 pteback3(O *object, void (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback1(new Callback1MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); } //3 args to Callback2 +template +struct Callback2FnActionArg3 : public Callback2Action { + X fn; + T1 arg1; + T2 arg2; + T3 arg3; + void Execute(P1 p1, P2 p2) { fn(p1, p2, arg1, arg2, arg3); } + + Callback2FnActionArg3(X fn, T1 arg1, T2 arg2, T3 arg3) + : fn(fn), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Callback2 callback3(void (*fn)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Callback2(new Callback2FnActionArg3 + (fn, pick(arg1), pick(arg2), pick(arg3))); +} + template struct Callback2MethodActionArg3 : public Callback2Action { O *object; @@ -141,22 +177,47 @@ struct Callback2MethodActionArg3 : public Callback2Action { void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3); } Callback2MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Callback2 callback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Callback2(new Callback2MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Callback2 callback3(const O *object, void (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Callback2(new Callback2MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Callback2 callback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback2(new Callback2MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } -//3 args to Callback3 +template +struct Callback2MethodActionArg3Pte : public Callback2Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + void Execute(P1 p1, P2 p2) { if(object) (object->*method)(p1, p2, arg1, arg2, arg3); } + + Callback2MethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Callback2 pteback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Callback2(new Callback2MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +Callback2 pteback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback2(new Callback2MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +//3 args to Callback3 (obsolete - we only provide up to 5 parameters of receiving function) template struct Callback3MethodActionArg3 : public Callback3Action { @@ -168,22 +229,40 @@ struct Callback3MethodActionArg3 : public Callback3Action { void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3); } Callback3MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Callback3 callback3(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Callback3(new Callback3MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Callback3 callback3(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Callback3(new Callback3MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Callback3 callback3(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback3(new Callback3MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } -//3 args to Callback4 +//3 args to Callback4 (obsolete - we only provide up to 5 parameters of receiving function) + +template +struct Callback4FnActionArg3 : public Callback4Action { + X fn; + T1 arg1; + T2 arg2; + T3 arg3; + void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { fn(p1, p2, p3, p4, arg1, arg2, arg3); } + + Callback4FnActionArg3(X fn, T1 arg1, T2 arg2, T3 arg3) + : fn(fn), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Callback4 callback3(void (*fn)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Callback4(new Callback4MethodActionArg3 + (fn, pick(arg1), pick(arg2), pick(arg3))); +} template struct Callback4MethodActionArg3 : public Callback4Action { @@ -195,19 +274,19 @@ struct Callback4MethodActionArg3 : public Callback4Action { void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3); } Callback4MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Callback4 callback3(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Callback4(new Callback4MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Callback4 callback3(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Callback4(new Callback4MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Callback4 callback3(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Callback4(new Callback4MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } // -------------------------------------------------------- @@ -224,66 +303,45 @@ struct GateMethodActionArg3Pte : public GateAction { bool Execute() { return object ? (object->*method)(arg1, arg2, arg3): false; } GateMethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; -/* ambigiuous with Callback versions - -template -Gate pteback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { - return Gate(new GateMethodActionArg3Pte - (object, method, arg1, arg2, arg3)); -} -*/ - template Gate pteback3(O *object, bool (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Gate(new GateMethodActionArg3Pte - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +Gate pteback3(O *object, bool (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate(new GateMethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -struct GateMethodActionArg3 : public GateAction -{ +struct GateMethodActionArg3 : public GateAction { O *object; M method; T1 arg1; T2 arg2; T3 arg3; - bool Execute() { return object ? (object->*method)(arg1, arg2, arg3) : false; } GateMethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; -/* ambigiuous with Callback versions - -template -Gate callback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) -{ - return Gate( - new GateMethodActionArg3(object, method, arg1, arg2, arg3)); -} - -template -Gate callback3(const O *object, R (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Gate(new GateMethodActionArg3 - (object, method, arg1, arg2, arg3)); -} -*/ - template Gate callback3(O *object, bool (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Gate( - new GateMethodActionArg3(object, method, arg1, arg2, arg3)); + new GateMethodActionArg3(object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Gate callback3(const O *object, bool (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Gate(new GateMethodActionArg3 - (object, method, arg1, arg2, arg3)); +Gate callback3(O *object, bool (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate(new GateMethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template @@ -294,33 +352,42 @@ struct GateActionCallArg3 : public GateAction { T3 arg3; bool Execute() { return x(arg1, arg2, arg3); } - GateActionCallArg3(X x, T1 arg1, T2 arg2, T3 arg3) - : x(x), arg1(arg1), arg2(arg2), arg3(arg3) {} + GateActionCallArg3(X x, T1 arg1, T2 arg2, T3 arg3) + : x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; -/* ambigiuous with Callback versions - -template -Gate callback3(R (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { - return Gate( - new GateActionCallArg3(fn, arg1, arg2, arg3)); -} -*/ - template Gate callback3(bool (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Gate( - new GateActionCallArg3(fn, arg1, arg2, arg3)); + new GateActionCallArg3(fn, pick(arg1), pick(arg2), pick(arg3))); } template Gate callback3(Gate3 cb, T1 arg1, T2 arg2, T3 arg3) { return Gate( - new GateActionCallArg3, T1, T2, T3>(cb, arg1, arg2, arg3)); + new GateActionCallArg3, T1, T2, T3>(cb, pick(arg1), pick(arg2), pick(arg3))); } //3 args to Gate1 +template +struct Gate1FnActionArg3 : public Gate1Action { + X fn; + T1 arg1; + T2 arg2; + T3 arg3; + bool Execute(P1 p1) { return fn ? fn(p1, arg1, arg2, arg3) : false; } + + Gate1FnActionArg3(X fn, T1 arg1, T2 arg2, T3 arg3) + : fn(fn), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Gate1 callback3(bool (*fn)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Gate1(new Gate1FnActionArg3 + (fn, pick(arg1), pick(arg2), pick(arg3))); +} + template struct Gate1MethodActionArg3 : public Gate1Action { O *object; @@ -331,23 +398,66 @@ struct Gate1MethodActionArg3 : public Gate1Action { bool Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2, arg3) : false; } Gate1MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Gate1 callback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Gate1(new Gate1MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Gate1 callback3(const O *object, bool (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Gate1(new Gate1MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Gate1 callback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate1(new Gate1MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +struct Gate1MethodActionArg3Pte : public Gate1Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + bool Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2, arg3) : false; } + + Gate1MethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Gate1 pteback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Gate1(new Gate1MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +Gate1 pteback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate1(new Gate1MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); } //3 args to Gate2 +template +struct Gate2FnActionArg3 : public Gate2Action { + X fn; + T1 arg1; + T2 arg2; + T3 arg3; + bool Execute(P1 p1, P2 p2) { return fn ? fn(p1, p2, arg1, arg2, arg3) : false; } + + Gate2FnActionArg3(X fn, T1 arg1, T2 arg2, T3 arg3) + : fn(fn), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Gate2 callback3(bool (*fn)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Gate2(new Gate2FnActionArg3 + (fn, pick(arg1), pick(arg2), pick(arg3))); +} + template struct Gate2MethodActionArg3 : public Gate2Action { O *object; @@ -358,22 +468,47 @@ struct Gate2MethodActionArg3 : public Gate2Action { bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2, arg3) : false; } Gate2MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Gate2 callback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Gate2(new Gate2MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Gate2 callback3(const O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Gate2(new Gate2MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Gate2 callback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate2(new Gate2MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } -//3 args to Gate3 +template +struct Gate2MethodActionArg3Pte : public Gate2Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2, arg3) : false; } + + Gate2MethodActionArg3Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} +}; + +template +Gate2 pteback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { + return Gate2(new Gate2MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +template +Gate2 pteback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate2(new Gate2MethodActionArg3Pte + (object, method, pick(arg1), pick(arg2), pick(arg3))); +} + +//3 args to Gate3 (obsolete - we only provide up to 5 parameters of receiving function) template struct Gate3MethodActionArg3 : public Gate3Action { @@ -385,22 +520,22 @@ struct Gate3MethodActionArg3 : public Gate3Action { bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg1, arg2, arg3) : false; } Gate3MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Gate3 callback3(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Gate3(new Gate3MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Gate3 callback3(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Gate3(new Gate3MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Gate3 callback3(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate3(new Gate3MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } -//3 args to Gate4 +//3 args to Gate4 (obsolete - we only provide up to 5 parameters of receiving function) template struct Gate4MethodActionArg3 : public Gate4Action { @@ -412,17 +547,17 @@ struct Gate4MethodActionArg3 : public Gate4Action { bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3) : false; } Gate4MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)) {} }; template Gate4 callback3(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) { return Gate4(new Gate4MethodActionArg3 - (object, method, arg1, arg2, arg3)); + (object, method, pick(arg1), pick(arg2), pick(arg3))); } template -Gate4 callback3(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { - return Gate4(new Gate4MethodActionArg3 - (object, method, arg1, arg2, arg3)); +Gate4 callback3(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) { + return Gate4(new Gate4MethodActionArg3 + (object, method, pick(arg1), pick(arg2), pick(arg3))); } diff --git a/uppsrc/Core/Callback4.h b/uppsrc/Core/Callback4.h index 40114ab72..353dfedfe 100644 --- a/uppsrc/Core/Callback4.h +++ b/uppsrc/Core/Callback4.h @@ -4,29 +4,26 @@ template struct CallbackMethodActionArg4Pte : public CallbackAction { Ptr object; M method; - T1 arg1; - T2 arg2; - T3 arg3; - T4 arg4; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; void Execute() { if(object) (object->*method)(arg1, arg2, arg3, arg4); } CallbackMethodActionArg4Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; -/* ambigiuous with Callback versions - -template -Callback pteback4(O *object, R (M::*method)(Q1, Q2,Q3,Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback(new CallbackMethodActionArg4Pte - (object, method, arg1, arg2, arg3, arg4)); -} -*/ - template Callback pteback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback(new CallbackMethodActionArg4Pte - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + +template +Callback pteback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback(new CallbackMethodActionArg4Pte + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template @@ -42,74 +39,68 @@ struct CallbackMethodActionArg4 : public CallbackAction void Execute() { (object->*method)(arg1, arg2, arg3, arg4); } CallbackMethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; -/* ambigiuous with Callback versions - -template -Callback callback4(O *object, R (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) -{ - return Callback( - new CallbackMethodActionArg4(object, method, arg1, arg2, arg3, arg4)); -} - -template -Callback callback4(const O *object, R (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback(new CallbackMethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); -} -*/ - template Callback callback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback( - new CallbackMethodActionArg4(object, method, arg1, arg2, arg3, arg4)); + new CallbackMethodActionArg4(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Callback callback4(const O *object, void (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback(new CallbackMethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Callback callback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback(new CallbackMethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template struct CallbackActionCallArg4 : public CallbackAction { - X x; - T1 arg1; - T2 arg2; - T3 arg3; - T4 arg4; + X x; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; void Execute() { x(arg1, arg2, arg3, arg4); } - CallbackActionCallArg4(X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : x(x), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + CallbackActionCallArg4(X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4) + : x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; -/* ambigiuous with Callback versions - -template -Callback callback4(R (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback( - new CallbackActionCallArg4(fn, arg1, arg2, arg3, arg4)); -} -*/ - template Callback callback4(void (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback( - new CallbackActionCallArg4(fn, arg1, arg2, arg3, arg4)); + new CallbackActionCallArg4(fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template Callback callback4(Callback4 cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback( - new CallbackActionCallArg4, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4)); + new CallbackActionCallArg4, T1, T2, T3, T4>(cb, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } //4 args to Callback1 +template +struct Callback1FnActionArg4 : public Callback1Action { + X fn; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + void Execute(P1 p1) { fn(p1, arg1, arg2, arg3, arg4); } + + Callback1FnActionArg4(X fn, T1 arg1, T2 arg2, T3 arg3, T4 arg4) + : fn(fn), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} +}; + +template +Callback1 callback4(void (*fn)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback1(new Callback1FnActionArg4 + (fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + template struct Callback1MethodActionArg4 : public Callback1Action { O *object; @@ -121,22 +112,48 @@ struct Callback1MethodActionArg4 : public Callback1Action { void Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3, arg4); } Callback1MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Callback1 callback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback1(new Callback1MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Callback1 callback4(const O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback1(new Callback1MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Callback1 callback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback1(new Callback1MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } -//4 args to Callback2 +template +struct Callback1MethodActionArg4Pte : public Callback1Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + void Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3, arg4); } + + Callback1MethodActionArg4Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} +}; + +template +Callback1 pteback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback1(new Callback1MethodActionArg4Pte + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + +template +Callback1 pteback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback1(new Callback1MethodActionArg4Pte + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + +//4 args to Callback2 (obsolete - we only provide up to 5 parameters of receiving function) template struct Callback2MethodActionArg4 : public Callback2Action { @@ -149,22 +166,22 @@ struct Callback2MethodActionArg4 : public Callback2Action { void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3, arg4); } Callback2MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Callback2 callback4(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback2(new Callback2MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Callback2 callback4(const O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback2(new Callback2MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Callback2 callback4(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback2(new Callback2MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } -//4 args to Callback3 +//4 args to Callback3 (obsolete - we only provide up to 5 parameters of receiving function) template struct Callback3MethodActionArg4 : public Callback3Action { @@ -177,22 +194,22 @@ struct Callback3MethodActionArg4 : public Callback3Action { void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3, arg4); } Callback3MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Callback3 callback4(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback3(new Callback3MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Callback3 callback4(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback3(new Callback3MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Callback3 callback4(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback3(new Callback3MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } -//4 args to Callback4 +//4 args to Callback4 (obsolete - we only provide up to 5 parameters of receiving function) template struct Callback4MethodActionArg4 : public Callback4Action { @@ -205,19 +222,19 @@ struct Callback4MethodActionArg4 : public Callback4Action { void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3, arg4); } Callback4MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Callback4 callback4(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Callback4(new Callback4MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Callback4 callback4(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Callback4(new Callback4MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Callback4 callback4(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Callback4(new Callback4MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } //---------------------------------------------------------- @@ -235,21 +252,19 @@ struct GateMethodActionArg4Pte : public GateAction { bool Execute() { return object ? (object->*method)(arg1, arg2, arg3, arg4) : false; } GateMethodActionArg4Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; -/* -template -Gate pteback4(O *object, R (M::*method)(Q1, Q2,Q3,Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate(new GateMethodActionArg4Pte - (object, method, arg1, arg2, arg3, arg4)); -} -*/ - template Gate pteback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate(new GateMethodActionArg4Pte - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + +template +Gate pteback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate(new GateMethodActionArg4Pte + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template @@ -265,35 +280,20 @@ struct GateMethodActionArg4 : public GateAction bool Execute() { return object ? (object->*method)(arg1, arg2, arg3, arg4) : false; } GateMethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; -/* -template -Gate callback4(O *object, R (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) -{ - return Gate( - new GateMethodActionArg4(object, method, arg1, arg2, arg3, arg4)); -} - -template -Gate callback4(const O *object, R (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate(new GateMethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); -} -*/ - template Gate callback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate( - new GateMethodActionArg4(object, method, arg1, arg2, arg3, arg4)); + new GateMethodActionArg4(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Gate callback4(const O *object, bool (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate(new GateMethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Gate callback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate(new GateMethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template @@ -305,32 +305,43 @@ struct GateActionCallArg4 : public GateAction { T4 arg4; bool Execute() { return x(arg1, arg2, arg3, arg4); } - GateActionCallArg4(X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : x(x), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + GateActionCallArg4(X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4) + : x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; -/* -template -Gate callback4(R (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate( - new GateActionCallArg4(fn, arg1, arg2, arg3, arg4)); -} -*/ - template Gate callback4(bool (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate( - new GateActionCallArg4(fn, arg1, arg2, arg3, arg4)); + new GateActionCallArg4(fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template Gate callback4(Gate4 cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate( - new GateActionCallArg4, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4)); + new GateActionCallArg4, T1, T2, T3, T4>(cb, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } //4 args to Gate1 +template +struct Gate1FnActionArg4 : public Gate1Action { + X fn; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + bool Execute(P1 p1) { return fn ? fn(p1, arg1, arg2, arg3, arg4) : false; } + + Gate1FnActionArg4(X fn, T1 arg1, T2 arg2, T3 arg3, T4 arg4) + : fn(fn), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} +}; + +template +Gate1 callback4(bool (*fn)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate1(new Gate1FnActionArg4 + (fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + template struct Gate1MethodActionArg4 : public Gate1Action { O *object; @@ -342,19 +353,45 @@ struct Gate1MethodActionArg4 : public Gate1Action { bool Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2, arg3, arg4) : false; } Gate1MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Gate1 callback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate1(new Gate1MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Gate1 callback4(const O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate1(new Gate1MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Gate1 callback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate1(new Gate1MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + +template +struct Gate1MethodActionArg4Pte : public Gate1Action { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + bool Execute(P1 p1) { return object ? (object->*method)(p1, arg1, arg2, arg3, arg4) : false; } + + Gate1MethodActionArg4Pte(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} +}; + +template +Gate1 pteback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate1(new Gate1MethodActionArg4Pte + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); +} + +template +Gate1 pteback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate1(new Gate1MethodActionArg4Pte + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } //4 args to Gate2 @@ -370,19 +407,19 @@ struct Gate2MethodActionArg4 : public Gate2Action { bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2, arg1, arg2, arg3, arg4) : false; } Gate2MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Gate2 callback4(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate2(new Gate2MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Gate2 callback4(const O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate2(new Gate2MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Gate2 callback4(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate2(new Gate2MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } //4 args to Gate3 @@ -398,19 +435,19 @@ struct Gate3MethodActionArg4 : public Gate3Action { bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3, arg1, arg2, arg3, arg4) : false; } Gate3MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Gate3 callback4(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate3(new Gate3MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Gate3 callback4(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate3(new Gate3MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Gate3 callback4(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate3(new Gate3MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } //4 args to Gate4 @@ -426,17 +463,17 @@ struct Gate4MethodActionArg4 : public Gate4Action { bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3, arg4) : false; } Gate4MethodActionArg4(O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4) - : object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)) {} }; template Gate4 callback4(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return Gate4(new Gate4MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } template -Gate4 callback4(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { - return Gate4(new Gate4MethodActionArg4 - (object, method, arg1, arg2, arg3, arg4)); +Gate4 callback4(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) { + return Gate4(new Gate4MethodActionArg4 + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4))); } diff --git a/uppsrc/Core/Callback5.h b/uppsrc/Core/Callback5.h index 9e0bdceac..9a5e77e62 100644 --- a/uppsrc/Core/Callback5.h +++ b/uppsrc/Core/Callback5.h @@ -1,7 +1,27 @@ -template +template < class X, class T1, class T2, class T3, class T4, class T5, class HC = X > +struct CallbackActionCallArg5 : public CallbackAction { + X x; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + T5 arg5; + void Execute() { x ( arg1, arg2, arg3, arg4, arg5 ); } -struct CallbackMethodActionArg5 : public CallbackAction + CallbackActionCallArg5 ( X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) + : x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {} +}; + + +template +Callback callback5 ( void ( *fn ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) { + return Callback(new CallbackActionCallArg5 < void (*)( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5, uintptr_t > + (fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5))); +} + +template +struct CallbackMethodActionArg5 : public CallbackAction { O *object; M method; T1 arg1; @@ -16,28 +36,143 @@ struct CallbackMethodActionArg5 : public CallbackAction } CallbackMethodActionArg5 ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) - : object ( object ), method ( method ), arg1 ( arg1 ), arg2 ( arg2 ), arg3 ( arg3 ), arg4 ( arg4 ) , arg5 ( arg5 ) {} + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {} }; template Callback callback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) { - return Callback ( - new CallbackMethodActionArg5 < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 > ( object, method, arg1, arg2, arg3, arg4, arg5 ) ); + return Callback(new CallbackMethodActionArg5 < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5))); } +template +Callback callback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +{ + return Callback ( new CallbackMethodActionArg5 < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5))); +} + +template +struct CallbackMethodActionArg5Pte : public CallbackAction { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + T5 arg5; + + void Execute() + { + ( object->*method ) ( arg1, arg2, arg3, arg4, arg5 ); + } + + CallbackMethodActionArg5Pte ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) + : object ( object ), method ( method ), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {} +}; + +template +Callback pteback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +{ + return Callback(new CallbackMethodActionArg5Pte < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) ); +} + +template +Callback pteback5 ( O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +{ + return Callback(new CallbackMethodActionArg5Pte < O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) ); +} + +// ----------------------------------------------- + +template < class X, class T1, class T2, class T3, class T4, class T5, class HC = X > +struct GateActionCallArg5 : public GateAction { + X x; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + T5 arg5; + bool Execute() { return x ? x ( arg1, arg2, arg3, arg4, arg5 ) : false; } + + GateActionCallArg5 ( X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) + : x(x), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {} +}; + + +template +Gate callback5 ( bool ( *fn ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +{ + return Gate(new GateActionCallArg5 < bool (*)( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5, uintptr_t > + (fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5))); +} + +template +struct GateMethodActionArg5 : public GateAction { + O *object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + T5 arg5; + bool Execute() { return object ? ( object->*method ) ( arg1, arg2, arg3, arg4, arg5 ) : false; } + + GateMethodActionArg5 ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) + : object(object), method(method), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {} +}; template -Callback callback5 ( const O *object, void ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +Gate callback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) { - return Callback ( new CallbackMethodActionArg5 < const O, void ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 > - ( object, method, arg1, arg2, arg3, arg4, arg5 ) ); + return Gate(new GateMethodActionArg5 < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5))); } -template +template +Gate callback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +{ + return Gate ( new GateMethodActionArg5 < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5))); +} +template +struct GateMethodActionArg5Pte : public GateAction { + Ptr object; + M method; + T1 arg1; + T2 arg2; + T3 arg3; + T4 arg4; + T5 arg5; + bool Execute() { return object ? ( object->*method ) ( arg1, arg2, arg3, arg4, arg5 ) : false; } + + GateMethodActionArg5Pte ( O *object, M method, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) + : object ( object ), method ( method ), arg1(pick(arg1)), arg2(pick(arg2)), arg3(pick(arg3)), arg4(pick(arg4)), arg5(pick(arg5)) {} +}; + +template +Gate pteback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +{ + return Gate(new GateMethodActionArg5Pte < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) ); +} + +template +Gate pteback5 ( O *object, bool ( M::*method ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) +{ + return Gate(new GateMethodActionArg5Pte < O, bool ( M::* ) ( Q1, Q2, Q3, Q4, Q5 ) const, T1, T2, T3, T4, T5 > + (object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4), pick(arg5) ) ); +} + +// ---------------------------------------- + +template struct Callback5Action { Atomic count; @@ -174,39 +309,3 @@ Callback5::~Callback5() { Release(); } - - - -template < class X, class T1, class T2, class T3, class T4, class T5, class HC = X > - -struct CallbackActionCallArg5 : public CallbackAction -{ - X x; - T1 arg1; - T2 arg2; - T3 arg3; - T4 arg4; - T5 arg5; - void Execute() - { - x ( arg1, arg2, arg3, arg4, arg5 ); - } - - CallbackActionCallArg5 ( X x, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) - : x ( x ), arg1 ( arg1 ), arg2 ( arg2 ), arg3 ( arg3 ), arg4 ( arg4 ), arg5 ( arg5 ) {} -}; - - -template -Callback callback5 ( void ( *fn ) ( Q1, Q2, Q3, Q4, Q5 ), T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) -{ - return Callback ( - new CallbackActionCallArg5 < void ( * ) ( Q1, Q2, Q3, Q4, Q5 ), T1, T2, T3, T4, T5, uintptr_t > ( fn, arg1, arg2, arg3, arg4, arg5 ) ); -} - -template -Callback callback5 ( Callback5 cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 ) -{ - return Callback ( - new CallbackActionCallArg5, T1, T2, T3, T4, T5> ( cb, arg1, arg2, arg3, arg4, arg5 ) ); -} diff --git a/uppsrc/Core/Core.upp b/uppsrc/Core/Core.upp index 16c130529..bc3befb94 100644 --- a/uppsrc/Core/Core.upp +++ b/uppsrc/Core/Core.upp @@ -99,8 +99,8 @@ file InMap.hpp, Tuple.h, Other.h, - Concretes readonly separator, Cbgen.h, + Callbacks readonly separator, Callback0.h, Callback1.h, Callback2.h, @@ -109,6 +109,7 @@ file Callback5.h, Callback.h, Callback.cpp optimize_speed, + Concretes readonly separator, TimeDate.h, TimeDate.cpp optimize_speed, Value.h,