#define COMBINE(a, b)					COMBINE1(a, b)
#define COMBINE1(a, b)					a##b

#define BASE_DELEGATE					COMBINE(IDelegate, SUFFIX)

#define STATIC_DELEGATE					COMBINE(StaticDelegate, SUFFIX)
#define MEMBER_DELEGATE					COMBINE(MemberDelegate, SUFFIX)

#define DELEGATE						COMBINE(Delegate, SUFFIX)


TEMPLATE TEMPLATE_S_ARGS_DEF
class BASE_DELEGATE {
public:
	virtual void invoke(DELEGATE_PARAMS) = 0;
	virtual bool compare(BASE_DELEGATE* other) = 0;
	virtual bool isType(const std::type_info& _type) = 0;
private:
	//unsigned char _type;// 1 static func / 0 member func
};

TEMPLATE TEMPLATE_S_ARGS_DEF
class STATIC_DELEGATE : public BASE_DELEGATE TEMPLATE_S_ARGS {
public:
	typedef void(*Func)(DELEGATE_PARAMS);

	STATIC_DELEGATE(Func fun) 
		: _func(fun) 
	{
	}
	virtual bool isType(const std::type_info& _type)
	{
		return typeid(STATIC_DELEGATE TEMPLATE_S_ARGS) == _type;
	}

	virtual void invoke(DELEGATE_PARAMS) {
		_func(DELEGATE_ARGS);
	}

	virtual bool compare(BASE_DELEGATE TEMPLATE_S_ARGS* other) {
		if (NULL == other || !other->isType(typeid(STATIC_DELEGATE TEMPLATE_S_ARGS))) return false;
		STATIC_DELEGATE TEMPLATE_S_ARGS* cast = static_cast<STATIC_DELEGATE TEMPLATE_S_ARGS*>(other);
		return _func == cast->_func;
	}

protected:
	Func _func;
};

template TEMPLATE_O_ARGS_DEF
class MEMBER_DELEGATE : public BASE_DELEGATE TEMPLATE_S_ARGS {
public:
	typedef void(obj_type::*Func)(DELEGATE_PARAMS);

	MEMBER_DELEGATE(obj_type* obj, Func objfunc)
		: _obj(obj), _func(objfunc)
	{
	}
	virtual bool isType(const std::type_info& _type)
	{
		return typeid(MEMBER_DELEGATE TEMPLATE_O_ARGS) == _type;
	}
	virtual void invoke(DELEGATE_PARAMS) {
		(_obj->*_func)(DELEGATE_ARGS);
	}

	virtual bool compare(BASE_DELEGATE TEMPLATE_S_ARGS* other) {
		if (NULL == other || !other->isType(typeid(MEMBER_DELEGATE TEMPLATE_O_ARGS))) return false;
		MEMBER_DELEGATE TEMPLATE_O_ARGS* cast = static_cast<MEMBER_DELEGATE TEMPLATE_O_ARGS*>(other);
		return _obj == cast->_obj && _func == cast->_func;
	}

protected:
	obj_type* _obj;
	Func _func;
};

TEMPLATE TEMPLATE_S_ARGS_DEF
inline BASE_DELEGATE TEMPLATE_S_ARGS* New(void(*Func)(DELEGATE_PARAMS))
{
	return new STATIC_DELEGATE TEMPLATE_S_ARGS(Func);
}

template TEMPLATE_O_ARGS_DEF
inline BASE_DELEGATE TEMPLATE_S_ARGS* New(obj_type* obj, void (obj_type::*Func)(DELEGATE_PARAMS))
{
	return new MEMBER_DELEGATE TEMPLATE_O_ARGS(obj, Func);
}

TEMPLATE TEMPLATE_S_ARGS_DEF
class DELEGATE {
private:
	void disconnect_(BASE_DELEGATE TEMPLATE_S_ARGS* fun) {
		IFuncListIterator iter;

		for (iter = _list.begin(); iter != _list.end();) {
			if ((*iter)->compare(fun)) {
				delete (*iter);
				iter = _list.erase(iter);
				break;
			}
			else {
				iter++;
			}
		}
	}
public:
	~DELEGATE() {
		clear();
	}

	typedef TYPENAME std::list<BASE_DELEGATE TEMPLATE_S_ARGS*> IFuncList;
	typedef TYPENAME IFuncList::iterator IFuncListIterator;
	typedef TYPENAME IFuncList::const_iterator ConstIFuncListIterator;

	template<typename obj_type>
	void connect(obj_type* obj, void(obj_type::*objFunc)(DELEGATE_PARAMS)) {
		connect(new MEMBER_DELEGATE TEMPLATE_O_ARGS(obj, objFunc));
	}

	void connect(void(*Func)(DELEGATE_PARAMS)) {
		connect(new STATIC_DELEGATE TEMPLATE_S_ARGS(Func));
	}

	void connect(BASE_DELEGATE TEMPLATE_S_ARGS* func) {
		disconnect_(func);
		_list.push_back(func);
	}

	void disconnect(BASE_DELEGATE TEMPLATE_S_ARGS* fun) {
		disconnect_(fun);
		delete fun;
	}

	template<typename obj_type>
	void disconnect(obj_type* obj, void(obj_type::*objFunc)(DELEGATE_PARAMS)) {
		disconnect(new MEMBER_DELEGATE TEMPLATE_O_ARGS(obj, objFunc));
	}

	void disconnect(void(*Func)(DELEGATE_PARAMS)) {
		 disconnect(new STATIC_DELEGATE TEMPLATE_S_ARGS(Func));
	}

	void operator()(DELEGATE_PARAMS) {
		IFuncListIterator iter = _list.begin();
		for (; iter != _list.end(); iter++) {
			(*iter)->invoke(DELEGATE_ARGS);
		}
	}

	void operator+=(BASE_DELEGATE TEMPLATE_S_ARGS* Func) {
		connect(Func);
	}

	void operator-=(BASE_DELEGATE TEMPLATE_S_ARGS* Func) {
		disconnect(Func);
	}

	void clear() {
		IFuncListIterator iter;
		for (iter = _list.begin(); iter != _list.end();) {
			delete (*iter);
			iter = _list.erase(iter);
		}
	}

protected:

	IFuncList _list;
};

#undef COMBINE
#undef COMBINE1
#undef BASE_DELEGATE
#undef STATIC_DELEGATE					
#undef MEMBER_DELEGATE					
#undef DELEGATE				

#undef SUFFIX				
#undef TEMPLATE			
#undef TEMPLATE_S_ARGS_DEF	
#undef TEMPLATE_S_ARGS		
#undef TEMPLATE_O_ARGS_DEF	
#undef TEMPLATE_O_ARGS		
#undef DELEGATE_PARAMS		
#undef DELEGATE_ARGS		
#undef TYPENAME