//========================================================================================
/***************

callback_test

generic callback mechanism.

This is a way for a class to register an aribtrary member function
with arbitrary arguments to be called back later.

*****************/
//========================================================================================

#include "stl_basics.h"
#include "stl_vector.h"
#include "gMemory.h"

//========================================================================================

struct CallBack
{
	virtual ~CallBack() { }

	virtual void Do() const = 0;
};

// (should hold smart pointers to T_Class when possible)


//========================================================================================

template < class T_Class >
struct CallBack0 : public CallBack
{
	typedef void (T_Class::* T_fun_type)(void);
	
	explicit CallBack0(T_Class * c, T_fun_type f )
	{
		__p = c;
		_mem_fun = f;
	}

	virtual void Do() const
	{
		(__p->*_mem_fun)();
	}


	T_Class *	__p;
	T_fun_type	_mem_fun;
};

template < class T_Class , typename Arg1 >
struct CallBack1 : public CallBack
{
	typedef void (T_Class::* T_fun_type)(Arg1);
	
	explicit CallBack1(T_Class * c, T_fun_type f, Arg1 a1 )
	{
		__p = c;
		_mem_fun = f;
		_arg1 = a1;
	}

	virtual void Do() const
	{
		(__p->*_mem_fun)(_arg1);
	}


	T_Class *	__p;
	T_fun_type	_mem_fun;
	Arg1		_arg1;
};

template < class T_Class , typename Arg1 , typename Arg2 >
struct CallBack2 : public CallBack
{
	typedef void (T_Class::* T_fun_type)(Arg1,Arg2);
	
	explicit CallBack2(T_Class * c, T_fun_type f, Arg1 a1 , Arg2 a2 )
	{
		__p = c;
		_mem_fun = f;
		_arg1 = a1;
		_arg2 = a2;
	}

	virtual void Do() const
	{
		(__p->*_mem_fun)(_arg1,_arg2);
	}


	T_Class *	__p;
	T_fun_type	_mem_fun;
	Arg1		_arg1;
	Arg2		_arg2;
};

//========================================================================================

template < class T_Class , typename T_fun_type >
CallBack * make_cb0(T_Class * c, T_fun_type f)
{
	return new CallBack0<T_Class>(c,f);
}

template < class T_Class , typename T_fun_type , typename Arg1 >
CallBack * make_cb1(T_Class * c, T_fun_type f,Arg1 a)
{
	return new CallBack1<T_Class,Arg1>(c,f,a);
}

template < class T_Class, typename T_fun_type, typename Arg1, typename Arg2 >
CallBack * make_cb2(T_Class * c, T_fun_type f,Arg1 a1,Arg2 a2)
{
	return new CallBack2<T_Class,Arg1,Arg2>(c,f,a1,a2);
}


//========================================================================================

struct TestC
{
	TestC(int i)
	{
		m_i = i;
	}
	
	void DoStuff1()
	{
		printf("%d\n",m_i);
	}

	void DoStuff2(int a)
	{
		printf("%d %d\n",m_i,a);
	}

	void DoStuff3(int a,int b)
	{
		printf("%d %d %d\n",m_i,a,b);
	}

	int	m_i;
};

//=======================================================================================

void callback_test()
{
	std::vector<CallBack *> cbs;

	TestC t1(4);
	TestC t2(2);

	CallBack * cb;
	cb = make_cb0(&t1,TestC::DoStuff1);
	cbs.push_back(cb);

	CallBack0<TestC> * cb0;
	cb0 = new CallBack0<TestC>(&t2,TestC::DoStuff1);
	cbs.push_back(cb0);

	CallBack1<TestC,int> * cb1;
	cb1 = new CallBack1<TestC,int>(&t1,TestC::DoStuff2,7);
	cbs.push_back(cb1);

	cbs.push_back( make_cb1(&t2,TestC::DoStuff2,4) );

	cbs.push_back( make_cb2(&t2,TestC::DoStuff3,9,9) );

	std::vector<CallBack *>::iterator it;
	for(it = cbs.begin();it != cbs.end();++it)
	{
		(*it)->Do();
	}
	
	for(it = cbs.begin();it != cbs.end();++it)
	{
		delete (*it);
	}
}


//========================================================================================