#ifndef FUNCTION_H
#define FUNCTION_H

#include <cassert>

class NullType {};
template<class R = void(), class C = NullType>
struct Function;

struct Functor
{
	template <class R> R operator()();
	template <class R, class T1> R operator()(T1);
	template <class R, class T1, class T2> R operator()(T1,T2);
	virtual ~Functor() {}
};

template <class R> R Functor::operator()()
{
    Function<R()>* self = dynamic_cast<Function<R()>*>(this);
    assert(self != 0); return self->operator()();
}

template <class R, class T1> R Functor::operator ()(T1 t1)
{
	Function<R(T1)>* self = dynamic_cast<Function<R(T1)>*>(this);
	assert(self != 0); return self->operator()(t1);
}

template <class R, class T1, class T2> R Functor::operator ()(T1 t1, T2 t2)
{
	Function<R(T1,T2)>* self = dynamic_cast<Function<R(T1,T2)>*>(this);
	assert(self != 0); return self->operator()(t1, t2);
}

template<class R>
struct Function<R()> : public Functor
{
private:
	typedef R (*F)();

public:
	Function() {}
	Function(F f) : m_f(f) {}
	virtual R operator ()() { return m_f(); }

private:
	F m_f;
};

template<class R, class T1>
struct Function<R(T1)> : public Functor
{
private:
	typedef R (*F)(T1);

public:
	Function() {}
	Function(F f) : m_f(f) {}
	virtual R operator ()(T1 t1) { return m_f(t1); }

private:
	F m_f;
};

template<class R, class T1, class T2>
struct Function<R(T1,T2)> : public Functor
{
private:
	typedef R (*F)(T1,T2);

public:
	Function() {}
	Function(F f) : m_f(f) {}
	virtual R operator ()(T1 t1, T2 t2) { return m_f(t1, t2); }

private:
	F m_f;
};

template <class R, class C>
struct Function<R(C::*)()> : public Function<R()>
{
private:
	typedef R (C::*F)();

public:
	Function(F f, C c) : m_f(f), m_c(c) {}
	virtual R operator ()() { return (c.*m_f)(); }

private:
	F m_f;
	C m_c;
};

template <class R, class C>
struct Function<R(C::*)() const, C> : public Function<R()>
{
private:
	typedef R (C::*F)() const;

public:
	Function(F f, C c) : m_f(f), m_c(c) {}
	virtual R operator ()() { return (c.*m_f)(); }

private:
	F m_f;
	C m_c;
};

template <class R, class T1, class C>
struct Function<R(C::*)(T1), C> : public Function<R(T1)>
{
private:
	typedef R (C::*F)(T1);

public:
	Function(F f, C c) : m_f(f), m_c(c) {}
	virtual R operator ()(T1 t1) { return (c.*m_f)(t1); }

private:
	F m_f;
	C m_c;
};

template <class R, class T1, class C>
struct Function<R(C::*)(T1) const, C> : public Function<R(T1)>
{
private:
	typedef R (C::*F)(T1) const;

public:
	Function(F f, C c) : m_f(f), m_c(c) {}
	virtual R operator ()(T1 t1) { return (c.*m_f)(t1); }

private:
	F m_f;
	C m_c;
};

template <class R, class T1, class T2, class C>
struct Function<R(C::*)(T1,T2), C> : public Function<R(T1,T2)>
{
private:
	typedef R (C::*F)(T1,T2);

public:
	Function(F f, C c) : m_f(f), m_c(c) {}
	virtual R operator ()(T1 t1, T2 t2) { return (c.*m_f)(t1, t2); }

private:
	F m_f;
	C m_c;
};

template <class R, class T1, class T2, class C>
struct Function<R(C::*)(T1,T2) const, C> : public Function<R(T1,T2)>
{
private:
	typedef R (C::*F)(T1,T2) const;

public:
	Function(F f, C c) : m_f(f), m_c(c) {}
	virtual R operator ()(T1 t1, T2 t2) { return (c.*m_f)(t1, t2); }

private:
	F m_f;
	C m_c;
};


#endif // FUNCTION_H