#ifndef CPPDELEGATE_H_E100A24F_F4CD_4D35_AED1_C5BE1FBD1CDD
#define CPPDELEGATE_H_E100A24F_F4CD_4D35_AED1_C5BE1FBD1CDD

#include <list>

using namespace std;

template<typename T, typename F> class DelegateBase
{
protected:
    typedef DelegateBase<T, F> DLGTBASE;
private:
    T* obj;
    F func;
protected:
    DelegateBase(T* t, F f) : obj(t), func(f){}
    DelegateBase(F f) : obj((void*)0), func(f){}
    T* GetObject(){return obj;}
    F GetFunction(){return func;}
    bool Equals(DLGTBASE* other){return obj == other->obj && func == other->func;}
};

template<class _DLGT> class DelegateX
{
protected:
    typedef _DLGT* DLGT;
private:
    list<DLGT> m_list;
    class Remover : public unary_function<DLGT, bool>
    {
    private:
        DLGT comparand;
    public:
        Remover(DLGT p) : comparand(p){}
        bool operator() (DLGT& p){return comparand->Equals(p);}
    };
protected:
    DelegateX(){m_list.push_back(static_cast<DLGT>(this));}
    void CopyInnerList(list<DLGT>& var){var.assign(m_list.begin(), m_list.end());}
    virtual bool Equals(DLGT dlgt) = 0;
public:
    void Add(DLGT p)
    {
        for (list<DLGT>::iterator i = p->m_list.begin(); i != p->m_list.end(); i++) m_list.push_back(*i);
    }
    void Remove(DLGT p)
    {
        for (list<DLGT>::iterator i = p->m_list.begin(); i != p->m_list.end(); i++) m_list.remove_if(Remover(*i));
    }
    void operator +=(DLGT p){return Add(p);}
    void operator -=(DLGT p){return Remove(p);}
};

//R DelegateA0();

template<typename R> class DelegateA0 : public DelegateX<DelegateA0<R>>
{
protected:
    virtual R Invoke() = 0;
public:
    R Call()
    {
        list<DLGT> dlgtx; CopyInnerList(dlgtx);
        for (list<DLGT>::iterator i = dlgtx.begin(); i != --dlgtx.end(); i++) (*i)->Invoke();
        return dlgtx.back()->Invoke();
    }
    R operator ()(){return Call();}
};

template<typename R, typename T>
class DelegateA0I : public DelegateBase<T, R (T::*)()>, public DelegateA0<R>
{
protected:
    R Invoke() {return (GetObject()->*GetFunction())();}
    bool Equals(DLGT dlgt) {return DLGTBASE::Equals(static_cast<DelegateA0I<R, T>*>(dlgt));}
public:
    DelegateA0I(T* t, R (T::*f)()) : DLGTBASE(t, f){}
};
template<typename R, typename T>
DelegateA0<R>* CreateDelegate(T* obj, R (T::*f)()){return new DelegateA0I<R, T>(obj, f);}

template<typename R>
class DelegateA0S : public DelegateBase<void, R (*)()>, public DelegateA0<R>
{
protected:
    R Invoke() {return (GetFunction())();}
    bool Equals(DLGT dlgt) {return DLGTBASE::Equals(static_cast<DelegateA0S<R>*>(dlgt));}
public:
    DelegateA0S(R (*f)()) : DLGTBASE(f){}
};
template<typename R>
DelegateA0<R>* CreateDelegate(R (*f)()){return new DelegateA0S<R>(f);}

//R DelegateA1(A1);

template<typename R, typename A1> class DelegateA1 : public DelegateX<DelegateA1<R, A1>>
{
protected:
    virtual R Invoke(A1 a1) = 0;
public:
    R Call(A1 a1)
    {
        list<DLGT> dlgtx; CopyInnerList(dlgtx);
        for (list<DLGT>::iterator i = dlgtx.begin(); i != --dlgtx.end(); i++) (*i)->Invoke(a1);
        return dlgtx.back()->Invoke(a1);
    }
    R operator ()(A1 a1){return Call(a1);}
};

template<typename R, typename T, typename A1>
class DelegateA1I : public DelegateBase<T, R (T::*)(A1)>, public DelegateA1<R, A1>
{
protected:
    R Invoke(A1 a1) {return (GetObject()->*GetFunction())(a1);}
    bool Equals(DLGT dlgt) {return DLGTBASE::Equals(static_cast<DelegateA1I<R, T, A1>*>(dlgt));}
public:
    DelegateA1I(T* t, R (T::*f)(A1)) : DLGTBASE(t, f){}
};
template<typename R, typename T, typename A1>
DelegateA1<R, A1>* CreateDelegate(T* obj, R (T::*f)(A1)){return new DelegateA1I<R, T, A1>(obj, f);}

template<typename R, typename A1>
class DelegateA1S : public DelegateBase<void, R (*)(A1)>, public DelegateA1<R, A1>
{
protected:
    R Invoke(A1 a1) {return (GetFunction())(a1);}
    bool Equals(DLGT dlgt) {return DLGTBASE::Equals(static_cast<DelegateA1S<R, A1>*>(dlgt));}
public:
    DelegateA1S(R (*f)(A1)) : DLGTBASE(f){}
};
template<typename R, typename A1>
DelegateA1<R, A1>* CreateDelegate(R (*f)(A1)){return new DelegateA1S<R, A1>(f);}

//R DelegateA2(A1, A2);

template<typename R, typename A1, typename A2> class DelegateA2 : public DelegateX<DelegateA2<R, A1, A2>>
{
protected:
    virtual R Invoke(A1 a1, A2 a2) = 0;
public:
    R Call(A1 a1, A2 a2)
    {
        list<DLGT> dlgtx; CopyInnerList(dlgtx);
        for (list<DLGT>::iterator i = dlgtx.begin(); i != --dlgtx.end(); i++) (*i)->Invoke(a1, a2);
        return dlgtx.back()->Invoke(a1, a2);
    }
    R operator ()(A1 a1, A2 a2){return Call(a1, a2);}
};

template<typename R, typename T, typename A1, typename A2>
class DelegateA2I : public DelegateBase<T, R (T::*)(A1, A2)>, public DelegateA2<R, A1, A2>
{
protected:
    R Invoke(A1 a1, A2 a2) {return (GetObject()->*GetFunction())(a1, a2);}
    bool Equals(DLGT dlgt) {return DLGTBASE::Equals(static_cast<DelegateA2I<R, T, A1, A2>*>(dlgt));}
public:
    DelegateA2I(T* t, R (T::*f)(A1, A2)) : DLGTBASE(t, f){}
};
template<typename R, typename T, typename A1, typename A2>
DelegateA2<R, A1, A2>* CreateDelegate(T* obj, R (T::*f)(A1, A2)){return new DelegateA2I<R, T, A1, A2>(obj, f);}

template<typename R, typename A1, typename A2>
class DelegateA2S : public DelegateBase<void, R (*)(A1, A2)>, public DelegateA2<R, A1, A2>
{
protected:
    R Invoke(A1 a1, A2 a2) {return (GetFunction())(a1, a2);}
    bool Equals(DLGT dlgt) {return DLGTBASE::Equals(static_cast<DelegateA2S<R, A1, A2>*>(dlgt));}
public:
    DelegateA2S(R (*f)(A1, A2)) : DLGTBASE(f){}
};
template<typename R, typename A1, typename A2>
DelegateA2<R, A1, A2>* CreateDelegate(R (*f)(A1, A2)){return new DelegateA2S<R, A1, A2>(f);}

#endif //CPPDELEGATE_H_E100A24F_F4CD_4D35_AED1_C5BE1FBD1CDD