callback.h

#pragma once
 
// Note - VS2010 does not support variadic templates :(
// MOO NOTE: Do not use these in new codes, between lambdas and std::function
// it really doesn't make sense. Remove in old code when you are messing around
// with it anyway.
 
template <class R> 
class Callback0 {
public:
 virtual ~Callback0() {}
 virtual R execute()=0;
};
 
template <class R,class Arg1>
class Callback1 {
public:
 virtual ~Callback1() {}
 virtual R execute(Arg1 a)=0;
};
 
template <class R,class Arg1,class Arg2>
class Callback2 {
public:
 virtual ~Callback2() {}
 virtual R execute(Arg1 a,Arg2 b)=0;
};
 
template <class R,class Arg1,class Arg2,class Arg3>
class Callback3 {
public:
 virtual ~Callback3() {}
 virtual R execute(Arg1 a,Arg2 b,Arg3 c)=0;
};
 
template <class R,class Arg1,class Arg2,class Arg3,class Arg4>
class Callback4 {
public:
 virtual ~Callback4() {}
 virtual R execute(Arg1 a,Arg2 b,Arg3 c,Arg4 d)=0;
};
 
template <class R>
class Callback0Static : public Callback0<R> {
public:
 typedef R (*type)();
 Callback0Static(type t) : t_(t) { }
 virtual R execute() { return t_(); }
private:
 type t_;
};
 
template <class R,class Arg1>
class Callback1Static : public Callback1<R,Arg1> {
public:
 typedef R (*type)(Arg1 a);
 Callback1Static(type t) : t_(t) { }
 virtual R execute(Arg1 a) { return t_(a); }
private:
 type t_;
};
 
template <class R,class Arg1,class Arg2>
class Callback2Static : public Callback2<R,Arg1,Arg2> {
public:
 typedef R (*type)(Arg1 a,Arg2 b);
 Callback2Static(type t) : t_(t) { }
 virtual R execute(Arg1 a,Arg2 b) { return t_(a,b); }
private:
 type t_;
};
 
template <class R,class Arg1,class Arg2,class Arg3>
class Callback3Static : public Callback3<R,Arg1,Arg2,Arg3> {
public:
 typedef R (*type)(Arg1 a,Arg2 b,Arg3 c);
 Callback3Static(type t) : t_(t) { }
 virtual R execute(Arg1 a,Arg2 b,Arg3 c) { return t_(a,b,c); }
private:
 type t_;
};
 
template <class R,class Arg1,class Arg2,class Arg3,class Arg4>
class Callback4Static : public Callback4<R,Arg1,Arg2,Arg3,Arg4> {
public:
 typedef R (*type)(Arg1 a,Arg2 b,Arg3 c,Arg4 d);
 Callback4Static(type t) : t_(t) { }
 R execute(Arg1 a,Arg2 b,Arg3 c,Arg4 d) override { return t_(a,b,c,d); }
private:
 type t_;
};
 
template <class R,class S,R (S::*MFP)()>
class Callback0Method : public Callback0<R> {
public:
 Callback0Method(S *s) : s_(s) { }
 virtual R execute() { return (s_->*MFP)(); }
private:
 S *s_;
};
 
template <class R,class Arg1,class S,R (S::*MFP)(Arg1)>
class Callback1Method : public Callback1<R,Arg1> {
public:
 Callback1Method(S *s) : s_(s) { }
 virtual R execute(Arg1 a) { return (s_->*MFP)(a); }
private:
 S *s_;
};
 
template <class R,class Arg1,class Arg2,class S,R (S::*MFP)(Arg1,Arg2)>
class Callback2Method : public Callback2<R,Arg1,Arg2> {
public:
 Callback2Method(S *s) : s_(s) { }
 virtual R execute(Arg1 a,Arg2 b) { return (s_->*MFP)(a,b); }
private:
 S *s_;
};
 
template <class R,class Arg1,class Arg2,class Arg3,class S,R (S::*MFP)(Arg1,Arg2,Arg3)>
class Callback3Method : public Callback3<R,Arg1,Arg2,Arg3> {
public:
 Callback3Method(S *s) : s_(s) { }
 R execute(Arg1 a,Arg2 b,Arg3 c) override { return (s_->*MFP)(a,b,c); }
private:
 S *s_;
};
 
template <class R,class Arg1,class Arg2,class Arg3,class Arg4,class S,R (S::*MFP)(Arg1,Arg2,Arg3,Arg4)>
class Callback4Method : public Callback4<R,Arg1,Arg2,Arg3,Arg4> {
public:
 Callback4Method(S *s) : s_(s) { }
 R execute(Arg1 a,Arg2 b,Arg3 c,Arg4 d) override { return (s_->*MFP)(a,b,c,d); }
private:
 S *s_;
};
 
// EoF