github-starred/ultimatepp
2
0
Fork 0
mirror of https://github.com/ultimatepp/ultimatepp.git synced 2026-07-11 22:03:01 -06:00
Code Issues 33 Projects Packages Wiki Activity Actions

.refactoring Callbacks

Browse source 
git-svn-id: svn://ultimatepp.org/upp/trunk@9268 f0d560ea-af0d-0410-9eb7-867de7ffcac7
This commit is contained in:
cxl 2015-12-06 23:54:31 +00:00
parent 5a65958d08
commit ff36be0324
7 changed files with 1112 additions and 600 deletions
Download patch file Download diff file Expand all files Collapse all files

50
uppsrc/Core/Callback0.h
View file

@ -16,6 +16,11 @@ Callback pteback(O *object, void (M::*method)()) {
return Callback(new CallbackMethodActionPte<O, void (M::*)()>(object, method));
}
template <class O, class M>
Callback pteback(O *object, void (M::*method)() const) {
return Callback(new CallbackMethodActionPte<O, void (M::*)() const>(object, method));
}
template <class O, class M>
struct CallbackMethodAction : public CallbackAction {
O *object;
@ -77,6 +82,11 @@ Callback1<P1> pteback(O *object, void (M::*method)(P1 p1)) {
return Callback1<P1>(new Callback1MethodActionPte<O, void (M::*)(P1 p1), P1>(object, method));
}
template <class O, class M, class P1>
Callback1<P1> pteback(O *object, void (M::*method)(P1 p1) const) {
return Callback1<P1>(new Callback1MethodActionPte<O, void (M::*)(P1 p1) const, P1>(object, method));
}
template <class O, class M, class P1>
struct Callback1MethodAction : public Callback1Action<P1> {
O *object;
@ -145,6 +155,11 @@ Callback2<P1, P2> pteback(O *object, void (M::*method)(P1 p1, P2 p2)) {
return Callback2<P1, P2>(new Callback2MethodActionPte<O, void (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
}
template <class O, class M, class P1, class P2>
Callback2<P1, P2> pteback(O *object, void (M::*method)(P1 p1, P2 p2) const) {
return Callback2<P1, P2>(new Callback2MethodActionPte<O, void (M::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
}
template <class O, class M, class P1, class P2>
struct Callback2MethodAction : public Callback2Action<P1, P2> {
O *object;
@ -213,6 +228,11 @@ Callback3<P1, P2, P3> pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3))
return Callback3<P1, P2, P3>(new Callback3MethodActionPte<O, void (M::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
}
template <class O, class M, class P1, class P2, class P3>
Callback3<P1, P2, P3> pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3) const) {
return Callback3<P1, P2, P3>(new Callback3MethodActionPte<O, void (M::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
}
template <class O, class M, class P1, class P2, class P3>
struct Callback3MethodAction : public Callback3Action<P1, P2, P3> {
O *object;
@ -281,6 +301,11 @@ Callback4<P1, P2, P3, P4> pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionPte<O, void (M::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
}
template <class O, class M, class P1, class P2, class P3, class P4>
Callback4<P1, P2, P3, P4> pteback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionPte<O, void (M::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
}
template <class O, class M, class P1, class P2, class P3, class P4>
struct Callback4MethodAction : public Callback4Action<P1, P2, P3, P4> {
O *object;
@ -370,6 +395,11 @@ Gate pteback(O *object, bool (M::*method)()) {
return Gate(new GateMethodActionPte<O, bool (M::*)()>(object, method));
}
template <class O, class M>
Gate pteback(O *object, bool (M::*method)() const) {
return Gate(new GateMethodActionPte<O, bool (M::*)() const>(object, method));
}
template <class O, class M>
Gate callback(O *object, bool (M::*method)()) {
return Gate(new GateMethodAction<O, bool (M::*)()>(object, method));
@ -413,6 +443,11 @@ Gate1<P1> pteback(O *object, bool (M::*method)(P1 p1)) {
return Gate1<P1>(new Gate1MethodActionPte<O, bool (M::*)(P1 p1), P1>(object, method));
}
template <class O, class M, class P1>
Gate1<P1> pteback(O *object, bool (M::*method)(P1 p1) const) {
return Gate1<P1>(new Gate1MethodActionPte<O, bool (M::*)(P1 p1) const, P1>(object, method));
}
template <class O, class M, class P1>
struct Gate1MethodAction : public Gate1Action<P1> {
O *object;
@ -481,6 +516,11 @@ Gate2<P1, P2> pteback(O *object, bool (M::*method)(P1 p1, P2 p2)) {
return Gate2<P1, P2>(new Gate2MethodActionPte<O, bool (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
}
template <class O, class M, class P1, class P2>
Gate2<P1, P2> pteback(O *object, bool (M::*method)(P1 p1, P2 p2) const) {
return Gate2<P1, P2>(new Gate2MethodActionPte<O, bool (M::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
}
template <class O, class M, class P1, class P2>
struct Gate2MethodAction : public Gate2Action<P1, P2> {
O *object;
@ -549,6 +589,11 @@ Gate3<P1, P2, P3> pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3)) {
return Gate3<P1, P2, P3>(new Gate3MethodActionPte<O, bool (M::*)(P1 p1, P2 p2, P3 p3), P1, P2, P3>(object, method));
}
template <class O, class M, class P1, class P2, class P3>
Gate3<P1, P2, P3> pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3) const) {
return Gate3<P1, P2, P3>(new Gate3MethodActionPte<O, bool (M::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
}
template <class O, class M, class P1, class P2, class P3>
struct Gate3MethodAction : public Gate3Action<P1, P2, P3> {
O *object;
@ -617,6 +662,11 @@ Gate4<P1, P2, P3, P4> pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3,
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionPte<O, bool (M::*)(P1 p1, P2 p2, P3 p3, P4 p4), P1, P2, P3, P4>(object, method));
}
template <class O, class M, class P1, class P2, class P3, class P4>
Gate4<P1, P2, P3, P4> pteback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionPte<O, bool (M::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
}
template <class O, class M, class P1, class P2, class P3, class P4>
struct Gate4MethodAction : public Gate4Action<P1, P2, P3, P4> {
O *object;

250
uppsrc/Core/Callback1.h
View file

@ -17,6 +17,11 @@ Callback pteback1(O *object, void (M::*method)(Q), T arg) {
return Callback(new CallbackMethodActionArgPte<O, void (M::*)(Q), T>(object, method, pick(arg)));
}
template <class O, class M, class Q, class T>
Callback pteback1(O *object, void (M::*method)(Q) const, T arg) {
return Callback(new CallbackMethodActionArgPte<O, void (M::*)(Q) const, T>(object, method, pick(arg)));
}
template <class O, class M, class T>
struct CallbackMethodActionArg : public CallbackAction {
O *object;
@ -36,9 +41,9 @@ Callback callback1(O *object, void (M::*method)(Q), T arg) {
}
template <class O, class M, class Q, class T>
Callback callback1(const O *object, void (M::*method)(Q) const, T arg) {
return Callback(new CallbackMethodActionArg<const O, void (M::*)(Q) const, T>
(object, method, arg));
Callback callback1(O *object, void (M::*method)(Q) const, T arg) {
return Callback(new CallbackMethodActionArg<O, void (M::*)(Q) const, T>
(object, method, pick(arg)));
}
template <class F, class T, class HC = F>
@ -81,6 +86,11 @@ Callback1<P1> pteback1(O *object, void (M::*method)(P1, Q), T arg) {
return Callback1<P1>(new Callback1MethodActionArgPte<O, void (M::*)(P1, Q), P1, T> (object, method, pick(arg)));
}
template <class O, class M, class P1, class Q, class T>
Callback1<P1> pteback1(O *object, void (M::*method)(P1, Q) const, T arg) {
return Callback1<P1>(new Callback1MethodActionArgPte<O, void (M::*)(P1, Q) const, P1, T> (object, method, pick(arg)));
}
template <class O, class M, class P1, class T>
struct Callback1MethodActionArg : public Callback1Action<P1> {
O *object;
@ -99,8 +109,8 @@ Callback1<P1> callback1(O *object, void (M::*method)(P1, Q), T arg) {
}
template <class O, class M, class P1, class Q, class T>
Callback1<P1> callback1(const O *object, void (M::*method)(P1, Q) const, T arg) {
return Callback1<P1>(new Callback1MethodActionArg<const O, void (M::*)(P1, Q) const, P1, T>
Callback1<P1> callback1(O *object, void (M::*method)(P1, Q) const, T arg) {
return Callback1<P1>(new Callback1MethodActionArg<O, void (M::*)(P1, Q) const, P1, T>
(object, method, pick(arg)));
}
@ -143,6 +153,11 @@ Callback2<P1, P2> pteback1(O *object, void (M::*method)(P1, P2, Q), T arg) {
return Callback2<P1, P2>(new Callback2MethodActionArgPte<O, void (M::*)(P1, P2, Q), P1, P2, T> (object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class Q, class T>
Callback2<P1, P2> pteback1(O *object, void (M::*method)(P1, P2, Q) const, T arg) {
return Callback2<P1, P2>(new Callback2MethodActionArgPte<O, void (M::*)(P1, P2, Q) const, P1, P2, T> (object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class T>
struct Callback2MethodActionArg : public Callback2Action<P1, P2> {
O *object;
@ -161,8 +176,8 @@ Callback2<P1, P2> callback1(O *object, void (M::*method)(P1, P2, Q), T arg) {
}
template <class O, class M, class P1, class P2, class Q, class T>
Callback2<P1, P2> callback1(const O *object, void (M::*method)(P1, P2, Q) const, T arg) {
return Callback2<P1, P2>(new Callback2MethodActionArg<const O, void (M::*)(P1, P2, Q) const, P1, P2, T>
Callback2<P1, P2> callback1(O *object, void (M::*method)(P1, P2, Q) const, T arg) {
return Callback2<P1, P2>(new Callback2MethodActionArg<O, void (M::*)(P1, P2, Q) const, P1, P2, T>
(object, method, pick(arg)));
}
@ -206,6 +221,12 @@ Callback3<P1, P2, P3> pteback1(O *object, void (M::*method)(P1, P2, P3, Q), T ar
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class Q, class T>
Callback3<P1, P2, P3> pteback1(O *object, void (M::*method)(P1, P2, P3, Q) const, T arg) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArgPte<O, void (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class T>
struct Callback3MethodActionArg : public Callback3Action<P1, P2, P3> {
O *object;
@ -224,8 +245,8 @@ Callback3<P1, P2, P3> callback1(O *object, void (M::*method)(P1, P2, P3, Q), T a
}
template <class O, class M, class P1, class P2, class P3, class Q, class T>
Callback3<P1, P2, P3> callback1(const O *object, void (M::*method)(P1, P2, P3, Q) const, T arg) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg<const O, void (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
Callback3<P1, P2, P3> callback1(O *object, void (M::*method)(P1, P2, P3, Q) const, T arg) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg<O, void (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
(object, method, pick(arg)));
}
@ -269,6 +290,12 @@ Callback4<P1, P2, P3, P4> pteback1(O *object, void (M::*method)(P1, P2, P3, P4,
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
Callback4<P1, P2, P3, P4> pteback1(O *object, void (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArgPte<O, void (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class T>
struct Callback4MethodActionArg : public Callback4Action<P1, P2, P3, P4> {
O *object;
@ -287,8 +314,8 @@ Callback4<P1, P2, P3, P4> callback1(O *object, void (M::*method)(P1, P2, P3, P4,
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
Callback4<P1, P2, P3, P4> callback1(const O *object, void (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg<const O, void (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
Callback4<P1, P2, P3, P4> callback1(O *object, void (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg<O, void (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
(object, method, pick(arg)));
}
@ -315,62 +342,67 @@ template <class O, class M, class T>
struct GateMethodActionArgPte : public GateAction {
Ptr<O> 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 <class O, class M, class Q, class T>
Gate pteback1(O *object, bool (M::*method)(Q), T arg) {
return Gate(new GateMethodActionArgPte<O, bool (M::*)(Q), T>(object, method, arg));
return Gate(new GateMethodActionArgPte<O, bool (M::*)(Q), T>(object, method, pick(arg)));
}
template <class O, class M, class Q, class T>
Gate pteback1(O *object, bool (M::*method)(Q) const, T arg) {
return Gate(new GateMethodActionArgPte<O, bool (M::*)(Q) const, T>(object, method, pick(arg)));
}
template <class O, class M, class T>
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 <class O, class M, class Q, class T>
Gate callback1(O *object, bool (M::*method)(Q), T arg) {
return Gate(new GateMethodActionArg<O, bool (M::*)(Q), T>
(object, method, arg));
(object, method, pick(arg)));
}
template <class O, class M, class Q, class T>
Gate callback1(const O *object, bool (M::*method)(Q) const, T arg) {
return Gate(new GateMethodActionArg<const O, bool (M::*)(Q) const, T>
(object, method, arg));
Gate callback1(O *object, bool (M::*method)(Q) const, T arg) {
return Gate(new GateMethodActionArg<O, bool (M::*)(Q) const, T>
(object, method, pick(arg)));
}
template <class F, class T, class HC = F>
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 <class Q, class T>
Gate callback1(bool (*fn)(Q), T arg)
{
return Gate(new GateActionCallArg<bool (*)(Q), T, uintptr_t>(fn, arg));
return Gate(new GateActionCallArg<bool (*)(Q), T, uintptr_t>(fn, pick(arg)));
}
//reduct
template <class Q, class T>
Gate callback1(Gate1<Q> cb, T arg)
{
return Gate(new GateActionCallArg<Gate1<Q>, T>(cb, arg));
return Gate(new GateActionCallArg<Gate1<Q>, T>(cb, pick(arg)));
}
//1 arg to Gate1
@ -379,85 +411,113 @@ template <class O, class M, class P1, class T>
struct Gate1MethodActionArgPte : public Gate1Action<P1> {
Ptr<O> 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 <class O, class M, class P1, class Q, class T>
Gate1<P1> pteback1(O *object, bool (M::*method)(P1, Q), T arg) {
return Gate1<P1>(new Gate1MethodActionArgPte<O, bool (M::*)(P1, Q), P1, T> (object, method, arg));
return Gate1<P1>(new Gate1MethodActionArgPte<O, bool (M::*)(P1, Q), P1, T> (object, method, pick(arg)));
}
template <class O, class M, class P1, class Q, class T>
Gate1<P1> pteback1(O *object, bool (M::*method)(P1, Q) const, T arg) {
return Gate1<P1>(new Gate1MethodActionArgPte<O, bool (M::*)(P1, Q) const, P1, T> (object, method, pick(arg)));
}
template <class O, class M, class P1, class T>
struct Gate1MethodActionArg : public Gate1Action<P1> {
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 <class O, class M, class P1, class Q, class T>
Gate1<P1> callback1(O *object, bool (M::*method)(P1, Q), T arg) {
return Gate1<P1>(new Gate1MethodActionArg<O, bool (M::*)(P1, Q), P1, T>
(object, method, arg));
(object, method, pick(arg)));
}
template <class O, class M, class P1, class Q, class T>
Gate1<P1> callback1(const O *object, bool (M::*method)(P1, Q) const, T arg) {
return Gate1<P1>(new Gate1MethodActionArg<const O, bool (M::*)(P1, Q) const, P1, T>
(object, method, arg));
Gate1<P1> callback1(O *object, bool (M::*method)(P1, Q) const, T arg) {
return Gate1<P1>(new Gate1MethodActionArg<O, bool (M::*)(P1, Q) const, P1, T>
(object, method, pick(arg)));
}
template <class F, class P1, class T, class HC = F>
struct Gate1ActionCallArg : public Gate1Action<P1> {
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 <class P1, class Q, class T>
Gate1<P1> callback1(bool (*fn)(P1, Q), T arg)
{
return Gate1<P1>(new Gate1ActionCallArg<bool (*)(P1, Q), P1, T, uintptr_t>(fn, arg));
return Gate1<P1>(new Gate1ActionCallArg<bool (*)(P1, Q), P1, T, uintptr_t>(fn, pick(arg)));
}
//reduct
template <class P1, class Q, class T>
Gate1<P1> callback1(Gate2<P1, Q> cb, T arg) {
return Gate1<P1>(new Gate1ActionCallArg<Gate2<P1, Q>, P1, T>(cb, arg));
return Gate1<P1>(new Gate1ActionCallArg<Gate2<P1, Q>, P1, T>(cb, pick(arg)));
}
//1 arg to Gate2
template <class O, class M, class P1, class P2, class T>
struct Gate2MethodActionArgPte : public Gate2Action<P1, P2> {
Ptr<O> 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 <class O, class M, class P1, class P2, class Q, class T>
Gate2<P1, P2> pteback1(O *object, bool (M::*method)(P1, P2, Q), T arg) {
return Gate2<P1, P2>(new Gate2MethodActionArgPte<O, bool (M::*)(P1, P2, Q), P1, P2, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class Q, class T>
Gate2<P1, P2> pteback1(O *object, bool (M::*method)(P1, P2, Q) const, T arg) {
return Gate2<P1, P2>(new Gate2MethodActionArgPte<O, bool (M::*)(P1, P2, Q) const, P1, P2, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class T>
struct Gate2MethodActionArg : public Gate2Action<P1, P2> {
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 <class O, class M, class P1, class P2, class Q, class T>
Gate2<P1, P2> callback1(O *object, bool (M::*method)(P1, P2, Q), T arg) {
return Gate2<P1, P2>(new Gate2MethodActionArg<O, bool (M::*)(P1, P2, Q), P1, P2, T>
(object, method, arg));
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class Q, class T>
Gate2<P1, P2> callback1(const O *object, bool (M::*method)(P1, P2, Q) const, T arg) {
return Gate2<P1, P2>(new Gate2MethodActionArg<const O, bool (M::*)(P1, P2, Q) const, P1, P2, T>
(object, method, arg));
Gate2<P1, P2> callback1(O *object, bool (M::*method)(P1, P2, Q) const, T arg) {
return Gate2<P1, P2>(new Gate2MethodActionArg<O, bool (M::*)(P1, P2, Q) const, P1, P2, T>
(object, method, pick(arg)));
}
template <class F, class P1, class P2, class T, class HC = F>
@ -466,23 +526,46 @@ struct Gate2ActionCallArg : Gate2Action<P1, P2> {
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 <class P1, class P2, class Q, class T>
Gate2<P1, P2> callback1(bool (*fn)(P1, P2, Q), T arg)
{
return Gate2<P1, P2>(new Gate2ActionCallArg<bool (*)(P1, P2, Q), P1, P2, T, uintptr_t>(fn, arg));
return Gate2<P1, P2>(new Gate2ActionCallArg<bool (*)(P1, P2, Q), P1, P2, T, uintptr_t>(fn, pick(arg)));
}
//reduct
template <class P1, class P2, class Q, class T>
Gate2<P1, P2> callback1(Gate3<P1, P2, Q> cb, T arg) {
return Gate2<P1, P2>(new Gate2ActionCallArg<Gate3<P1, P2, Q>, P1, P2, T>(cb, arg));
return Gate2<P1, P2>(new Gate2ActionCallArg<Gate3<P1, P2, Q>, P1, P2, T>(cb, pick(arg)));
}
//1 arg to Gate3
template <class O, class M, class P1, class P2, class P3, class T>
struct Gate3MethodActionArgPte : public Gate3Action<P1, P2, P3> {
Ptr<O> 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 <class O, class M, class P1, class P2, class P3, class Q, class T>
Gate3<P1, P2, P3> pteback1(O *object, bool (M::*method)(P1, P2, P3, Q), T arg) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArgPte<O, bool (M::*)(P1, P2, P3, Q), P1, P2, P3, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class Q, class T>
Gate3<P1, P2, P3> pteback1(O *object, bool (M::*method)(P1, P2, P3, Q) const, T arg) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArgPte<O, bool (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class T>
struct Gate3MethodActionArg : public Gate3Action<P1, P2, P3> {
O *object;
@ -491,65 +574,88 @@ struct Gate3MethodActionArg : public Gate3Action<P1, P2, P3> {
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 <class O, class M, class P1, class P2, class P3, class Q, class T>
Gate3<P1, P2, P3> callback1(O *object, bool (M::*method)(P1, P2, P3, Q), T arg) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg<O, bool (M::*)(P1, P2, P3, Q), P1, P2, P3, T>
(object, method, arg));
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class Q, class T>
Gate3<P1, P2, P3> callback1(const O *object, bool (M::*method)(P1, P2, P3, Q) const, T arg) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg<const O, bool (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
(object, method, arg));
Gate3<P1, P2, P3> callback1(O *object, bool (M::*method)(P1, P2, P3, Q) const, T arg) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg<O, bool (M::*)(P1, P2, P3, Q) const, P1, P2, P3, T>
(object, method, pick(arg)));
}
template <class F, class P1, class P2, class P3, class T, class HC = F>
struct Gate3ActionCallArg : Gate3Action<P1, P2, P3> {
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 <class P1, class P2, class P3, class Q, class T>
Gate3<P1, P2, P3> callback1(bool (*fn)(P1, P2, P3, Q), T arg)
{
return Gate3<P1, P2, P3>(new Gate3ActionCallArg<bool (*)(P1, P2, P3, Q), P1, P2, P3, T, uintptr_t>(fn, arg));
return Gate3<P1, P2, P3>(new Gate3ActionCallArg<bool (*)(P1, P2, P3, Q), P1, P2, P3, T, uintptr_t>(fn, pick(arg)));
}
//reduct
template <class P1, class P2, class P3, class Q, class T>
Gate3<P1, P2, P3> callback1(Gate4<P1, P2, P3, Q> cb, T arg) {
return Gate3<P1, P2, P3>(new Gate3ActionCallArg<Gate4<P1, P2, P3, Q>, P1, P2, P3, T>(cb, arg));
return Gate3<P1, P2, P3>(new Gate3ActionCallArg<Gate4<P1, P2, P3, Q>, P1, P2, P3, T>(cb, pick(arg)));
}
//1 arg to Gate4
template <class O, class M, class P1, class P2, class P3, class P4, class T>
struct Gate4MethodActionArgPte : public Gate4Action<P1, P2, P3, P4> {
Ptr<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; }
Gate4MethodActionArgPte(O *object, M method, T arg)
: object(object), method(method), arg(pick(arg)) {}
};
template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
Gate4<P1, P2, P3, P4> pteback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q), T arg) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArgPte<O, bool (M::*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
Gate4<P1, P2, P3, P4> pteback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArgPte<O, bool (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class T>
struct Gate4MethodActionArg : public Gate4Action<P1, P2, P3, P4> {
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 <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
Gate4<P1, P2, P3, P4> callback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q), T arg) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg<O, bool (M::*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T>
(object, method, arg));
(object, method, pick(arg)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
Gate4<P1, P2, P3, P4> callback1(const O *object, bool (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg<const O, bool (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
(object, method, arg));
Gate4<P1, P2, P3, P4> callback1(O *object, bool (M::*method)(P1, P2, P3, P4, Q) const, T arg) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg<O, bool (M::*)(P1, P2, P3, P4, Q) const, P1, P2, P3, P4, T>
(object, method, pick(arg)));
}
template <class F, class P1, class P2, class P3, class P4, class T, class HC = F>
@ -558,11 +664,11 @@ struct Gate4ActionCallArg : Gate4Action<P1, P2, P3, P4> {
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 <class P1, class P2, class P3, class P4, class Q, class T>
Gate4<P1, P2, P3, P4> callback1(bool (*fn)(P1, P2, P3, P4, Q), T arg)
{
return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg<bool (*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T, uintptr_t>(fn, arg));
return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg<bool (*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T, uintptr_t>(fn, pick(arg)));
}

498
uppsrc/Core/Callback2.h
View file

@ -4,26 +4,25 @@ template <class O, class M, class T1, class T2>
struct CallbackMethodActionArg2Pte : public CallbackAction {
Ptr<O> 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 <class O, class R, class M, class Q1, class Q2, class T1, class T2>
Callback pteback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2Pte<O, R (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
}
*/
template <class O, class M, class Q1, class Q2, class T1, class T2>
Callback pteback2(O *object, void (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2Pte<O, void (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class Q1, class Q2, class T1, class T2>
Callback pteback2(O *object, void (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2Pte<O, void (M::*)(Q1, Q2) const, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class T1, class T2>
@ -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 <class O, class R, class M, class Q1, class Q2, class T1, class T2>
Callback callback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2<O, R (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
}
template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
Callback callback2(const O *object, R (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2<const O, R (M::*)(Q1, Q2) const, T1, T2>
(object, method, arg1, arg2));
}
*/
template <class O, class M, class Q1, class Q2, class T1, class T2>
Callback callback2(O *object, void (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2<O, void (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class Q1, class Q2, class T1, class T2>
Callback callback2(const O *object, void (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2<const O, void (M::*)(Q1, Q2) const, T1, T2>
(object, method, arg1, arg2));
Callback callback2(O *object, void (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2<O, void (M::*)(Q1, Q2) const, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class T1, class T2, class HC = X>
@ -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 <class R, class Q1, class Q2, class T1, class T2>
Callback callback2(R (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
return Callback(new CallbackActionCallArg2<R (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class Q1, class Q2, class T1, class T2>
Callback callback2(void (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
return Callback(new CallbackActionCallArg2<void (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
return Callback(new CallbackActionCallArg2<void (*)(Q1, Q2), T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
template <class Q1, class Q2, class T1, class T2>
Callback callback2(Callback2<Q1, Q2> cb, T1 arg1, T2 arg2) {
return Callback(new CallbackActionCallArg2<Callback2<Q1, Q2>, T1, T2>(cb, arg1, arg2));
return Callback(new CallbackActionCallArg2<Callback2<Q1, Q2>, T1, T2>(cb, pick(arg1), pick(arg2)));
}
//2 args to Callback1
template <class O, class M, class P1, class T1, class T2>
struct Callback1MethodActionArg2Pte : public Callback1Action<P1> {
Ptr<O> 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 <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Callback1<P1> pteback2(O *object, void (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1MethodActionArg2Pte<O, void (M::*)(P1, Q1, Q2), P1, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Callback1<P1> pteback2(O *object, void (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1MethodActionArg2Pte<O, void (M::*)(P1, Q1, Q2) const, P1, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class T1, class T2>
struct Callback1MethodActionArg2 : public Callback1Action<P1> {
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 <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Callback1<P1> callback2(O *object, void (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1MethodActionArg2<O, void (M::*)(P1, Q1, Q2), P1, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Callback1<P1> callback2(const O *object, void (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1MethodActionArg2<const O, void (M::*)(P1, Q1, Q2) const, P1, T1, T2>
(object, method, arg1, arg2));
Callback1<P1> callback2(O *object, void (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1MethodActionArg2<O, void (M::*)(P1, Q1, Q2) const, P1, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class T1, class T2, class HC = X>
@ -124,28 +126,45 @@ struct Callback1ActionCallArg2 : public Callback1Action<P1> {
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 <class R, class P1, class Q1, class Q2, class T1, class T2>
Callback1<P1> callback2(R (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1ActionCallArg2<R (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class Q1, class Q2, class T1, class T2>
Callback1<P1> callback2(void (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1ActionCallArg2<void (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
return Callback1<P1>(new Callback1ActionCallArg2<void (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
template <class P1, class Q1, class Q2, class T1, class T2>
Callback1<P1> callback2(Callback3<P1, Q1, Q2> cb, T1 arg1, T2 arg2) {
return Callback1<P1>(new Callback1ActionCallArg2<Callback3<P1, Q1, Q2>, P1, T1, T2>(cb, arg1, arg2));
return Callback1<P1>(new Callback1ActionCallArg2<Callback3<P1, Q1, Q2>, P1, T1, T2>(cb, pick(arg1), pick(arg2)));
}
//2 args to Callback2
template <class O, class M, class P1, class P2, class T1, class T2>
struct Callback2MethodActionArg2Pte : public Callback2Action<P1, P2> {
Ptr<O> 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 <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Callback2<P1, P2> pteback2(O *object, void (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2MethodActionArg2Pte<O, void (M::*)(P1, P2, Q1, Q2), P1, P2, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Callback2<P1, P2> pteback2(O *object, void (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2MethodActionArg2Pte<O, void (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class T1, class T2>
struct Callback2MethodActionArg2 : public Callback2Action<P1, P2> {
O *object;
@ -155,19 +174,19 @@ struct Callback2MethodActionArg2 : public Callback2Action<P1, P2> {
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 <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Callback2<P1, P2> callback2(O *object, void (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2MethodActionArg2<O, void (M::*)(P1, P2, Q1, Q2), P1, P2, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Callback2<P1, P2> callback2(const O *object, void (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2MethodActionArg2<const O, void (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
(object, method, arg1, arg2));
Callback2<P1, P2> callback2(O *object, void (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2MethodActionArg2<O, void (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class P2, class T1, class T2, class HC = X>
@ -177,28 +196,45 @@ struct Callback2ActionCallArg2 : public Callback2Action<P1, P2> {
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 <class R, class P1, class P2, class Q1, class Q2, class T1, class T2>
Callback2<P1, P2> callback2(R (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2ActionCallArg2<R (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class P2, class Q1, class Q2, class T1, class T2>
Callback2<P1, P2> callback2(void (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2ActionCallArg2<void (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
return Callback2<P1, P2>(new Callback2ActionCallArg2<void (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
template <class P1, class P2, class Q1, class Q2, class T1, class T2>
Callback2<P1, P2> callback2(Callback4<P1, P2, Q1, Q2> cb, T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new Callback2ActionCallArg2<Callback4<P1, P2, Q1, Q2>, P1, P2, T1, T2>(cb, arg1, arg2));
return Callback2<P1, P2>(new Callback2ActionCallArg2<Callback4<P1, P2, Q1, Q2>, P1, P2, T1, T2>(cb, pick(arg1), pick(arg2)));
}
//2 args to Callback3
template <class O, class M, class P1, class P2, class P3, class T1, class T2>
struct Callback3MethodActionArg2Pte : public Callback3Action<P1, P2, P3> {
Ptr<O> 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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Callback3<P1, P2, P3> pteback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg2Pte<O, void (M::*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Callback3<P1, P2, P3> pteback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg2Pte<O, void (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class T1, class T2>
struct Callback3MethodActionArg2 : public Callback3Action<P1, P2, P3> {
O *object;
@ -208,19 +244,19 @@ struct Callback3MethodActionArg2 : public Callback3Action<P1, P2, P3> {
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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Callback3<P1, P2, P3> callback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg2<O, void (M::*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Callback3<P1, P2, P3> callback2(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg2<const O, void (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
(object, method, arg1, arg2));
Callback3<P1, P2, P3> callback2(O *object, void (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg2<O, void (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class P2, class P3, class T1, class T2, class HC = X>
@ -230,23 +266,40 @@ struct Callback3ActionCallArg2 : public Callback3Action<P1, P2, P3> {
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 <class R, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Callback3<P1, P2, P3> callback2(R (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new Callback3ActionCallArg2<R (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Callback3<P1, P2, P3> callback2(void (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new Callback3ActionCallArg2<void (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
return Callback3<P1, P2, P3>(new Callback3ActionCallArg2<void (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
//2 args to Callback4
template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2>
struct Callback4MethodActionArg2Pte : public Callback4Action<P1, P2, P3, P4> {
Ptr<O> 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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Callback4<P1, P2, P3, P4> pteback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg2Pte<O, void (M::*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Callback4<P1, P2, P3, P4> pteback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg2Pte<O, void (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2>
struct Callback4MethodActionArg2 : public Callback4Action<P1, P2, P3, P4> {
O *object;
@ -256,19 +309,19 @@ struct Callback4MethodActionArg2 : public Callback4Action<P1, P2, P3, P4> {
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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Callback4<P1, P2, P3, P4> callback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg2<O, void (M::*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Callback4<P1, P2, P3, P4> callback2(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg2<const O, void (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
(object, method, arg1, arg2));
Callback4<P1, P2, P3, P4> callback2(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg2<O, void (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class P2, class P3, class P4, class T1, class T2, class HC = X>
@ -278,19 +331,12 @@ struct Callback4ActionCallArg2 : public Callback4Action<P1, P2, P3, P4> {
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 <class R, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Callback4<P1, P2, P3, P4> callback2(R (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new Callback4ActionCallArg2<R (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Callback4<P1, P2, P3, P4> callback2(void (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new Callback4ActionCallArg2<void (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
return Callback4<P1, P2, P3, P4>(new Callback4ActionCallArg2<void (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
// ---------------------------------------------------------
@ -301,27 +347,24 @@ template <class O, class M, class T1, class T2>
struct GateMethodActionArg2Pte : public GateAction {
Ptr<O> 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 <class O, class R, class M, class Q1, class Q2, class T1, class T2>
Gate pteback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2Pte<O, R (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
}
*/
template <class O, class M, class Q1, class Q2, class T1, class T2>
Gate pteback2(O *object, bool (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2Pte<O, bool (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class Q1, class Q2, class T1, class T2>
Gate pteback2(O *object, bool (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2Pte<O, bool (M::*)(Q1, Q2) const, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class T1, class T2>
@ -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 <class O, class R, class M, class Q1, class Q2, class T1, class T2>
Gate callback2(O *object, R (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2<O, R (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
}
template <class O, class R, class M, class Q1, class Q2, class T1, class T2>
Gate callback2(const O *object, R (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2<const O, R (M::*)(Q1, Q2) const, T1, T2>
(object, method, arg1, arg2));
}
*/
template <class O, class M, class Q1, class Q2, class T1, class T2>
Gate callback2(O *object, bool (M::*method)(Q1, Q2), T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2<O, bool (M::*)(Q1, Q2), T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class Q1, class Q2, class T1, class T2>
Gate callback2(const O *object, bool (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2<const O, bool (M::*)(Q1, Q2) const, T1, T2>
(object, method, arg1, arg2));
Gate callback2(O *object, bool (M::*method)(Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate(new GateMethodActionArg2<O, bool (M::*)(Q1, Q2) const, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class T1, class T2, class HC = X>
@ -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 <class R, class Q1, class Q2, class T1, class T2>
Gate callback2(R (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
return Gate(new GateActionCallArg2<R (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class Q1, class Q2, class T1, class T2>
Gate callback2(bool (*fn)(Q1, Q2), T1 arg1, T2 arg2) {
return Gate(new GateActionCallArg2<bool (*)(Q1, Q2), T1, T2, uintptr_t>(fn, arg1, arg2));
return Gate(new GateActionCallArg2<bool (*)(Q1, Q2), T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
template <class Q1, class Q2, class T1, class T2>
Gate callback2(Gate2<Q1, Q2> cb, T1 arg1, T2 arg2) {
return Gate(new GateActionCallArg2<Gate2<Q1, Q2>, T1, T2>(cb, arg1, arg2));
return Gate(new GateActionCallArg2<Gate2<Q1, Q2>, T1, T2>(cb, pick(arg1), pick(arg2)));
}
//2 args to Gate1
template <class O, class M, class P1, class T1, class T2>
struct Gate1MethodActionArg2Pte : public Gate1Action<P1> {
Ptr<O> 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 <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Gate1<P1> pteback2(O *object, bool (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1MethodActionArg2Pte<O, bool (M::*)(P1, Q1, Q2), P1, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Gate1<P1> pteback2(O *object, bool (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1MethodActionArg2Pte<O, bool (M::*)(P1, Q1, Q2) const, P1, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class T1, class T2>
struct Gate1MethodActionArg2 : public Gate1Action<P1> {
O *object;
@ -402,19 +446,19 @@ struct Gate1MethodActionArg2 : public Gate1Action<P1> {
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 <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Gate1<P1> callback2(O *object, bool (M::*method)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1MethodActionArg2<O, bool (M::*)(P1, Q1, Q2), P1, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class Q1, class Q2, class T1, class T2>
Gate1<P1> callback2(const O *object, bool (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1MethodActionArg2<const O, bool (M::*)(P1, Q1, Q2) const, P1, T1, T2>
(object, method, arg1, arg2));
Gate1<P1> callback2(O *object, bool (M::*method)(P1, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1MethodActionArg2<O, bool (M::*)(P1, Q1, Q2) const, P1, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class T1, class T2, class HC = X>
@ -424,29 +468,45 @@ struct Gate1ActionCallArg2 : public Gate1Action<P1> {
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 <class R, class P1, class Q1, class Q2, class T1, class T2>
Gate1<P1> callback2(R (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1ActionCallArg2<R (*)(P1, P2, Q3), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class Q1, class Q2, class T1, class T2>
Gate1<P1> callback2(bool (*fn)(P1, Q1, Q2), T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1ActionCallArg2<bool (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, arg1, arg2));
return Gate1<P1>(new Gate1ActionCallArg2<bool (*)(P1, Q1, Q2), P1, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
template <class P1, class Q1, class Q2, class T1, class T2>
Gate1<P1> callback2(Gate3<P1, Q1, Q2> cb, T1 arg1, T2 arg2) {
return Gate1<P1>(new Gate1ActionCallArg2<Gate3<P1, Q1, Q2>, P1, T1, T2>(cb, arg1, arg2));
return Gate1<P1>(new Gate1ActionCallArg2<Gate3<P1, Q1, Q2>, P1, T1, T2>(cb, pick(arg1), pick(arg2)));
}
//2 args to Gate2
template <class O, class M, class P1, class P2, class T1, class T2>
struct Gate2MethodActionArg2Pte : public Gate2Action<P1, P2> {
Ptr<O> 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 <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Gate2<P1, P2> pteback2(O *object, bool (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2MethodActionArg2Pte<O, bool (M::*)(P1, P2, Q1, Q2), P1, P2, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Gate2<P1, P2> pteback2(O *object, bool (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2MethodActionArg2Pte<O, bool (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class T1, class T2>
struct Gate2MethodActionArg2 : public Gate2Action<P1, P2> {
O *object;
@ -456,19 +516,19 @@ struct Gate2MethodActionArg2 : public Gate2Action<P1, P2> {
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 <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Gate2<P1, P2> callback2(O *object, bool (M::*method)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2MethodActionArg2<O, bool (M::*)(P1, P2, Q1, Q2), P1, P2, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class T1, class T2>
Gate2<P1, P2> callback2(const O *object, bool (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2MethodActionArg2<const O, bool (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
(object, method, arg1, arg2));
Gate2<P1, P2> callback2(O *object, bool (M::*method)(P1, P2, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2MethodActionArg2<O, bool (M::*)(P1, P2, Q1, Q2) const, P1, P2, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class P2, class T1, class T2, class HC = X>
@ -478,29 +538,45 @@ struct Gate2ActionCallArg2 : public Gate2Action<P1, P2> {
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 <class R, class P1, class P2, class Q1, class Q2, class T1, class T2>
Gate2<P1, P2> callback2(R (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2ActionCallArg2<R (*)(P1, P2, Q1, Q1), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class P2, class Q1, class Q2, class T1, class T2>
Gate2<P1, P2> callback2(bool (*fn)(P1, P2, Q1, Q2), T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2ActionCallArg2<bool (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, arg1, arg2));
return Gate2<P1, P2>(new Gate2ActionCallArg2<bool (*)(P1, P2, Q1, Q2), P1, P2, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
template <class P1, class P2, class Q1, class Q2, class T1, class T2>
Gate2<P1, P2> callback2(Gate4<P1, P2, Q1, Q2> cb, T1 arg1, T2 arg2) {
return Gate2<P1, P2>(new Gate2ActionCallArg2<Gate4<P1, P2, Q1, Q2>, P1, P2, T1, T2>(cb, arg1, arg2));
return Gate2<P1, P2>(new Gate2ActionCallArg2<Gate4<P1, P2, Q1, Q2>, P1, P2, T1, T2>(cb, pick(arg1), pick(arg2)));
}
//2 args to Gate3
template <class O, class M, class P1, class P2, class P3, class T1, class T2>
struct Gate3MethodActionArg2Pte : public Gate3Action<P1, P2, P3> {
Ptr<O> 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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Gate3<P1, P2, P3> pteback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg2Pte<O, bool (M::*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Gate3<P1, P2, P3> pteback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg2Pte<O, bool (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class T1, class T2>
struct Gate3MethodActionArg2 : public Gate3Action<P1, P2, P3> {
O *object;
@ -510,19 +586,19 @@ struct Gate3MethodActionArg2 : public Gate3Action<P1, P2, P3> {
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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Gate3<P1, P2, P3> callback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg2<O, bool (M::*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Gate3<P1, P2, P3> callback2(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg2<const O, bool (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
(object, method, arg1, arg2));
Gate3<P1, P2, P3> callback2(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg2<O, bool (M::*)(P1, P2, P3, Q1, Q2) const, P1, P2, P3, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class P2, class P3, class T1, class T2, class HC = X>
@ -532,24 +608,40 @@ struct Gate3ActionCallArg2 : public Gate3Action<P1, P2, P3> {
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 <class R, class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Gate3<P1, P2, P3> callback2(R (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Gate3<P1, P2, P3>(new Gate3ActionCallArg2<R (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class P2, class P3, class Q1, class Q2, class T1, class T2>
Gate3<P1, P2, P3> callback2(bool (*fn)(P1, P2, P3, Q1, Q2), T1 arg1, T2 arg2) {
return Gate3<P1, P2, P3>(new Gate3ActionCallArg2<bool (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, arg1, arg2));
return Gate3<P1, P2, P3>(new Gate3ActionCallArg2<bool (*)(P1, P2, P3, Q1, Q2), P1, P2, P3, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}
//2 args to Gate4
template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2>
struct Gate4MethodActionArg2Pte : public Gate4Action<P1, P2, P3, P4> {
Ptr<O> 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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Gate4<P1, P2, P3, P4> pteback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg2Pte<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Gate4<P1, P2, P3, P4> pteback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg2Pte<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2>
struct Gate4MethodActionArg2 : public Gate4Action<P1, P2, P3, P4> {
O *object;
@ -559,19 +651,19 @@ struct Gate4MethodActionArg2 : public Gate4Action<P1, P2, P3, P4> {
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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Gate4<P1, P2, P3, P4> callback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg2<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2>
(object, method, arg1, arg2));
(object, method, pick(arg1), pick(arg2)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Gate4<P1, P2, P3, P4> callback2(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg2<const O, bool (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
(object, method, arg1, arg2));
Gate4<P1, P2, P3, P4> callback2(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2) const, T1 arg1, T2 arg2) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg2<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2) const, P1, P2, P3, P4, T1, T2>
(object, method, pick(arg1), pick(arg2)));
}
template <class X, class P1, class P2, class P3, class P4, class T1, class T2, class HC = X>
@ -581,18 +673,10 @@ struct Gate4ActionCallArg2 : public Gate4Action<P1, P2, P3, P4> {
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 <class R, class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Gate4<P1, P2, P3, P4> callback2(R (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg2<R (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
}
*/
template <class P1, class P2, class P3, class P4, class Q1, class Q2, class T1, class T2>
Gate4<P1, P2, P3, P4> callback2(bool (*fn)(P1, P2, P3, P4, Q1, Q2), T1 arg1, T2 arg2) {
return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg2<bool (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, arg1, arg2));
return Gate4<P1, P2, P3, P4>(new Gate4ActionCallArg2<bool (*)(P1, P2, P3, P4, Q1, Q2), P1, P2, P3, P4, T1, T2, uintptr_t>(fn, pick(arg1), pick(arg2)));
}

407
uppsrc/Core/Callback3.h
View file

@ -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 <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback pteback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback(new CallbackMethodActionArg3Pte<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback pteback3(O *object, void (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback(new CallbackMethodActionArg3Pte<O, void (M::*)(Q1, Q2, Q3), T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback pteback3(O *object, void (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback(new CallbackMethodActionArg3Pte<O, void (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class T1, class T2, class T3>
@ -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 <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback callback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3)
{
return Callback(
new CallbackMethodActionArg3<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
}
template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback callback3(const O *object, R (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback(new CallbackMethodActionArg3<const O, R (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback callback3(O *object, void (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3)
{
return Callback(
new CallbackMethodActionArg3<O, void (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
new CallbackMethodActionArg3<O, void (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback callback3(const O *object, void (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback(new CallbackMethodActionArg3<const O, void (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(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<O, void (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class X, class T1, class T2, class T3, class HC = X>
@ -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 <class R, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback callback3(R (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback(
new CallbackActionCallArg3<R (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
}
*/
template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback callback3(void (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback(
new CallbackActionCallArg3<void (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
new CallbackActionCallArg3<void (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, pick(arg1), pick(arg2), pick(arg3)));
}
template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback callback3(Callback3<Q1, Q2, Q3> cb, T1 arg1, T2 arg2, T3 arg3) {
return Callback(
new CallbackActionCallArg3<Callback3<Q1, Q2, Q3>, T1, T2, T3>(cb, arg1, arg2, arg3));
new CallbackActionCallArg3<Callback3<Q1, Q2, Q3>, T1, T2, T3>(cb, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Callback1
template <class X, class P1, class T1, class T2, class T3>
struct Callback1FnActionArg3 : public Callback1Action<P1> {
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 <class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback1<P1> callback3(void (*fn)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new Callback1FnActionArg3<void (*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
(fn, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class T1, class T2, class T3>
struct Callback1MethodActionArg3 : public Callback1Action<P1> {
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 <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback1<P1> callback3(O *object, void (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new Callback1MethodActionArg3<O, void (M::*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback1<P1> callback3(const O *object, void (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new Callback1MethodActionArg3<const O, void (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Callback1<P1> callback3(O *object, void (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new Callback1MethodActionArg3<O, void (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class T1, class T2, class T3>
struct Callback1MethodActionArg3Pte : public Callback1Action<P1> {
Ptr<O> 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 <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback1<P1> pteback3(O *object, void (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new Callback1MethodActionArg3Pte<O, void (M::*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback1<P1> pteback3(O *object, void (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new Callback1MethodActionArg3Pte<O, void (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Callback2
template <class X, class P1, class P2, class T1, class T2, class T3>
struct Callback2FnActionArg3 : public Callback2Action<P1, P2> {
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 <class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback2<P1, P2> callback3(void (*fn)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new Callback2FnActionArg3<void (*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
(fn, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class T1, class T2, class T3>
struct Callback2MethodActionArg3 : public Callback2Action<P1, P2> {
O *object;
@ -141,22 +177,47 @@ struct Callback2MethodActionArg3 : public Callback2Action<P1, P2> {
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 <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback2<P1, P2> callback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new Callback2MethodActionArg3<O, void (M::*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback2<P1, P2> callback3(const O *object, void (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new Callback2MethodActionArg3<const O, void (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Callback2<P1, P2> callback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new Callback2MethodActionArg3<O, void (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Callback3
template <class O, class M, class P1, class P2, class T1, class T2, class T3>
struct Callback2MethodActionArg3Pte : public Callback2Action<P1, P2> {
Ptr<O> 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 <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback2<P1, P2> pteback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new Callback2MethodActionArg3Pte<O, void (M::*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback2<P1, P2> pteback3(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new Callback2MethodActionArg3Pte<O, void (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Callback3 (obsolete - we only provide up to 5 parameters of receiving function)
template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3>
struct Callback3MethodActionArg3 : public Callback3Action<P1, P2, P3> {
@ -168,22 +229,40 @@ struct Callback3MethodActionArg3 : public Callback3Action<P1, P2, P3> {
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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback3<P1, P2, P3> callback3(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg3<O, void (M::*)(P1, P2, P3, Q1, Q2, Q3), P1, P2, P3, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback3<P1, P2, P3> callback3(const O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg3<const O, void (M::*)(P1, P2, P3, Q1, Q2, Q3) const, P1, P2, P3, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Callback3<P1, P2, P3> callback3(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg3<O, void (M::*)(P1, P2, P3, Q1, Q2, Q3) const, P1, P2, P3, T1, T2, T3>
(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 <class X, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
struct Callback4FnActionArg3 : public Callback4Action<P1, P2, P3, P4> {
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 <class X, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback4<P1, P2, P3, P4> callback3(void (*fn)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg3<O, void (*)(P1, P2, P3, P4, Q1, Q2, Q3), P1, P2, P3, P4, T1, T2, T3>
(fn, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
struct Callback4MethodActionArg3 : public Callback4Action<P1, P2, P3, P4> {
@ -195,19 +274,19 @@ struct Callback4MethodActionArg3 : public Callback4Action<P1, P2, P3, P4> {
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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback4<P1, P2, P3, P4> callback3(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg3<O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3), P1, P2, P3, P4, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Callback4<P1, P2, P3, P4> callback3(const O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg3<const O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3) const, P1, P2, P3, P4, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Callback4<P1, P2, P3, P4> callback3(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg3<O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3) const, P1, P2, P3, P4, T1, T2, T3>
(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 <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate pteback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate(new GateMethodActionArg3Pte<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate pteback3(O *object, bool (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate(new GateMethodActionArg3Pte<O, bool (M::*)(Q1, Q2, Q3), T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate pteback3(O *object, bool (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate(new GateMethodActionArg3Pte<O, bool (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class T1, class T2, class T3>
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 <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate callback3(O *object, R (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3)
{
return Gate(
new GateMethodActionArg3<O, R (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
}
template <class O, class R, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate callback3(const O *object, R (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate(new GateMethodActionArg3<const O, R (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate callback3(O *object, bool (M::*method)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3)
{
return Gate(
new GateMethodActionArg3<O, bool (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, arg1, arg2, arg3));
new GateMethodActionArg3<O, bool (M::*)(Q1, Q2, Q3), T1, T2, T3>(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate callback3(const O *object, bool (M::*method)(Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate(new GateMethodActionArg3<const O, bool (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(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<O, bool (M::*)(Q1, Q2, Q3) const, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class X, class T1, class T2, class T3, class HC = X>
@ -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 <class R, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate callback3(R (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate(
new GateActionCallArg3<R (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
}
*/
template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate callback3(bool (*fn)(Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate(
new GateActionCallArg3<bool (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
new GateActionCallArg3<bool (*)(Q1, Q2, Q3), T1, T2, T3, uintptr_t>(fn, pick(arg1), pick(arg2), pick(arg3)));
}
template <class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate callback3(Gate3<Q1, Q2, Q3> cb, T1 arg1, T2 arg2, T3 arg3) {
return Gate(
new GateActionCallArg3<Gate3<Q1, Q2, Q3>, T1, T2, T3>(cb, arg1, arg2, arg3));
new GateActionCallArg3<Gate3<Q1, Q2, Q3>, T1, T2, T3>(cb, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Gate1
template <class X, class P1, class T1, class T2, class T3>
struct Gate1FnActionArg3 : public Gate1Action<P1> {
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 <class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate1<P1> callback3(bool (*fn)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate1<P1>(new Gate1FnActionArg3<bool (*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
(fn, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class T1, class T2, class T3>
struct Gate1MethodActionArg3 : public Gate1Action<P1> {
O *object;
@ -331,23 +398,66 @@ struct Gate1MethodActionArg3 : public Gate1Action<P1> {
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 <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate1<P1> callback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate1<P1>(new Gate1MethodActionArg3<O, bool (M::*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate1<P1> callback3(const O *object, bool (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate1<P1>(new Gate1MethodActionArg3<const O, bool (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Gate1<P1> callback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate1<P1>(new Gate1MethodActionArg3<O, bool (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class T1, class T2, class T3>
struct Gate1MethodActionArg3Pte : public Gate1Action<P1> {
Ptr<O> 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 <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate1<P1> pteback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate1<P1>(new Gate1MethodActionArg3Pte<O, bool (M::*)(P1, Q1, Q2, Q3), P1, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate1<P1> pteback3(O *object, bool (M::*method)(P1, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate1<P1>(new Gate1MethodActionArg3Pte<O, bool (M::*)(P1, Q1, Q2, Q3) const, P1, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Gate2
template <class X, class P1, class P2, class T1, class T2, class T3>
struct Gate2FnActionArg3 : public Gate2Action<P1, P2> {
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 <class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate2<P1, P2> callback3(bool (*fn)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate2<P1, P2>(new Gate2FnActionArg3<bool (*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
(fn, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class T1, class T2, class T3>
struct Gate2MethodActionArg3 : public Gate2Action<P1, P2> {
O *object;
@ -358,22 +468,47 @@ struct Gate2MethodActionArg3 : public Gate2Action<P1, P2> {
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 <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate2<P1, P2> callback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate2<P1, P2>(new Gate2MethodActionArg3<O, bool (M::*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate2<P1, P2> callback3(const O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate2<P1, P2>(new Gate2MethodActionArg3<const O, bool (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Gate2<P1, P2> callback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate2<P1, P2>(new Gate2MethodActionArg3<O, bool (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Gate3
template <class O, class M, class P1, class P2, class T1, class T2, class T3>
struct Gate2MethodActionArg3Pte : public Gate2Action<P1, P2> {
Ptr<O> 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 <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate2<P1, P2> pteback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate2<P1, P2>(new Gate2MethodActionArg3Pte<O, bool (M::*)(P1, P2, Q1, Q2, Q3), P1, P2, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate2<P1, P2> pteback3(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate2<P1, P2>(new Gate2MethodActionArg3Pte<O, bool (M::*)(P1, P2, Q1, Q2, Q3) const, P1, P2, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
//3 args to Gate3 (obsolete - we only provide up to 5 parameters of receiving function)
template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3>
struct Gate3MethodActionArg3 : public Gate3Action<P1, P2, P3> {
@ -385,22 +520,22 @@ struct Gate3MethodActionArg3 : public Gate3Action<P1, P2, P3> {
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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate3<P1, P2, P3> callback3(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg3<O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3), P1, P2, P3, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate3<P1, P2, P3> callback3(const O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg3<const O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3) const, P1, P2, P3, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Gate3<P1, P2, P3> callback3(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg3<O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3) const, P1, P2, P3, T1, T2, T3>
(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 <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
struct Gate4MethodActionArg3 : public Gate4Action<P1, P2, P3, P4> {
@ -412,17 +547,17 @@ struct Gate4MethodActionArg3 : public Gate4Action<P1, P2, P3, P4> {
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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate4<P1, P2, P3, P4> callback3(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3), T1 arg1, T2 arg2, T3 arg3) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg3<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3), P1, P2, P3, P4, T1, T2, T3>
(object, method, arg1, arg2, arg3));
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class T1, class T2, class T3>
Gate4<P1, P2, P3, P4> callback3(const O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg3<const O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3) const, P1, P2, P3, P4, T1, T2, T3>
(object, method, arg1, arg2, arg3));
Gate4<P1, P2, P3, P4> callback3(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3) const, T1 arg1, T2 arg2, T3 arg3) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg3<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3) const, P1, P2, P3, P4, T1, T2, T3>
(object, method, pick(arg1), pick(arg2), pick(arg3)));
}

315
uppsrc/Core/Callback4.h
View file

@ -4,29 +4,26 @@ template <class O, class M, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4Pte : public CallbackAction {
Ptr<O> 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 <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback pteback4(O *object, R (M::*method)(Q1, Q2,Q3,Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(new CallbackMethodActionArg4Pte<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback pteback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(new CallbackMethodActionArg4Pte<O, void (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback pteback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(new CallbackMethodActionArg4Pte<O, void (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class T1, class T2, class T3, class T4>
@ -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 <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback callback4(O *object, R (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
return Callback(
new CallbackMethodActionArg4<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
}
template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
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<const O, R (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback callback4(O *object, void (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
return Callback(
new CallbackMethodActionArg4<O, void (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
new CallbackMethodActionArg4<O, void (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
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<const O, void (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(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<O, void (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class X, class T1, class T2, class T3, class T4, class HC = X>
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 <class R, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback callback4(R (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(
new CallbackActionCallArg4<R (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
}
*/
template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback callback4(void (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(
new CallbackActionCallArg4<void (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
new CallbackActionCallArg4<void (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback callback4(Callback4<Q1, Q2, Q3, Q4> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(
new CallbackActionCallArg4<Callback4<Q1, Q2, Q3, Q4>, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4));
new CallbackActionCallArg4<Callback4<Q1, Q2, Q3, Q4>, T1, T2, T3, T4>(cb, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
//4 args to Callback1
template <class X, class P1, class T1, class T2, class T3, class T4>
struct Callback1FnActionArg4 : public Callback1Action<P1> {
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 <class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback1<P1> callback4(void (*fn)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new Callback1FnActionArg4<void (*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
(fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class T1, class T2, class T3, class T4>
struct Callback1MethodActionArg4 : public Callback1Action<P1> {
O *object;
@ -121,22 +112,48 @@ struct Callback1MethodActionArg4 : public Callback1Action<P1> {
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 <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback1<P1> callback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new Callback1MethodActionArg4<O, void (M::*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback1<P1> callback4(const O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new Callback1MethodActionArg4<const O, void (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Callback1<P1> callback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new Callback1MethodActionArg4<O, void (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
//4 args to Callback2
template <class O, class M, class P1, class T1, class T2, class T3, class T4>
struct Callback1MethodActionArg4Pte : public Callback1Action<P1> {
Ptr<O> 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 <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback1<P1> pteback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new Callback1MethodActionArg4Pte<O, void (M::*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback1<P1> pteback4(O *object, void (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new Callback1MethodActionArg4Pte<O, void (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
(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 <class O, class M, class P1, class P2, class T1, class T2, class T3, class T4>
struct Callback2MethodActionArg4 : public Callback2Action<P1, P2> {
@ -149,22 +166,22 @@ struct Callback2MethodActionArg4 : public Callback2Action<P1, P2> {
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 <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback2<P1, P2> callback4(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback2<P1, P2>(new Callback2MethodActionArg4<O, void (M::*)(P1, P2, Q1, Q2, Q3, Q4), P1, P2, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback2<P1, P2> callback4(const O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback2<P1, P2>(new Callback2MethodActionArg4<const O, void (M::*)(P1, P2, Q1, Q2, Q3, Q4) const, P1, P2, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Callback2<P1, P2> callback4(O *object, void (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback2<P1, P2>(new Callback2MethodActionArg4<O, void (M::*)(P1, P2, Q1, Q2, Q3, Q4) const, P1, P2, T1, T2, T3, T4>
(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 <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
struct Callback3MethodActionArg4 : public Callback3Action<P1, P2, P3> {
@ -177,22 +194,22 @@ struct Callback3MethodActionArg4 : public Callback3Action<P1, P2, P3> {
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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback3<P1, P2, P3> callback4(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg4<O, void (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4), P1, P2, P3, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback3<P1, P2, P3> 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<P1, P2, P3>(new Callback3MethodActionArg4<const O, void (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4) const, P1, P2, P3, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Callback3<P1, P2, P3> callback4(O *object, void (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg4<O, void (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4) const, P1, P2, P3, T1, T2, T3, T4>
(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 <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
struct Callback4MethodActionArg4 : public Callback4Action<P1, P2, P3, P4> {
@ -205,19 +222,19 @@ struct Callback4MethodActionArg4 : public Callback4Action<P1, P2, P3, P4> {
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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback4<P1, P2, P3, P4> callback4(O *object, void (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg4<O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), P1, P2, P3, P4, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Callback4<P1, P2, P3, P4> 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<P1, P2, P3, P4>(new Callback4MethodActionArg4<const O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, P1, P2, P3, P4, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Callback4<P1, P2, P3, P4> 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<P1, P2, P3, P4>(new Callback4MethodActionArg4<O, void (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, P1, P2, P3, P4, T1, T2, T3, T4>
(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 <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate pteback4(O *object, R (M::*method)(Q1, Q2,Q3,Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate(new GateMethodActionArg4Pte<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate pteback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate(new GateMethodActionArg4Pte<O, bool (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate pteback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate(new GateMethodActionArg4Pte<O, bool (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class T1, class T2, class T3, class T4>
@ -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 <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate callback4(O *object, R (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
return Gate(
new GateMethodActionArg4<O, R (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
}
template <class O, class R, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
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<const O, R (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
*/
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate callback4(O *object, bool (M::*method)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
return Gate(
new GateMethodActionArg4<O, bool (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
new GateMethodActionArg4<O, bool (M::*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4>(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
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<const O, bool (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(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<O, bool (M::*)(Q1, Q2, Q3, Q4) const, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class X, class T1, class T2, class T3, class T4, class HC = X>
@ -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 <class R, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate callback4(R (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate(
new GateActionCallArg4<R (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
}
*/
template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate callback4(bool (*fn)(Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate(
new GateActionCallArg4<bool (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
new GateActionCallArg4<bool (*)(Q1, Q2, Q3, Q4), T1, T2, T3, T4, uintptr_t>(fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate callback4(Gate4<Q1, Q2, Q3, Q4> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate(
new GateActionCallArg4<Gate4<Q1, Q2, Q3, Q4>, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4));
new GateActionCallArg4<Gate4<Q1, Q2, Q3, Q4>, T1, T2, T3, T4>(cb, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
//4 args to Gate1
template <class X, class P1, class T1, class T2, class T3, class T4>
struct Gate1FnActionArg4 : public Gate1Action<P1> {
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 <class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate1<P1> callback4(bool (*fn)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate1<P1>(new Gate1FnActionArg4<bool (*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
(fn, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class T1, class T2, class T3, class T4>
struct Gate1MethodActionArg4 : public Gate1Action<P1> {
O *object;
@ -342,19 +353,45 @@ struct Gate1MethodActionArg4 : public Gate1Action<P1> {
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 <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate1<P1> callback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate1<P1>(new Gate1MethodActionArg4<O, bool (M::*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate1<P1> callback4(const O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate1<P1>(new Gate1MethodActionArg4<const O, bool (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Gate1<P1> callback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate1<P1>(new Gate1MethodActionArg4<O, bool (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class T1, class T2, class T3, class T4>
struct Gate1MethodActionArg4Pte : public Gate1Action<P1> {
Ptr<O> 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 <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate1<P1> pteback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate1<P1>(new Gate1MethodActionArg4Pte<O, bool (M::*)(P1, Q1, Q2, Q3, Q4), P1, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate1<P1> pteback4(O *object, bool (M::*method)(P1, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate1<P1>(new Gate1MethodActionArg4Pte<O, bool (M::*)(P1, Q1, Q2, Q3, Q4) const, P1, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
//4 args to Gate2
@ -370,19 +407,19 @@ struct Gate2MethodActionArg4 : public Gate2Action<P1, P2> {
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 <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate2<P1, P2> callback4(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate2<P1, P2>(new Gate2MethodActionArg4<O, bool (M::*)(P1, P2, Q1, Q2, Q3, Q4), P1, P2, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class P2, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate2<P1, P2> callback4(const O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate2<P1, P2>(new Gate2MethodActionArg4<const O, bool (M::*)(P1, P2, Q1, Q2, Q3, Q4) const, P1, P2, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Gate2<P1, P2> callback4(O *object, bool (M::*method)(P1, P2, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate2<P1, P2>(new Gate2MethodActionArg4<O, bool (M::*)(P1, P2, Q1, Q2, Q3, Q4) const, P1, P2, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
//4 args to Gate3
@ -398,19 +435,19 @@ struct Gate3MethodActionArg4 : public Gate3Action<P1, P2, P3> {
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 <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate3<P1, P2, P3> callback4(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg4<O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4), P1, P2, P3, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class P2, class P3, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate3<P1, P2, P3> 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<P1, P2, P3>(new Gate3MethodActionArg4<const O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4) const, P1, P2, P3, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Gate3<P1, P2, P3> callback4(O *object, bool (M::*method)(P1, P2, P3, Q1, Q2, Q3, Q4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate3<P1, P2, P3>(new Gate3MethodActionArg4<O, bool (M::*)(P1, P2, P3, Q1, Q2, Q3, Q4) const, P1, P2, P3, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
//4 args to Gate4
@ -426,17 +463,17 @@ struct Gate4MethodActionArg4 : public Gate4Action<P1, P2, P3, P4> {
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 <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate4<P1, P2, P3, P4> callback4(O *object, bool (M::*method)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodActionArg4<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4), P1, P2, P3, P4, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}
template <class O, class M, class P1, class P2, class P3, class P4, class Q1, class Q2, class Q3, class Q4, class T1, class T2, class T3, class T4>
Gate4<P1, P2, P3, P4> 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<P1, P2, P3, P4>(new Gate4MethodActionArg4<const O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, P1, P2, P3, P4, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
Gate4<P1, P2, P3, P4> 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<P1, P2, P3, P4>(new Gate4MethodActionArg4<O, bool (M::*)(P1, P2, P3, P4, Q1, Q2, Q3, Q4) const, P1, P2, P3, P4, T1, T2, T3, T4>
(object, method, pick(arg1), pick(arg2), pick(arg3), pick(arg4)));
}

189
uppsrc/Core/Callback5.h
View file

@ -1,7 +1,27 @@
template <class O, class M, class T1, class T2, class T3, class T4, class T5>
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 <class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class T1, class T2, class T3, class T4, class T5>
struct CallbackMethodActionArg5Pte : public CallbackAction {
Ptr<O> 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 <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class P1, class P2, class P3, class P4, class P5>
template <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class T1, class T2, class T3, class T4, class T5>
struct GateMethodActionArg5Pte : public GateAction {
Ptr<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; }
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 <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class O, class M, class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class P1, class P2, class P3, class P4, class P5>
struct Callback5Action
{
Atomic count;
@ -174,39 +309,3 @@ Callback5<P1, P2, P3, P4, P5>::~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 <class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
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 <class Q1, class Q2, class Q3, class Q4, class Q5, class T1, class T2, class T3, class T4, class T5>
Callback callback5 ( Callback5<Q1, Q2, Q3, Q4, Q5> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
{
return Callback (
new CallbackActionCallArg5<Callback5<Q1, Q2, Q3, Q4, Q5>, T1, T2, T3, T4, T5> ( cb, arg1, arg2, arg3, arg4, arg5 ) );
}

3
uppsrc/Core/Core.upp
View file

@ -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,