Delegate.h

#pragma once

#include "IDelegate.h"

template<typename T, typename R> class Delegate0 : public IDelegate0<R>
{
private:
    T*  object;
    R   (T::*func)();

public:
    Delegate0(T* object, R (T::*func)())
    {
        this->object = object;
        this->func = func;
    }
    virtual ~Delegate0() { }

    virtual R   operator()()
    {
        return (this->object->*this->func)();
    }
};

template<typename T, typename R, typename P1> class Delegate1 : public IDelegate1<R, P1>
{
private:
    T*  object;
    R   (T::*func)(P1);

public:
    Delegate1(T* object, R (T::*func)(P1))
    {
        this->object = object;
        this->func = func;
    }
    virtual ~Delegate1() { }

    virtual R   operator()(P1 p1)
    {
        return (this->object->*this->func)(p1);
    }
};

template<typename T, typename R, typename P1, typename P2> class Delegate2 : public IDelegate2<R, P1, P2>
{
private:
    T*  object;
    R   (T::*func)(P1, P2);

public:
    Delegate2(T* object, R (T::*func)(P1, P2))
    {
        this->object = object;
        this->func = func;
    }
    virtual ~Delegate2() { }

    virtual R   operator()(P1 p1, P2 p2)
    {
        return (this->object->*this->func)(p1, p2);
    }
};

template<typename T, typename R, typename P1, typename P2, typename P3> class Delegate3 : public IDelegate3<R, P1, P2, P3>
{
private:
    T*  object;
    R   (T::*func)(P1, P2, P3);

public:
    Delegate3(T* object, R (T::*func)(P1, P2, P3))
    {
        this->object = object;
        this->func = func;
    }
    virtual ~Delegate3() { }

    virtual R   operator()(P1 p1, P2 p2, P3 p3)
    {
        return (this->object->*this->func)(p1, p2, p3);
    }
};

template<typename T, typename R, typename P1, typename P2, typename P3, typename P4> class Delegate4 : public IDelegate4<R, P1, P2, P3, P4>
{
private:
    T*  object;
    R   (T::*func)(P1, P2, P3, P4);

public:
    Delegate4(T* object, R (T::*func)(P1, P2, P3, P4))
    {
        this->object = object;
        this->func = func;
    }
    virtual ~Delegate4() { }

    virtual R   operator()(P1 p1, P2 p2, P3 p3, P4 p4)
    {
        return (this->object->*this->func)(p1, p2, p3, p4);
    }
};

template<typename T, typename R, typename P1, typename P2, typename P3, typename P4, typename P5> class Delegate5 : public IDelegate5<R, P1, P2, P3, P4, P5>
{
private:
    T*  object;
    R   (T::*func)(P1, P2, P3, P4, P5);

public:
    Delegate5(T* object, R (T::*func)(P1, P2, P3, P4, P5))
    {
        this->object = object;
        this->func = func;
    }
    virtual ~Delegate5() { }

    virtual R   operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
    {
        return (this->object->*this->func)(p1, p2, p3, p4, p5);
    }
};