github-starred/ultimatepp
2
0
Fork 0
mirror of https://github.com/ultimatepp/ultimatepp.git synced 2026-05-21 06:45:39 -06:00
Code Issues 33 Projects Packages Wiki Activity Actions

+Core: additional callback variants thanks to kohait00

Browse source 
git-svn-id: svn://ultimatepp.org/upp/trunk@3398 f0d560ea-af0d-0410-9eb7-867de7ffcac7
This commit is contained in:
rylek 2011-05-02 23:05:13 +00:00
parent 3db5e8089d
commit a0c02fe485
9 changed files with 2883 additions and 1611 deletions
Download patch file Download diff file Expand all files Collapse all files

72
uppsrc/Core/Callback.cpp
View file

@ -2,18 +2,82 @@
NAMESPACE_UPP
//#BLITZ_APPROVE
#define CPP_PART__
#include "Cbgen.h"
void Callback::Execute() const
{
if(action) action->Execute();
}
Callback& Callback::operator=(const Callback& c)
{
c.Retain();
Release();
action = c.action;
return *this;
}
Callback::Callback(const Callback& c)
{
action = c.action;
Retain();
}
Callback::~Callback()
{
Release();
}
Callback callback(Callback cb1, Callback cb2)
{
return Callback(new CallbackForkAction (cb1, cb2));
}
Callback& operator<<(Callback& a, Callback b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
//
bool Gate::Execute() const
{
return (void *)action == (void *)1 ? true : action ? action->Execute() : false;
}
Gate& Gate::operator=(const Gate& c)
{
c.Retain();
Release();
action = c.action;
return *this;
}
Gate::Gate(const Gate& c)
{
action = c.action;
Retain();
}
Gate::~Gate()
{
Release();
}
Gate callback(Gate cb1, Gate cb2)
{
return Gate(new GateForkAction (cb1, cb2));
}
Gate& operator<<(Gate& a, Gate b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
END_UPP_NAMESPACE

745
uppsrc/Core/Callback.h
View file

@ -4,740 +4,11 @@ template <class D, class S>
inline D brutal_cast(const S& source) { return *(D *)&source; }
#include "Cbgen.h"
template <class OBJECT_, class METHOD_, class T>
struct CallbackMethodActionArgPte : public CallbackAction {
Ptr<OBJECT_> object;
METHOD_ method;
T arg;
void Execute() { if(object) (object->*method)(arg); }
CallbackMethodActionArgPte(OBJECT_ *object, METHOD_ method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class Object, class M, class P, class T>
Callback pteback1(Object *object, void (M::*method)(P), T arg) {
return Callback(new CallbackMethodActionArgPte<Object, void (M::*)(P), T>(object, method, arg));
}
template <class OBJECT_, class METHOD_, class T>
struct CallbackMethodActionArg : public CallbackAction {
OBJECT_ *object;
METHOD_ method;
T arg;
void Execute() { (object->*method)(arg); }
CallbackMethodActionArg(OBJECT_ *object, METHOD_ method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class Object, class M, class P, class T>
Callback callback1(Object *object, void (M::*method)(P), T arg) {
return Callback(new CallbackMethodActionArg<Object, void (M::*)(P), T>
(object, method, arg));
}
template <class Object, class M, class P, class T>
Callback callback1(const Object *object, void (M::*method)(P) const, T arg) {
return Callback(new CallbackMethodActionArg<const Object, void (M::*)(P) const, T>
(object, method, arg));
}
template <class F, class T, class HC = F>
struct CallbackActionCallArg : public CallbackAction {
F fn;
T arg;
void Execute() { fn(arg); }
CallbackActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class T, class P>
Callback callback1(void (*fn)(P), T arg)
{
return Callback(new CallbackActionCallArg<void (*)(P), T, uintptr_t>(fn, arg));
}
template <class OBJECT_, class METHOD_, class P1, class T>
struct CallbackMethodActionArg1Pte : public Callback1Action<P1> {
Ptr<OBJECT_> object;
METHOD_ method;
T arg;
void Execute(P1 p1) { if(object) (object->*method)(p1, arg); }
CallbackMethodActionArg1Pte(OBJECT_ *object, METHOD_ method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class Object, class M, class P1, class P, class T>
Callback1<P1> pteback1(Object *object, void (M::*method)(P1, P), T arg) {
return Callback1<P1>(new CallbackMethodActionArg1Pte<Object, void (M::*)(P1, P), P1, T> (object, method, arg));
}
template <class OBJECT_, class METHOD_, class P1, class T>
struct CallbackMethodActionArg1 : public Callback1Action<P1> {
OBJECT_ *object;
METHOD_ method;
T arg;
void Execute(P1 p1) { (object->*method)(p1, arg); }
CallbackMethodActionArg1(OBJECT_ *object, METHOD_ method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class Object, class M, class P1, class P, class T>
Callback1<P1> callback1(Object *object, void (M::*method)(P1, P), T arg) {
return Callback1<P1>(new CallbackMethodActionArg1<Object, void (M::*)(P1, P), P1, T>
(object, method, arg));
}
template <class Object, class M, class P1, class P, class T>
Callback1<P1> callback1(const Object *object, void (M::*method)(P1, P) const, T arg) {
return Callback1<P1>(new CallbackMethodActionArg1<const Object, void (M::*)(P1, P) const, P1, T>
(object, method, arg));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class T1>
struct CallbackMethodActionArg1_2 : public Callback2Action<P1, P2> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1);}
CallbackMethodActionArg1_2(OBJECT_ *object, METHOD_ method, T1 arg1)
: object(object), method(method), arg1(arg1) {}
};
template <class Object, class M, class P1, class P2, class T1>
Callback2<P1, P2> callback1(Object *object, void (M::*method)(P1, P2, T1), T1 arg1) {
return Callback2<P1, P2>(new CallbackMethodActionArg1_2<Object, void (M::*)(P1, P2, T1), P1, P2, T1>
(object, method, arg1));
}
template <class Object, class M, class P1, class P2, class T1>
Callback2<P1, P2> callback1(const Object *object, void (M::*method)(P1, P2, T1) const, T1 arg1) {
return Callback2<P1, P2>(new CallbackMethodActionArg1_2<const Object, void (M::*)(P1, P2, T1) const, P1, P2, T1>
(object, method, arg1));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1>
struct CallbackMethodActionArg1_3 : public Callback3Action<P1, P2, P3> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1);}
CallbackMethodActionArg1_3(OBJECT_ *object, METHOD_ method, T1 arg1)
: object(object), method(method), arg1(arg1) {}
};
template <class Object, class M, class P1, class P2, class P3, class T1>
Callback3<P1, P2, P3> callback1(Object *object, void (M::*method)(P1, P2, P3, T1), T1 arg1) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg1_3<Object, void (M::*)(P1, P2, P3, T1), P1, P2, P3, T1>
(object, method, arg1));
}
template <class Object, class M, class P1, class P2, class P3, class T1>
Callback3<P1, P2, P3> callback1(const Object *object, void (M::*method)(P1, P2, P3, T1) const, T1 arg1) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg1_3<const Object, void (M::*)(P1, P2, P3, T1) const, P1, P2, P3, T1>
(object, method, arg1));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1>
struct CallbackMethodActionArg1_4 : public Callback4Action<P1, P2, P3, P4> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1);}
CallbackMethodActionArg1_4(OBJECT_ *object, METHOD_ method, T1 arg1)
: object(object), method(method), arg1(arg1) {}
};
template <class Object, class M, class P1, class P2, class P3, class P4, class T1>
Callback4<P1, P2, P3, P4> callback1(Object *object, void (M::*method)(P1, P2, P3, P4, T1), T1 arg1) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg1_4<Object, void (M::*)(P1, P2, P3, P4, T1), P1, P2, P3, P4, T1>
(object, method, arg1));
}
template <class Object, class M, class P1, class P2, class P3, class P4, class T1>
Callback4<P1, P2, P3, P4> callback1(const Object *object, void (M::*method)(P1, P2, P3, P4, T1) const, T1 arg1) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg1_4<const Object, void (M::*)(P1, P2, P3, P4, T1) const, P1, P2, P3, P4, T1>
(object, method, arg1));
}
template <class OBJECT_, class METHOD_, class P1, class T>
struct GateMethodActionArg1 : public Gate1Action<P1> {
OBJECT_ *object;
METHOD_ method;
T arg;
bool Execute(P1 p1) { return (object->*method)(p1, arg); }
GateMethodActionArg1(OBJECT_ *object, METHOD_ method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class Object, class M, class P1, class P, class T>
Gate1<P1> callback1(Object *object, bool (M::*method)(P1, P), T arg) {
return Gate1<P1>(new GateMethodActionArg1<Object, bool (M::*)(P1, P), P1, T>
(object, method, arg));
}
template <class F, class P1, class T, class HC = F>
struct CallbackActionCallArg1 : Callback1Action<P1> {
F fn;
T arg;
void Execute(P1 p1) { fn(p1, arg); }
CallbackActionCallArg1(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class T, class P1, class P>
Callback1<P1> callback1(void (*fn)(P1, P), T arg)
{
return Callback1<P1>(new CallbackActionCallArg1<void (*)(P1, P), P1, T, uintptr_t>(fn, arg));
}
template <class T, class P>
Callback callback1(Callback1<P> cb, T arg)
{
return Callback(new CallbackActionCallArg<Callback1<P>, T>(cb, arg));
}
template <class T, class P1, class P>
Callback1<P1> callback1(Callback2<P1, P> cb, T arg) {
return Callback1<P1>(new CallbackActionCallArg1<Callback2<P1, P>, P1, T>(cb, arg));
}
template <class P1>
bool Gate1<P1>::Execute(P1 p1) const {
return (void *)action == (void *)1 ? true : action ? action->Execute(p1) : false;
}
template <class P1, class P2>
bool Gate2<P1, P2>::Execute(P1 p1, P2 p2) const {
return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2) : false;
}
template <class P1, class P2, class P3>
bool Gate3<P1, P2, P3>::Execute(P1 p1, P2 p2, P3 p3) const {
return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2, p3) : false;
}
template <class P1, class P2, class P3, class P4>
bool Gate4<P1, P2, P3, P4>::Execute(P1 p1, P2 p2, P3 p3, P4 p4) const {
return (void *)action == (void *)1 ? true : action ? action->Execute(p1, p2, p3, p4) : false;
}
template <class OBJECT_, class METHOD_, class T1, class T2>
struct CallbackMethodActionArg2Pte : public CallbackAction {
Ptr<OBJECT_> object;
METHOD_ method;
T1 arg1;
T2 arg2;
void Execute() { if(object) (object->*method)(arg1, arg2); }
CallbackMethodActionArg2Pte(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(arg2) {}
};
template <class Object, class R, class O, class A, class B, class T1, class T2>
Callback pteback2(Object *object, R (O::*method)(A, B), T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2Pte<Object, R (O::*)(A, B), T1, T2>
(object, method, arg1, arg2));
}
template <class OBJECT_, class METHOD_, class T1, class T2>
struct CallbackMethodActionArg2 : public CallbackAction {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
void Execute() { (object->*method)(arg1, arg2); }
CallbackMethodActionArg2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(arg2) {}
};
template <class Object, class R, class O, class A, class B, class T1, class T2>
Callback callback2(Object *object, R (O::*method)(A, B), T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2<Object, R (O::*)(A, B), T1, T2>
(object, method, arg1, arg2));
}
template <class Object, class R, class O, class A, class B, class T1, class T2>
Callback callback2(const Object *object, R (O::*method)(A, B) const, T1 arg1, T2 arg2) {
return Callback(new CallbackMethodActionArg2<const Object, R (O::*)(A, B) const, T1, T2>
(object, method, arg1, arg2));
}
template <class OBJECT_, class METHOD_, class P1, class T1, class T2>
struct CallbackMethodActionArg2_1 : public Callback1Action<P1> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
void Execute(P1 p1) { (object->*method)(p1, arg1, arg2); }
CallbackMethodActionArg2_1(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(arg2) {}
};
template <class Object, class M, class P1, class T1, class T2>
Callback1<P1> callback2(Object *object, void (M::*method)(P1, T1, T2), T1 arg1, T2 arg2) {
return Callback1<P1>(new CallbackMethodActionArg2_1<Object, void (M::*)(P1, T1, T2), P1, T1, T2>
(object, method, arg1, arg2));
}
template <class Object, class M, class P1, class T1, class T2>
Callback1<P1> callback2(const Object *object, void (M::*method)(P1, T1, T2) const, T1 arg1, T2 arg2) {
return Callback1<P1>(new CallbackMethodActionArg2_1<const Object, void (M::*)(P1, T1, T2) const, P1, T1, T2>
(object, method, arg1, arg2));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class T1, class T2>
struct CallbackMethodActionArg2_2 : public Callback2Action<P1, P2> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2);}
CallbackMethodActionArg2_2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(arg2) {}
};
template <class Object, class M, class P1, class P2, class T1, class T2>
Callback2<P1, P2> callback2(Object *object, void (M::*method)(P1, P2, T1, T2), T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new CallbackMethodActionArg2_2<Object, void (M::*)(P1, P2, T1, T2), P1, P2, T1, T2>
(object, method, arg1, arg2));
}
template <class Object, class M, class P1, class P2, class T1, class T2>
Callback2<P1, P2> callback2(const Object *object, void (M::*method)(P1, P2, T1, T2) const, T1 arg1, T2 arg2) {
return Callback2<P1, P2>(new CallbackMethodActionArg2_2<const Object, void (M::*)(P1, P2, T1, T2) const, P1, P2, T1, T2>
(object, method, arg1, arg2));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1, class T2>
struct CallbackMethodActionArg2_3 : public Callback3Action<P1, P2, P3> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2);}
CallbackMethodActionArg2_3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(arg2) {}
};
template <class Object, class M, class P1, class P2, class P3, class T1, class T2>
Callback3<P1, P2, P3> callback2(Object *object, void (M::*method)(P1, P2, P3, T1, T2), T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg2_3<Object, void (M::*)(P1, P2, P3, T1, T2), P1, P2, P3, T1, T2>
(object, method, arg1, arg2));
}
template <class Object, class M, class P1, class P2, class P3, class T1, class T2>
Callback3<P1, P2, P3> callback2(const Object *object, void (M::*method)(P1, P2, P3, T1, T2) const, T1 arg1, T2 arg2) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg2_3<const Object, void (M::*)(P1, P2, P3, T1, T2) const, P1, P2, P3, T1, T2>
(object, method, arg1, arg2));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1, class T2>
struct CallbackMethodActionArg2_4 : public Callback4Action<P1, P2, P3, P4> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2);}
CallbackMethodActionArg2_4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(arg2) {}
};
template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2>
Callback4<P1, P2, P3, P4> callback2(Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2), T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg2_4<Object, void (M::*)(P1, P2, P3, P4, T1, T2), P1, P2, P3, P4, T1, T2>
(object, method, arg1, arg2));
}
template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2>
Callback4<P1, P2, P3, P4> callback2(const Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2) const, T1 arg1, T2 arg2) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg2_4<const Object, void (M::*)(P1, P2, P3, P4, T1, T2) const, P1, P2, P3, P4, T1, T2>
(object, method, arg1, arg2));
}
template <class X, class T1, class T2, class HC = X>
struct CallbackActionCallArg2 : public CallbackAction {
X x;
T1 arg1;
T2 arg2;
void Execute() { x(arg1, arg2); }
CallbackActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(arg2) {}
};
template <class R, class A, class B, class T1, class T2>
Callback callback2(R (*fn)(A, B), T1 arg1, T2 arg2) {
return Callback(new CallbackActionCallArg2<R (*)(A, B), T1, T2, uintptr_t>(fn, arg1, arg2));
}
template <class A, class B, class T1, class T2>
Callback callback2(Callback2<A, B> cb, T1 arg1, T2 arg2) {
return Callback(new CallbackActionCallArg2<Callback2<A, B>, T1, T2>(cb, arg1, arg2));
}
template <class OBJECT_, class METHOD_, class T1, class T2, class T3>
struct CallbackMethodActionArg3Pte : public CallbackAction {
Ptr<OBJECT_> object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
void Execute() { if(object) (object->*method)(arg1, arg2, arg3); }
CallbackMethodActionArg3Pte(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
};
template <class Object, class R, class O, class A, class B,class C, class T1, class T2, class T3>
Callback pteback3(Object *object, R (O::*method)(A, B, C), T1 arg1, T2 arg2, T3 arg3) {
return Callback(new CallbackMethodActionArg3Pte<Object, R (O::*)(A,B,C), T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class OBJECT_, class METHOD_, class T1, class T2, class T3>
struct CallbackMethodActionArg3 : public CallbackAction
{
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
void Execute() { (object->*method)(arg1, arg2, arg3); }
CallbackMethodActionArg3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
};
template <class Object, class R, class O, class A, class B, class C, class T1, class T2, class T3>
Callback callback3(Object *object, R (O::*method)(A, B, C), T1 arg1, T2 arg2, T3 arg3)
{
return Callback(
new CallbackMethodActionArg3<Object, R (O::*)(A, B, C), T1, T2, T3>(object, method, arg1, arg2, arg3));
}
template <class Object, class R, class O, class A, class B, class C, class T1, class T2, class T3>
Callback callback3(const Object *object, R (O::*method)(A, B, C) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback(new CallbackMethodActionArg3<const Object, R (O::*)(A, B, C) const, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class OBJECT_, class METHOD_, class P1, class T1, class T2, class T3>
struct CallbackMethodActionArg3_1 : public Callback1Action<P1> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
void Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3); }
CallbackMethodActionArg3_1(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
};
template <class Object, class M, class P1, class T1, class T2, class T3>
Callback1<P1> callback3(Object *object, void (M::*method)(P1, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new CallbackMethodActionArg3_1<Object, void (M::*)(P1, T1, T2, T3), P1, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class Object, class M, class P1, class T1, class T2, class T3>
Callback1<P1> callback3(const Object *object, void (M::*method)(P1, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback1<P1>(new CallbackMethodActionArg3_1<const Object, void (M::*)(P1, T1, T2, T3) const, P1, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class T1, class T2, class T3>
struct CallbackMethodActionArg3_2 : public Callback2Action<P1, P2> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3);}
CallbackMethodActionArg3_2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
};
template <class Object, class M, class P1, class P2, class T1, class T2, class T3>
Callback2<P1, P2> callback3(Object *object, void (M::*method)(P1, P2, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new CallbackMethodActionArg3_2<Object, void (M::*)(P1, P2, T1, T2, T3), P1, P2, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class Object, class M, class P1, class P2, class T1, class T2, class T3>
Callback2<P1, P2> callback3(const Object *object, void (M::*method)(P1, P2, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback2<P1, P2>(new CallbackMethodActionArg3_2<const Object, void (M::*)(P1, P2, T1, T2, T3) const, P1, P2, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1, class T2, class T3>
struct CallbackMethodActionArg3_3 : public Callback3Action<P1, P2, P3> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3);}
CallbackMethodActionArg3_3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
};
template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3>
Callback3<P1, P2, P3> callback3(Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg3_3<Object, void (M::*)(P1, P2, P3, T1, T2, T3), P1, P2, P3, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3>
Callback3<P1, P2, P3> callback3(const Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg3_3<const Object, void (M::*)(P1, P2, P3, T1, T2, T3) const, P1, P2, P3, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
struct CallbackMethodActionArg3_4 : public Callback4Action<P1, P2, P3, P4> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3);}
CallbackMethodActionArg3_4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3) {}
};
template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
Callback4<P1, P2, P3, P4> callback3(Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3), T1 arg1, T2 arg2, T3 arg3) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg3_4<Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3), P1, P2, P3, P4, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3>
Callback4<P1, P2, P3, P4> callback3(const Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3) const, T1 arg1, T2 arg2, T3 arg3) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg3_4<const Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3) const, P1, P2, P3, P4, T1, T2, T3>
(object, method, arg1, arg2, arg3));
}
template <class X, class T1, class T2, class T3, class HC = X>
struct CallbackActionCallArg3 : public CallbackAction {
X x;
T1 arg1;
T2 arg2;
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) {}
};
template <class R, class A, class B, class C, class T1, class T2, class T3>
Callback callback3(R (*fn)(A, B, C), T1 arg1, T2 arg2, T3 arg3) {
return Callback(
new CallbackActionCallArg3<R (*)(A, B, C), T1, T2, T3, uintptr_t>(fn, arg1, arg2, arg3));
}
template <class A, class B, class C, class T1, class T2, class T3>
Callback callback3(Callback3<A, B, C> cb, T1 arg1, T2 arg2, T3 arg3) {
return Callback(
new CallbackActionCallArg3<Callback3<A, B, C>, T1, T2, T3>(cb, arg1, arg2, arg3));
}
template <class OBJECT_, class METHOD_, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4Pte : public CallbackAction {
Ptr<OBJECT_> object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
void Execute() { if(object) (object->*method)(arg1, arg2, arg3, arg4); }
CallbackMethodActionArg4Pte(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
};
template <class Object, class R, class O, class A, class B,class C, class D, class T1, class T2, class T3, class T4>
Callback pteback4(Object *object, R (O::*method)(A, B,C,D), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(new CallbackMethodActionArg4Pte<Object, R (O::*)(A, B,C,D), T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class OBJECT_, class METHOD_, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4 : public CallbackAction
{
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
void Execute() { (object->*method)(arg1, arg2, arg3, arg4); }
CallbackMethodActionArg4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
};
template <class Object, class R, class O, class A, class B, class C, class D, class T1, class T2, class T3, class T4>
Callback callback4(Object *object, R (O::*method)(A, B, C, D), T1 arg1, T2 arg2, T3 arg3, T4 arg4)
{
return Callback(
new CallbackMethodActionArg4<Object, R (O::*)(A, B, C, D), T1, T2, T3, T4>(object, method, arg1, arg2, arg3, arg4));
}
template <class Object, class R, class O, class A, class B, class C, class D, class T1, class T2, class T3, class T4>
Callback callback4(const Object *object, R (O::*method)(A, B, C, D) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(new CallbackMethodActionArg4<const Object, R (O::*)(A, B,C,D) const, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class OBJECT_, class METHOD_, class P1, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4_1 : public Callback1Action<P1> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
void Execute(P1 p1) { (object->*method)(p1, arg1, arg2, arg3, arg4); }
CallbackMethodActionArg4_1(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
};
template <class Object, class M, class P1, class T1, class T2, class T3, class T4>
Callback1<P1> callback4(Object *object, void (M::*method)(P1, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new CallbackMethodActionArg4_1<Object, void (M::*)(P1, T1, T2, T3, T4), P1, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class Object, class M, class P1, class T1, class T2, class T3, class T4>
Callback1<P1> callback4(const Object *object, void (M::*method)(P1, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback1<P1>(new CallbackMethodActionArg4_1<const Object, void (M::*)(P1, T1, T2, T3, T4) const, P1, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4_2 : public Callback2Action<P1, P2> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg1, arg2, arg3, arg4);}
CallbackMethodActionArg4_2(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
};
template <class Object, class M, class P1, class P2, class T1, class T2, class T3, class T4>
Callback2<P1, P2> callback4(Object *object, void (M::*method)(P1, P2, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback2<P1, P2>(new CallbackMethodActionArg4_2<Object, void (M::*)(P1, P2, T1, T2, T3, T4), P1, P2, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class Object, class M, class P1, class P2, class T1, class T2, class T3, class T4>
Callback2<P1, P2> callback4(const Object *object, void (M::*method)(P1, P2, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback2<P1, P2>(new CallbackMethodActionArg4_2<const Object, void (M::*)(P1, P2, T1, T2, T3, T4) const, P1, P2, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4_3 : public Callback3Action<P1, P2, P3> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
T3 arg4;
void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg1, arg2, arg3, arg4);}
CallbackMethodActionArg4_3(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
};
template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
Callback3<P1, P2, P3> callback4(Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg4_3<Object, void (M::*)(P1, P2, P3, T1, T2, T3, T4), P1, P2, P3, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class Object, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
Callback3<P1, P2, P3> callback4(const Object *object, void (M::*method)(P1, P2, P3, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback3<P1, P2, P3>(new CallbackMethodActionArg4_3<const Object, void (M::*)(P1, P2, P3, T1, T2, T3, T4) const, P1, P2, P3, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class OBJECT_, class METHOD_, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4_4 : public Callback4Action<P1, P2, P3, P4> {
OBJECT_ *object;
METHOD_ method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg1, arg2, arg3, arg4);}
CallbackMethodActionArg4_4(OBJECT_ *object, METHOD_ method, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
};
template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
Callback4<P1, P2, P3, P4> callback4(Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3, T4), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg4_4<Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3, T4), P1, P2, P3, P4, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, arg4));
}
template <class Object, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
Callback4<P1, P2, P3, P4> callback4(const Object *object, void (M::*method)(P1, P2, P3, P4, T1, T2, T3, T4) const, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback4<P1, P2, P3, P4>(new CallbackMethodActionArg4_4<const Object, void (M::*)(P1, P2, P3, P4, T1, T2, T3, T4) const, P1, P2, P3, P4, T1, T2, T3, T4>
(object, method, arg1, arg2, arg3, 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;
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) {}
};
template <class R, class A, class B,class C, class D, class T1, class T2, class T3, class T4>
Callback callback4(R (*fn)(A, B, C, D), T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(
new CallbackActionCallArg4<R (*)(A, B,C,D), T1, T2, T3, T4, uintptr_t>(fn, arg1, arg2, arg3, arg4));
}
template <class A, class B, class C, class D, class T1, class T2, class T3, class T4>
Callback callback4(Callback4<A, B, C, D> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
return Callback(
new CallbackActionCallArg4<Callback4<A, B,C,D>, T1, T2, T3, T4>(cb, arg1, arg2, arg3, arg4));
}
#include "Callback0.h"
#include "Callback1.h"
#include "Callback2.h"
#include "Callback3.h"
#include "Callback4.h"
#define THISBACK(x) callback(this, &CLASSNAME::x)
#define THISBACK1(x, arg) callback1(this, &CLASSNAME::x, arg)
@ -751,6 +22,12 @@ Callback callback4(Callback4<A, B, C, D> cb, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
#define PTEBACK3(m, a, b, c) pteback3(this, &CLASSNAME::m, a, b, c)
#define PTEBACK4(m, a, b, c, d) pteback4(this, &CLASSNAME::m, a, b, c, d)
#define STDBACK(x) callback(&x)
#define STDBACK1(x, arg) callback1(&x, arg)
#define STDBACK2(m, a, b) callback2(&m, a, b)
#define STDBACK3(m, a, b, c) callback3(&m, a, b, c)
#define STDBACK4(m, a, b, c, d) callback4(&m, a, b, c, d)
template <class T>
class CallbackArgTarget
{

808
uppsrc/Core/Callback0.h Normal file
View file

@ -0,0 +1,808 @@
//0 args to Callback
template <class O, class M>
struct CallbackMethodActionPte : public CallbackAction {
Ptr<O> object;
M method;
void Execute() { if(object) (object->*method)(); }
bool IsValid() const { return object; }
CallbackMethodActionPte(O *object, M method) : object(object), method(method) {}
};
template <class O, class M>
Callback pteback(O *object, void (M::*method)()) {
return Callback(new CallbackMethodActionPte<O, void (M::*)()>(object, method));
}
template <class O, class M>
struct CallbackMethodAction : public CallbackAction {
O *object;
M method;
void Execute() { (object->*method)(); }
CallbackMethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M>
Callback callback(O *object, void (M::*method)()) {
return Callback(new CallbackMethodAction<O, void (M::*)()>(object, method));
}
template <class O, class M>
Callback callback(const O *object, void (M::*method)() const) {
return Callback(new CallbackMethodAction<const O, void (M::*)() const>(object, method));
}
struct CallbackFnAction : public CallbackAction {
void (*fn)();
void Execute() { (*fn)(); }
CallbackFnAction(void (*fn)()) : fn(fn) {}
};
inline Callback callback(void (*fn)()) {
return Callback(new CallbackFnAction (fn));
}
struct CallbackForkAction : public CallbackAction {
Callback cb1, cb2;
void Execute() { cb1(); cb2(); }
CallbackForkAction(Callback cb1, Callback cb2)
: cb1(cb1), cb2(cb2) {}
};
inline Callback Proxy(Callback& cb)
{
return callback(&cb, &Callback::Execute);
}
Callback callback(Callback cb1, Callback cb2);
Callback& operator<<(Callback& a, Callback b);
//0 args to Callback1
template <class O, class M, class P1>
struct Callback1MethodActionPte : public Callback1Action<P1> {
Ptr<O> object;
M method;
void Execute(P1 p1) { if(object) (object->*method)(p1); }
bool IsValid() const { return object; }
Callback1MethodActionPte(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1>
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>
struct Callback1MethodAction : public Callback1Action<P1> {
O *object;
M method;
void Execute(P1 p1) { (object->*method)(p1); }
Callback1MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1>
Callback1<P1> callback(O *object, void (M::*method)(P1 p1)) {
return Callback1<P1>(new Callback1MethodAction<O, void (M::*)(P1 p1), P1>(object, method));
}
template <class O, class M, class P1>
Callback1<P1> callback(const O *object, void (M::*method)(P1 p1) const) {
return Callback1<P1>(new Callback1MethodAction<const O, void (M::*)(P1 p1) const, P1>(object, method));
}
template <class P1>
struct Callback1FnAction : public Callback1Action<P1> {
void (*fn)(P1 p1);
void Execute(P1 p1) { (*fn)(p1); }
Callback1FnAction(void (*fn)(P1 p1)) : fn(fn) {}
};
template <class P1>
inline Callback1<P1> callback(void (*fn)(P1 p1)) {
return Callback1<P1>(new Callback1FnAction <P1>(fn));
}
template <class P1>
struct Callback1ForkAction : public Callback1Action<P1> {
Callback1<P1> cb1, cb2;
void Execute(P1 p1) { cb1(p1); cb2(p1); }
Callback1ForkAction(Callback1<P1> cb1, Callback1<P1> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1>
inline Callback1<P1> Proxy(Callback1<P1>& cb)
{
return callback(&cb, &Callback1<P1>::Execute);
}
template <class P1>
Callback1<P1> callback(Callback1<P1> cb1, Callback1<P1> cb2)
{
return Callback1<P1>(new Callback1ForkAction <P1>(cb1, cb2));
}
template <class P1>
Callback1<P1>& operator<<(Callback1<P1>& a, Callback1<P1> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
//0 args to Callback2
template <class O, class M, class P1, class P2>
struct Callback2MethodActionPte : public Callback2Action<P1, P2> {
Ptr<O> object;
M method;
void Execute(P1 p1, P2 p2) { if(object) (object->*method)(p1, p2); }
bool IsValid() const { return object; }
Callback2MethodActionPte(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2>
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>
struct Callback2MethodAction : public Callback2Action<P1, P2> {
O *object;
M method;
void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2); }
Callback2MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2>
Callback2<P1, P2> callback(O *object, void (M::*method)(P1 p1, P2 p2)) {
return Callback2<P1, P2>(new Callback2MethodAction<O, void (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
}
template <class O, class M, class P1, class P2>
Callback2<P1, P2> callback(const O *object, void (M::*method)(P1 p1, P2 p2) const) {
return Callback2<P1, P2>(new Callback2MethodAction<const O, void (M::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
}
template <class P1, class P2>
struct Callback2FnAction : public Callback2Action<P1, P2> {
void (*fn)(P1 p1, P2 p2);
void Execute(P1 p1, P2 p2) { (*fn)(p1, p2); }
Callback2FnAction(void (*fn)(P1 p1, P2 p2)) : fn(fn) {}
};
template <class P1, class P2>
inline Callback2<P1, P2> callback(void (*fn)(P1 p1, P2 p2)) {
return Callback2<P1, P2>(new Callback2FnAction <P1, P2>(fn));
}
template <class P1, class P2>
struct Callback2ForkAction : public Callback2Action<P1, P2> {
Callback2<P1, P2> cb1, cb2;
void Execute(P1 p1, P2 p2) { cb1(p1, p2); cb2(p1, p2); }
Callback2ForkAction(Callback2<P1, P2> cb1, Callback2<P1, P2> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1, class P2>
inline Callback2<P1, P2> Proxy(Callback2<P1, P2>& cb)
{
return callback(&cb, &Callback2<P1, P2>::Execute);
}
template <class P1, class P2>
Callback2<P1, P2> callback(Callback2<P1, P2> cb1, Callback2<P1, P2> cb2)
{
return Callback2<P1, P2>(new Callback2ForkAction <P1, P2>(cb1, cb2));
}
template <class P1, class P2>
Callback2<P1, P2>& operator<<(Callback2<P1, P2>& a, Callback2<P1, P2> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
//0 args to Callback3
template <class O, class M, class P1, class P2, class P3>
struct Callback3MethodActionPte : public Callback3Action<P1, P2, P3> {
Ptr<O> object;
M method;
void Execute(P1 p1, P2 p2, P3 p3) { if(object) (object->*method)(p1, p2, p3); }
bool IsValid() const { return object; }
Callback3MethodActionPte(O *object, M method) : object(object), method(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)) {
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>
struct Callback3MethodAction : public Callback3Action<P1, P2, P3> {
O *object;
M method;
void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3); }
Callback3MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2, class P3>
Callback3<P1, P2, P3> callback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3)) {
return Callback3<P1, P2, P3>(new Callback3MethodAction<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> callback(const O *object, void (M::*method)(P1 p1, P2 p2, P3 p3) const) {
return Callback3<P1, P2, P3>(new Callback3MethodAction<const O, void (M::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
}
template <class P1, class P2, class P3>
struct Callback3FnAction : public Callback3Action<P1, P2, P3> {
void (*fn)(P1 p1, P2 p2, P3 p3);
void Execute(P1 p1, P2 p2, P3 p3) { (*fn)(p1, p2, p3); }
Callback3FnAction(void (*fn)(P1 p1, P2 p2, P3 p3)) : fn(fn) {}
};
template <class P1, class P2, class P3>
inline Callback3<P1, P2, P3> callback(void (*fn)(P1 p1, P2 p2, P3 p3)) {
return Callback3<P1, P2, P3>(new Callback3FnAction <P1, P2, P3>(fn));
}
template <class P1, class P2, class P3>
struct Callback3ForkAction : public Callback3Action<P1, P2, P3> {
Callback3<P1, P2, P3> cb1, cb2;
void Execute(P1 p1, P2 p2, P3 p3) { cb1(p1, p2, p3); cb2(p1, p2, p3); }
Callback3ForkAction(Callback3<P1, P2, P3> cb1, Callback3<P1, P2, P3> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1, class P2, class P3>
inline Callback3<P1, P2, P3> Proxy(Callback3<P1, P2, P3>& cb)
{
return callback(&cb, &Callback3<P1, P2, P3>::Execute);
}
template <class P1, class P2, class P3>
Callback3<P1, P2, P3> callback(Callback3<P1, P2, P3> cb1, Callback3<P1, P2, P3> cb2)
{
return Callback3<P1, P2, P3>(new Callback3ForkAction <P1, P2, P3>(cb1, cb2));
}
template <class P1, class P2, class P3>
Callback3<P1, P2, P3>& operator<<(Callback3<P1, P2, P3>& a, Callback3<P1, P2, P3> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
//0 args to Callback4
template <class O, class M, class P1, class P2, class P3, class P4>
struct Callback4MethodActionPte : public Callback4Action<P1, P2, P3, P4> {
Ptr<O> object;
M method;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { if(object) (object->*method)(p1, p2, p3, p4); }
bool IsValid() const { return object; }
Callback4MethodActionPte(O *object, M method) : object(object), method(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)) {
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>
struct Callback4MethodAction : public Callback4Action<P1, P2, P3, P4> {
O *object;
M method;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4); }
Callback4MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2, class P3, class P4>
Callback4<P1, P2, P3, P4> callback(O *object, void (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodAction<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> callback(const O *object, void (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodAction<const O, void (M::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
}
template <class P1, class P2, class P3, class P4>
struct Callback4FnAction : public Callback4Action<P1, P2, P3, P4> {
void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4);
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (*fn)(p1, p2, p3, p4); }
Callback4FnAction(void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) : fn(fn) {}
};
template <class P1, class P2, class P3, class P4>
inline Callback4<P1, P2, P3, P4> callback(void (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) {
return Callback4<P1, P2, P3, P4>(new Callback4FnAction <P1, P2, P3, P4>(fn));
}
template <class P1, class P2, class P3, class P4>
struct Callback4ForkAction : public Callback4Action<P1, P2, P3, P4> {
Callback4<P1, P2, P3, P4> cb1, cb2;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { cb1(p1, p2, p3, p4); cb2(p1, p2, p3, p4); }
Callback4ForkAction(Callback4<P1, P2, P3, P4> cb1, Callback4<P1, P2, P3, P4> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1, class P2, class P3, class P4>
inline Callback4<P1, P2, P3, P4> Proxy(Callback4<P1, P2, P3, P4>& cb)
{
return callback(&cb, &Callback4<P1, P2, P3, P4>::Execute);
}
template <class P1, class P2, class P3, class P4>
Callback4<P1, P2, P3, P4> callback(Callback4<P1, P2, P3, P4> cb1, Callback4<P1, P2, P3, P4> cb2)
{
return Callback4<P1, P2, P3, P4>(new Callback4ForkAction <P1, P2, P3, P4>(cb1, cb2));
}
template <class P1, class P2, class P3, class P4>
Callback4<P1, P2, P3, P4>& operator<<(Callback4<P1, P2, P3, P4>& a, Callback4<P1, P2, P3, P4> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
// -----------------------------------------------------------
//0 args to Gate
template <class O, class M>
struct GateMethodActionPte : public GateAction {
Ptr<O> object;
M method;
bool Execute() { return object ? (object->*method)() : false; }
bool IsValid() const { return object; }
GateMethodActionPte(O *object, M method) : object(object), method(method) {}
};
template <class O, class M>
struct GateMethodAction : public GateAction {
O *object;
M method;
bool Execute() { return (object->*method)(); }
GateMethodAction(O *object, M method) : object(object), method(method) {}
};
struct GateFnAction : public GateAction {
bool (*fn)();
bool Execute() { return (*fn)(); }
GateFnAction(bool (*fn)()) : fn(fn) {}
};
template <class O, class M>
Gate pteback(O *object, bool (M::*method)()) {
return Gate(new GateMethodActionPte<O, bool (M::*)()>(object, method));
}
template <class O, class M>
Gate callback(O *object, bool (M::*method)()) {
return Gate(new GateMethodAction<O, bool (M::*)()>(object, method));
}
template <class O, class M>
Gate callback(const O *object, bool (M::*method)() const) {
return Gate(new GateMethodAction<const O, bool (M::*)() const>(object, method));
}
inline Gate callback(bool (*fn)()) {
return Gate(new GateFnAction (fn));
}
struct GateForkAction : public GateAction {
Gate cb1, cb2;
bool Execute() { cb1(); return cb2(); }
GateForkAction(Gate cb1, Gate cb2)
: cb1(cb1), cb2(cb2) {}
};
inline Gate Proxy(Gate& cb)
{
return callback(&cb, &Gate::Execute);
}
Gate callback(Gate cb1, Gate cb2);
Gate& operator<<(Gate& a, Gate b);
//0 args to Gate1
template <class O, class M, class P1>
struct Gate1MethodActionPte : public Gate1Action<P1> {
Ptr<O> object;
M method;
bool Execute(P1 p1) { return object ? (object->*method)(p1) : false; }
bool IsValid() const { return object; }
Gate1MethodActionPte(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1>
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>
struct Gate1MethodAction : public Gate1Action<P1> {
O *object;
M method;
bool Execute(P1 p1) { return (object->*method)(p1); }
Gate1MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1>
Gate1<P1> callback(O *object, bool (M::*method)(P1 p1)) {
return Gate1<P1>(new Gate1MethodAction<O, bool (M::*)(P1 p1), P1>(object, method));
}
template <class O, class M, class P1>
Gate1<P1> callback(const O *object, bool (M::*method)(P1 p1) const) {
return Gate1<P1>(new Gate1MethodAction<const O, bool (M::*)(P1 p1) const, P1>(object, method));
}
template <class P1>
struct Gate1FnAction : public Gate1Action<P1> {
bool (*fn)(P1 p1);
bool Execute(P1 p1) { return (*fn)(p1); }
Gate1FnAction(bool (*fn)(P1 p1)) : fn(fn) {}
};
template <class P1>
inline Gate1<P1> callback(bool (*fn)(P1 p1)) {
return Gate1<P1>(new Gate1FnAction <P1>(fn));
}
template <class P1>
struct Gate1ForkAction : public Gate1Action<P1> {
Gate1<P1> cb1, cb2;
bool Execute(P1 p1) { cb1(p1); return cb2(p1); }
Gate1ForkAction(Gate1<P1> cb1, Gate1<P1> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1>
inline Gate1<P1> Proxy(Gate1<P1>& cb)
{
return callback(&cb, &Gate1<P1>::Execute);
}
template <class P1>
Gate1<P1> callback(Gate1<P1> cb1, Gate1<P1> cb2)
{
return Gate1<P1>(new Gate1ForkAction <P1>(cb1, cb2));
}
template <class P1>
Gate1<P1>& operator<<(Gate1<P1>& a, Gate1<P1> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
//0 args to Gate2
template <class O, class M, class P1, class P2>
struct Gate2MethodActionPte : public Gate2Action<P1, P2> {
Ptr<O> object;
M method;
bool Execute(P1 p1, P2 p2) { return object ? (object->*method)(p1, p2) : false; }
bool IsValid() const { return object; }
Gate2MethodActionPte(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2>
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>
struct Gate2MethodAction : public Gate2Action<P1, P2> {
O *object;
M method;
bool Execute(P1 p1, P2 p2) { return (object->*method)(p1, p2); }
Gate2MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2>
Gate2<P1, P2> callback(O *object, bool (M::*method)(P1 p1, P2 p2)) {
return Gate2<P1, P2>(new Gate2MethodAction<O, bool (M::*)(P1 p1, P2 p2), P1, P2>(object, method));
}
template <class O, class M, class P1, class P2>
Gate2<P1, P2> callback(const O *object, bool (M::*method)(P1 p1, P2 p2) const) {
return Gate2<P1, P2>(new Gate2MethodAction<const O, bool (M::*)(P1 p1, P2 p2) const, P1, P2>(object, method));
}
template <class P1, class P2>
struct Gate2FnAction : public Gate2Action<P1, P2> {
bool (*fn)(P1 p1, P2 p2);
bool Execute(P1 p1, P2 p2) { return (*fn)(p1, p2); }
Gate2FnAction(bool (*fn)(P1 p1, P2 p2)) : fn(fn) {}
};
template <class P1, class P2>
inline Gate2<P1, P2> callback(bool (*fn)(P1 p1, P2 p2)) {
return Gate2<P1, P2>(new Gate2FnAction <P1, P2>(fn));
}
template <class P1, class P2>
struct Gate2ForkAction : public Gate2Action<P1, P2> {
Gate2<P1, P2> cb1, cb2;
bool Execute(P1 p1, P2 p2) { cb1(p1, p2); return cb2(p1, p2); }
Gate2ForkAction(Gate2<P1, P2> cb1, Gate2<P1, P2> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1, class P2>
inline Gate2<P1, P2> Proxy(Gate2<P1, P2>& cb)
{
return callback(&cb, &Gate2<P1, P2>::Execute);
}
template <class P1, class P2>
Gate2<P1, P2> callback(Gate2<P1, P2> cb1, Gate2<P1, P2> cb2)
{
return Gate2<P1, P2>(new Gate2ForkAction <P1, P2>(cb1, cb2));
}
template <class P1, class P2>
Gate2<P1, P2>& operator<<(Gate2<P1, P2>& a, Gate2<P1, P2> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
//0 args to Gate3
template <class O, class M, class P1, class P2, class P3>
struct Gate3MethodActionPte : public Gate3Action<P1, P2, P3> {
Ptr<O> object;
M method;
bool Execute(P1 p1, P2 p2, P3 p3) { return object ? (object->*method)(p1, p2, p3) : false; }
bool IsValid() const { return object; }
Gate3MethodActionPte(O *object, M method) : object(object), method(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)) {
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>
struct Gate3MethodAction : public Gate3Action<P1, P2, P3> {
O *object;
M method;
bool Execute(P1 p1, P2 p2, P3 p3) { return (object->*method)(p1, p2, p3); }
Gate3MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2, class P3>
Gate3<P1, P2, P3> callback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3)) {
return Gate3<P1, P2, P3>(new Gate3MethodAction<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> callback(const O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3) const) {
return Gate3<P1, P2, P3>(new Gate3MethodAction<const O, bool (M::*)(P1 p1, P2 p2, P3 p3) const, P1, P2, P3>(object, method));
}
template <class P1, class P2, class P3>
struct Gate3FnAction : public Gate3Action<P1, P2, P3> {
bool (*fn)(P1 p1, P2 p2, P3 p3);
bool Execute(P1 p1, P2 p2, P3 p3) { return (*fn)(p1, p2, p3); }
Gate3FnAction(bool (*fn)(P1 p1, P2 p2, P3 p3)) : fn(fn) {}
};
template <class P1, class P2, class P3>
inline Gate3<P1, P2, P3> callback(bool (*fn)(P1 p1, P2 p2, P3 p3)) {
return Gate3<P1, P2, P3>(new Gate3FnAction <P1, P2, P3>(fn));
}
template <class P1, class P2, class P3>
struct Gate3ForkAction : public Gate3Action<P1, P2, P3> {
Gate3<P1, P2, P3> cb1, cb2;
bool Execute(P1 p1, P2 p2, P3 p3) { cb1(p1, p2, p3); return cb2(p1, p2, p3); }
Gate3ForkAction(Gate3<P1, P2, P3> cb1, Gate3<P1, P2, P3> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1, class P2, class P3>
inline Gate3<P1, P2, P3> Proxy(Gate3<P1, P2, P3>& cb)
{
return callback(&cb, &Gate3<P1, P2, P3>::Execute);
}
template <class P1, class P2, class P3>
Gate3<P1, P2, P3> callback(Gate3<P1, P2, P3> cb1, Gate3<P1, P2, P3> cb2)
{
return Gate3<P1, P2, P3>(new Gate3ForkAction <P1, P2, P3>(cb1, cb2));
}
template <class P1, class P2, class P3>
Gate3<P1, P2, P3>& operator<<(Gate3<P1, P2, P3>& a, Gate3<P1, P2, P3> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}
//0 args to Gate4
template <class O, class M, class P1, class P2, class P3, class P4>
struct Gate4MethodActionPte : public Gate4Action<P1, P2, P3, P4> {
Ptr<O> object;
M method;
bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return object ? (object->*method)(p1, p2, p3, p4) : false; }
bool IsValid() const { return object; }
Gate4MethodActionPte(O *object, M method) : object(object), method(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)) {
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>
struct Gate4MethodAction : public Gate4Action<P1, P2, P3, P4> {
O *object;
M method;
bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return (object->*method)(p1, p2, p3, p4); }
Gate4MethodAction(O *object, M method) : object(object), method(method) {}
};
template <class O, class M, class P1, class P2, class P3, class P4>
Gate4<P1, P2, P3, P4> callback(O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4)) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodAction<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> callback(const O *object, bool (M::*method)(P1 p1, P2 p2, P3 p3, P4 p4) const) {
return Gate4<P1, P2, P3, P4>(new Gate4MethodAction<const O, bool (M::*)(P1 p1, P2 p2, P3 p3, P4 p4) const, P1, P2, P3, P4>(object, method));
}
template <class P1, class P2, class P3, class P4>
struct Gate4FnAction : public Gate4Action<P1, P2, P3, P4> {
bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4);
bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { return (*fn)(p1, p2, p3, p4); }
Gate4FnAction(bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) : fn(fn) {}
};
template <class P1, class P2, class P3, class P4>
inline Gate4<P1, P2, P3, P4> callback(bool (*fn)(P1 p1, P2 p2, P3 p3, P4 p4)) {
return Gate4<P1, P2, P3, P4>(new Gate4FnAction <P1, P2, P3, P4>(fn));
}
template <class P1, class P2, class P3, class P4>
struct Gate4ForkAction : public Gate4Action<P1, P2, P3, P4> {
Gate4<P1, P2, P3, P4> cb1, cb2;
bool Execute(P1 p1, P2 p2, P3 p3, P4 p4) { cb1(p1, p2, p3, p4); return cb2(p1, p2, p3, p4); }
Gate4ForkAction(Gate4<P1, P2, P3, P4> cb1, Gate4<P1, P2, P3, P4> cb2)
: cb1(cb1), cb2(cb2) {}
};
template <class P1, class P2, class P3, class P4>
inline Gate4<P1, P2, P3, P4> Proxy(Gate4<P1, P2, P3, P4>& cb)
{
return callback(&cb, &Gate4<P1, P2, P3, P4>::Execute);
}
template <class P1, class P2, class P3, class P4>
Gate4<P1, P2, P3, P4> callback(Gate4<P1, P2, P3, P4> cb1, Gate4<P1, P2, P3, P4> cb2)
{
return Gate4<P1, P2, P3, P4>(new Gate4ForkAction <P1, P2, P3, P4>(cb1, cb2));
}
template <class P1, class P2, class P3, class P4>
Gate4<P1, P2, P3, P4>& operator<<(Gate4<P1, P2, P3, P4>& a, Gate4<P1, P2, P3, P4> b)
{
if(a)
a = callback(a, b);
else
a = b;
return a;
}

518
uppsrc/Core/Callback1.h Normal file
View file

@ -0,0 +1,518 @@
//1 arg to Callback
template <class O, class M, class T>
struct CallbackMethodActionArgPte : public CallbackAction {
Ptr<O> object;
M method;
T arg;
void Execute() { if(object) (object->*method)(arg); }
CallbackMethodActionArgPte(O *object, M method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class O, class M, class Q, class T>
Callback pteback1(O *object, void (M::*method)(Q), T arg) {
return Callback(new CallbackMethodActionArgPte<O, void (M::*)(Q), T>(object, method, arg));
}
template <class O, class M, class T>
struct CallbackMethodActionArg : public CallbackAction {
O *object;
M method;
T arg;
void Execute() { (object->*method)(arg); }
CallbackMethodActionArg(O *object, M method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class O, class M, class Q, class T>
Callback callback1(O *object, void (M::*method)(Q), T arg) {
return Callback(new CallbackMethodActionArg<O, void (M::*)(Q), T>
(object, method, 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));
}
template <class F, class T, class HC = F>
struct CallbackActionCallArg : public CallbackAction {
F fn;
T arg;
void Execute() { fn(arg); }
CallbackActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class Q, class T>
Callback callback1(void (*fn)(Q), T arg)
{
return Callback(new CallbackActionCallArg<void (*)(Q), T, uintptr_t>(fn, arg));
}
//reduct
template <class Q, class T>
Callback callback1(Callback1<Q> cb, T arg)
{
return Callback(new CallbackActionCallArg<Callback1<Q>, T>(cb, arg));
}
//1 arg to Callback1
template <class O, class M, class P1, class T>
struct Callback1MethodActionArgPte : public Callback1Action<P1> {
Ptr<O> object;
M method;
T arg;
void Execute(P1 p1) { if(object) (object->*method)(p1, arg); }
Callback1MethodActionArgPte(O *object, M method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class O, class M, class P1, class Q, class T>
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, arg));
}
template <class O, class M, class P1, class T>
struct Callback1MethodActionArg : public Callback1Action<P1> {
O *object;
M method;
T arg;
void Execute(P1 p1) { (object->*method)(p1, arg); }
Callback1MethodActionArg(O *object, M method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class O, class M, class P1, class Q, class T>
Callback1<P1> callback1(O *object, void (M::*method)(P1, Q), T arg) {
return Callback1<P1>(new Callback1MethodActionArg<O, void (M::*)(P1, Q), P1, T>
(object, method, 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>
(object, method, arg));
}
template <class F, class P1, class T, class HC = F>
struct Callback1ActionCallArg : public Callback1Action<P1> {
F fn;
T arg;
void Execute(P1 p1) { fn(p1, arg); }
Callback1ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class P1, class Q, class T>
Callback1<P1> callback1(void (*fn)(P1, Q), T arg)
{
return Callback1<P1>(new Callback1ActionCallArg<void (*)(P1, Q), P1, T, uintptr_t>(fn, arg));
}
//reduct
template <class P1, class Q, class T>
Callback1<P1> callback1(Callback2<P1, Q> cb, T arg) {
return Callback1<P1>(new Callback1ActionCallArg<Callback2<P1, Q>, P1, T>(cb, arg));
}
//1 arg to Callback2
template <class O, class M, class P1, class P2, class T>
struct Callback2MethodActionArg : public Callback2Action<P1, P2> {
O *object;
M method;
T arg;
void Execute(P1 p1, P2 p2) { (object->*method)(p1, p2, arg); }
Callback2MethodActionArg(O *object, M method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class O, class M, class P1, class P2, class Q, class T>
Callback2<P1, P2> callback1(O *object, void (M::*method)(P1, P2, Q), T arg) {
return Callback2<P1, P2>(new Callback2MethodActionArg<O, void (M::*)(P1, P2, Q), P1, P2, T>
(object, method, 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>
(object, method, arg));
}
template <class F, class P1, class P2, class T, class HC = F>
struct Callback2ActionCallArg : Callback2Action<P1, P2> {
F fn;
T arg;
void Execute(P1 p1, P2 p2) { fn(p1, p2, arg); }
Callback2ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class P1, class P2, class Q, class T>
Callback2<P1, P2> callback1(void (*fn)(P1, P2, Q), T arg)
{
return Callback2<P1, P2>(new Callback2ActionCallArg<void (*)(P1, P2, Q), P1, P2, T, uintptr_t>(fn, arg));
}
//reduct
template <class P1, class P2, class Q, class T>
Callback2<P1, P2> callback1(Callback3<P1, P2, Q> cb, T arg) {
return Callback2<P1, P2>(new Callback2ActionCallArg<Callback3<P1, P2, Q>, P1, P2, T>(cb, arg));
}
//1 arg to Callback3
template <class O, class M, class P1, class P2, class P3, class T>
struct Callback3MethodActionArg : public Callback3Action<P1, P2, P3> {
O *object;
M method;
T arg;
void Execute(P1 p1, P2 p2, P3 p3) { (object->*method)(p1, p2, p3, arg); }
Callback3MethodActionArg(O *object, M method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class O, class M, class P1, class P2, class P3, class Q, class T>
Callback3<P1, P2, P3> callback1(O *object, void (M::*method)(P1, P2, P3, Q), T arg) {
return Callback3<P1, P2, P3>(new Callback3MethodActionArg<O, void (M::*)(P1, P2, P3, Q), P1, P2, P3, T>
(object, method, arg));
}
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>
(object, method, arg));
}
template <class F, class P1, class P2, class P3, class T, class HC = F>
struct Callback3ActionCallArg : Callback3Action<P1, P2, P3> {
F fn;
T arg;
void Execute(P1 p1, P2 p2, P3 p3) { fn(p1, p2, p3, arg); }
Callback3ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class P1, class P2, class P3, class Q, class T>
Callback3<P1, P2, P3> callback1(void (*fn)(P1, P2, P3, Q), T arg)
{
return Callback3<P1, P2, P3>(new Callback3ActionCallArg<void (*)(P1, P2, P3, Q), P1, P2, P3, T, uintptr_t>(fn, arg));
}
//reduct
template <class P1, class P2, class P3, class Q, class T>
Callback3<P1, P2, P3> callback1(Callback4<P1, P2, P3, Q> cb, T arg) {
return Callback3<P1, P2, P3>(new Callback3ActionCallArg<Callback4<P1, P2, P3, Q>, P1, P2, P3, T>(cb, arg));
}
//1 arg to Callback4
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;
M method;
T arg;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { (object->*method)(p1, p2, p3, p4, arg); }
Callback4MethodActionArg(O *object, M method, T arg)
: object(object), method(method), arg(arg) {}
};
template <class O, class M, class P1, class P2, class P3, class P4, class Q, class T>
Callback4<P1, P2, P3, P4> callback1(O *object, void (M::*method)(P1, P2, P3, P4, Q), T arg) {
return Callback4<P1, P2, P3, P4>(new Callback4MethodActionArg<O, void (M::*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T>
(object, method, arg));
}
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>
(object, method, arg));
}
template <class F, class P1, class P2, class P3, class P4, class T, class HC = F>
struct Callback4ActionCallArg : Callback4Action<P1, P2, P3, P4> {
F fn;
T arg;
void Execute(P1 p1, P2 p2, P3 p3, P4 p4) { fn(p1, p2, p3, p4, arg); }
Callback4ActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class P1, class P2, class P3, class P4, class Q, class T>
Callback4<P1, P2, P3, P4> callback1(void (*fn)(P1, P2, P3, P4, Q), T arg)
{
return Callback4<P1, P2, P3, P4>(new Callback4ActionCallArg<void (*)(P1, P2, P3, P4, Q), P1, P2, P3, P4, T, uintptr_t>(fn, arg));
}
// -------------------------------------------------------
//1 arg to Gate
template <class O, class M, class T>
struct GateMethodActionArgPte : public GateAction {
Ptr<O> object;
M method;
T arg;
bool Execute() { return object? (object->*method)(arg) : false; }
GateMethodActionArgPte(O *object, M method, T arg)
: object(object), method(method), arg(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));
}
template <class O, class M, class T>
struct GateMethodActionArg : public GateAction {
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) {}
};
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));
}
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));
}
template <class F, class T, class HC = F>
struct GateActionCallArg : public GateAction {
F fn;
T arg;
bool Execute() { return fn(arg); }
GateActionCallArg(F fn, T arg) : fn(fn), arg(arg) {}
};
template <class Q, class T>
Gate callback1(bool (*fn)(Q), T arg)
{
return Gate(new GateActionCallArg<bool (*)(Q), T, uintptr_t>(fn, arg));
}
//reduct
template <class Q, class T>
Gate callback1(Gate1<Q> cb, T arg)
{
return Gate(new GateActionCallArg<Gate1<Q>, T>(cb, arg));
}
//1 arg to Gate1
template <class O, class M, class P1, class T>
struct Gate1MethodActionArgPte : public Gate1Action<P1> {
Ptr<O> object;
M method;
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) {}
};
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));
}
template <class O, class M, class P1, class T>
struct Gate1MethodActionArg : public Gate1Action<P1> {
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) {}
};
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));
}
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));
}
template <class F, class P1, class T, class HC = F>
struct Gate1ActionCallArg : public Gate1Action<P1> {
F fn;
T arg;
bool Execute(P1 p1) { return fn(p1, arg); }
Gate1ActionCallArg(F fn, T arg) : fn(fn), arg(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));
}
//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));
}
//1 arg to Gate2
template <class O, class M, class P1, class P2, class T>
struct Gate2MethodActionArg : public Gate2Action<P1, P2> {
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) {}
};
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));
}
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));
}
template <class F, class P1, class P2, class T, class HC = F>
struct Gate2ActionCallArg : Gate2Action<P1, P2> {
F fn;
T arg;
bool Execute(P1 p1, P2 p2) { return fn(p1, p2, arg); }
Gate2ActionCallArg(F fn, T arg) : fn(fn), arg(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));
}
//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));
}
//1 arg to Gate3
template <class O, class M, class P1, class P2, class P3, class T>
struct Gate3MethodActionArg : public Gate3Action<P1, P2, P3> {
O *object;
M method;
T arg;
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) {}
};
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));
}
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));
}
template <class F, class P1, class P2, class P3, class T, class HC = F>
struct Gate3ActionCallArg : Gate3Action<P1, P2, P3> {
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) {}
};
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));
}
//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));
}
//1 arg to Gate4
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;
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) {}
};
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));
}
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));
}
template <class F, class P1, class P2, class P3, class P4, class T, class HC = F>
struct Gate4ActionCallArg : Gate4Action<P1, P2, P3, P4> {
F fn;
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) {}
};
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));
}

598
uppsrc/Core/Callback2.h Normal file
View file

@ -0,0 +1,598 @@
// 2 args to Callback
template <class O, class M, class T1, class T2>
struct CallbackMethodActionArg2Pte : public CallbackAction {
Ptr<O> object;
M method;
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) {}
};
/* 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));
}
template <class O, class M, class T1, class T2>
struct CallbackMethodActionArg2 : public CallbackAction {
O *object;
M method;
T1 arg1;
T2 arg2;
void Execute() { (object->*method)(arg1, arg2); }
CallbackMethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(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));
}
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));
}
template <class X, class T1, class T2, class HC = X>
struct CallbackActionCallArg2 : public CallbackAction {
X x;
T1 arg1;
T2 arg2;
void Execute() { x(arg1, arg2); }
CallbackActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(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));
}
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));
}
//2 args to Callback1
template <class O, class M, class P1, class T1, class T2>
struct Callback1MethodActionArg2 : public Callback1Action<P1> {
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) {}
};
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));
}
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));
}
template <class X, class P1, class T1, class T2, class HC = X>
struct Callback1ActionCallArg2 : public Callback1Action<P1> {
X x;
T1 arg1;
T2 arg2;
void Execute(P1 p1) { x(p1, arg1, arg2); }
Callback1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(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));
}
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));
}
//2 args to Callback2
template <class O, class M, class P1, class P2, class T1, class T2>
struct Callback2MethodActionArg2 : public Callback2Action<P1, P2> {
O *object;
M method;
T1 arg1;
T2 arg2;
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) {}
};
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));
}
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));
}
template <class X, class P1, class P2, class T1, class T2, class HC = X>
struct Callback2ActionCallArg2 : public Callback2Action<P1, P2> {
X x;
T1 arg1;
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) {}
};
/* 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));
}
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));
}
//2 args to Callback3
template <class O, class M, class P1, class P2, class P3, class T1, class T2>
struct Callback3MethodActionArg2 : public Callback3Action<P1, P2, P3> {
O *object;
M method;
T1 arg1;
T2 arg2;
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) {}
};
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));
}
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));
}
template <class X, class P1, class P2, class P3, class T1, class T2, class HC = X>
struct Callback3ActionCallArg2 : public Callback3Action<P1, P2, P3> {
X x;
T1 arg1;
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) {}
};
/* 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));
}
//2 args to Callback4
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;
M method;
T1 arg1;
T2 arg2;
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) {}
};
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));
}
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));
}
template <class X, class P1, class P2, class P3, class P4, class T1, class T2, class HC = X>
struct Callback4ActionCallArg2 : public Callback4Action<P1, P2, P3, P4> {
X x;
T1 arg1;
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) {}
};
/* 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));
}
// ---------------------------------------------------------
// 2 args to Gate
template <class O, class M, class T1, class T2>
struct GateMethodActionArg2Pte : public GateAction {
Ptr<O> object;
M method;
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) {}
};
/* 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));
}
template <class O, class M, class T1, class T2>
struct GateMethodActionArg2 : public GateAction {
O *object;
M method;
T1 arg1;
T2 arg2;
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) {}
};
/* 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));
}
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));
}
template <class X, class T1, class T2, class HC = X>
struct GateActionCallArg2 : public GateAction {
X x;
T1 arg1;
T2 arg2;
bool Execute() { return x(arg1, arg2); }
GateActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(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));
}
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));
}
//2 args to Gate1
template <class O, class M, class P1, class T1, class T2>
struct Gate1MethodActionArg2 : public Gate1Action<P1> {
O *object;
M method;
T1 arg1;
T2 arg2;
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) {}
};
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));
}
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));
}
template <class X, class P1, class T1, class T2, class HC = X>
struct Gate1ActionCallArg2 : public Gate1Action<P1> {
X x;
T1 arg1;
T2 arg2;
bool Execute(P1 p1) { return x(p1, arg1, arg2); }
Gate1ActionCallArg2(X x, T1 arg1, T2 arg2) : x(x), arg1(arg1), arg2(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));
}
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));
}
//2 args to Gate2
template <class O, class M, class P1, class P2, class T1, class T2>
struct Gate2MethodActionArg2 : public Gate2Action<P1, P2> {
O *object;
M method;
T1 arg1;
T2 arg2;
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) {}
};
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));
}
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));
}
template <class X, class P1, class P2, class T1, class T2, class HC = X>
struct Gate2ActionCallArg2 : public Gate2Action<P1, P2> {
X x;
T1 arg1;
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) {}
};
/* 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));
}
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));
}
//2 args to Gate3
template <class O, class M, class P1, class P2, class P3, class T1, class T2>
struct Gate3MethodActionArg2 : public Gate3Action<P1, P2, P3> {
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; }
Gate3MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(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));
}
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));
}
template <class X, class P1, class P2, class P3, class T1, class T2, class HC = X>
struct Gate3ActionCallArg2 : public Gate3Action<P1, P2, P3> {
X x;
T1 arg1;
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) {}
};
/* 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));
}
//2 args to Gate4
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;
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; }
Gate4MethodActionArg2(O *object, M method, T1 arg1, T2 arg2)
: object(object), method(method), arg1(arg1), arg2(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));
}
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));
}
template <class X, class P1, class P2, class P3, class P4, class T1, class T2, class HC = X>
struct Gate4ActionCallArg2 : public Gate4Action<P1, P2, P3, P4> {
X x;
T1 arg1;
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) {}
};
/* 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));
}

428
uppsrc/Core/Callback3.h Normal file
View file

@ -0,0 +1,428 @@
//3 args to Callback
template <class O, class M, class T1, class T2, class T3>
struct CallbackMethodActionArg3Pte : public CallbackAction {
Ptr<O> object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
/* 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));
}
template <class O, class M, class T1, class T2, class T3>
struct CallbackMethodActionArg3 : public CallbackAction
{
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
/* 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));
}
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));
}
template <class X, class T1, class T2, class T3, class HC = X>
struct CallbackActionCallArg3 : public CallbackAction {
X x;
T1 arg1;
T2 arg2;
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) {}
};
/* 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));
}
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));
}
//3 args to Callback1
template <class O, class M, class P1, class T1, class T2, class T3>
struct Callback1MethodActionArg3 : public Callback1Action<P1> {
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) {}
};
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));
}
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));
}
//3 args to Callback2
template <class O, class M, class P1, class P2, class T1, class T2, class T3>
struct Callback2MethodActionArg3 : public Callback2Action<P1, P2> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
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));
}
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));
}
//3 args to Callback3
template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3>
struct Callback3MethodActionArg3 : public Callback3Action<P1, P2, P3> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
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));
}
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));
}
//3 args to Callback4
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> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
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));
}
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));
}
// --------------------------------------------------------
//3 args to Gate
template <class O, class M, class T1, class T2, class T3>
struct GateMethodActionArg3Pte : public GateAction {
Ptr<O> object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
/* 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));
}
template <class O, class M, class T1, class T2, class T3>
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) {}
};
/* 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));
}
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));
}
template <class X, class T1, class T2, class T3, class HC = X>
struct GateActionCallArg3 : public GateAction {
X x;
T1 arg1;
T2 arg2;
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) {}
};
/* 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));
}
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));
}
//3 args to Gate1
template <class O, class M, class P1, class T1, class T2, class T3>
struct Gate1MethodActionArg3 : public Gate1Action<P1> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
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));
}
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));
}
//3 args to Gate2
template <class O, class M, class P1, class P2, class T1, class T2, class T3>
struct Gate2MethodActionArg3 : public Gate2Action<P1, P2> {
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; }
Gate2MethodActionArg3(O *object, M method, T1 arg1, T2 arg2, T3 arg3)
: object(object), method(method), arg1(arg1), arg2(arg2), arg3(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));
}
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));
}
//3 args to Gate3
template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3>
struct Gate3MethodActionArg3 : public Gate3Action<P1, P2, P3> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
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));
}
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));
}
//3 args to Gate4
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> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
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));
}
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));
}

442
uppsrc/Core/Callback4.h Normal file
View file

@ -0,0 +1,442 @@
//4 args to Callback
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;
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) {}
};
/* 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));
}
template <class O, class M, class T1, class T2, class T3, class T4>
struct CallbackMethodActionArg4 : public CallbackAction
{
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
/* 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));
}
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));
}
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;
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) {}
};
/* 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));
}
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));
}
//4 args to Callback1
template <class O, class M, class P1, class T1, class T2, class T3, class T4>
struct Callback1MethodActionArg4 : public Callback1Action<P1> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
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));
}
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));
}
//4 args to Callback2
template <class O, class M, class P1, class P2, class T1, class T2, class T3, class T4>
struct Callback2MethodActionArg4 : public Callback2Action<P1, P2> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
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));
}
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));
}
//4 args to Callback3
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> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T3 arg4;
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) {}
};
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));
}
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));
}
//4 args to Callback4
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> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
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));
}
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));
}
//----------------------------------------------------------
//4 args to Gate
template <class O, class M, class T1, class T2, class T3, class T4>
struct GateMethodActionArg4Pte : public GateAction {
Ptr<O> object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
/*
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));
}
template <class O, class M, class T1, class T2, class T3, class T4>
struct GateMethodActionArg4 : public GateAction
{
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
/*
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));
}
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));
}
template <class X, class T1, class T2, class T3, class T4, class HC = X>
struct GateActionCallArg4 : public GateAction {
X x;
T1 arg1;
T2 arg2;
T3 arg3;
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) {}
};
/*
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));
}
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));
}
//4 args to Gate1
template <class O, class M, class P1, class T1, class T2, class T3, class T4>
struct Gate1MethodActionArg4 : public Gate1Action<P1> {
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; }
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) {}
};
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));
}
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));
}
//4 args to Gate2
template <class O, class M, class P1, class P2, class T1, class T2, class T3, class T4>
struct Gate2MethodActionArg4 : public Gate2Action<P1, P2> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
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));
}
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));
}
//4 args to Gate3
template <class O, class M, class P1, class P2, class P3, class T1, class T2, class T3, class T4>
struct Gate3MethodActionArg4 : public Gate3Action<P1, P2, P3> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T3 arg4;
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) {}
};
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));
}
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));
}
//4 args to Gate4
template <class O, class M, class P1, class P2, class P3, class P4, class T1, class T2, class T3, class T4>
struct Gate4MethodActionArg4 : public Gate4Action<P1, P2, P3, P4> {
O *object;
M method;
T1 arg1;
T2 arg2;
T3 arg3;
T4 arg4;
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) {}
};
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));
}
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));
}

878
uppsrc/Core/Cbgen.h
View file

File diff suppressed because it is too large Load diff

5
uppsrc/Core/Core.upp
View file

@ -88,6 +88,11 @@ file
Hash.cpp optimize_speed,
Concretes readonly separator,
Cbgen.h,
Callback0.h,
Callback1.h,
Callback2.h,
Callback3.h,
Callback4.h,
Callback.h,
Callback.cpp optimize_speed,
TimeDate.h,