テンプレートの実装

/********************************************************************
	created:	2011/11/13
	file base:	define
	file ext:	h
	author:		Clark/ 
	purpose:	
*********************************************************************/
#ifndef __TASK_DEFINE_H__
#define __TASK_DEFINE_H__


struct IEvent{};
struct STimerTrig{};
struct SMonsterMoveTrig{};

#endif //__TASK_DEFINE_H__

/********************************************************************
	created:	2011/11/13
	file base:	CLK
	file ext:	h
	author:		Clark/ 
	purpose:	
*********************************************************************/

#pragma once
#include <tchar.h>
#include <Windows.h>
#include "define.h"

namespace CLK
{
	// CLK 
	class BaseCLK
	{
	public:
		static BOOL Init();
		static void UnInit();
	};

	// 
	class Trace
	{
	public:
		static void Print(const TCHAR* pText);
	};

	// 
	template<DWORD v>  
	class Dword2Type  
	{  
	public:
		enum {VALUE = v};  
	};
}

#include "CLK.h"
#include <iostream>

using namespace std;

BOOL CLK::BaseCLK::Init()
{
	setlocale(LC_ALL,"chs"); 
	return TRUE; 
}
void CLK::BaseCLK::UnInit(){}


void CLK::Trace::Print(const TCHAR* pText)
{
	_tprintf(pText);
}

//------------------------------------------------------------------------------------------------------------------------
 

/********************************************************************
	created:	2011/11/13
	file base:	Trigger
	file ext:	h
	author:		Clark/ 
	purpose:	 
*********************************************************************/
#ifndef __TRIGGER_H__
#define __TRIGGER_H__
#include "..//CLK.h"



class Trigger
{
public:
	//    
	template<class T>  
	BOOL Create(T* pDate)  
	{  
		CreateTrig<T> createTrig;  
		return createTrig(this, pDate);  
	}  

	// ， LUA 
	virtual void OnTrigger() = 0;

	// ， 
	virtual void Release(){ delete this; }

protected:
	Trigger(){}
	virtual ~Trigger(){}

private:
	template<class T>  
	class CreateTrig
	{
	public:
		BOOL operator()(Trigger* pTrigger, T* pDate)
		{
			CLK::Trace::Print(TEXT(" 
"));
			return FALSE;  
		}
	};
};

template<class T>
class TriggerEx:public Trigger{ void OnTrigger(){} };

#endif //__TRIGGER_H__

 

/********************************************************************
	created:	2011/11/13
	file base:	TimerTrig
	file ext:	h
	author:		Clark/ 
	purpose:	 
*********************************************************************/
#ifndef __TIME_TRIGGER_H__
#define __TIME_TRIGGER_H__
#include "..//Trigger.h"



template<>  
class Trigger::CreateTrig<STimerTrig>
{
public:
	BOOL operator()(Trigger* pTrigger, STimerTrig* pDate)
	{
		CLK::Trace::Print(TEXT("STimerTrig 
"));
		TriggerEx<STimerTrig>* pTimerTrig = dynamic_cast<TriggerEx<STimerTrig>*>(pTrigger);
		pTimerTrig->OnTimer(0);
		return TRUE;  
	}
};

template<>
class TriggerEx<STimerTrig>: public Trigger
{
public:
	TriggerEx();
	virtual ~TriggerEx();

	// ， LUA 
	// ： LUA ，LUA ， 
	virtual void OnTrigger();

private:
	// 
	virtual void OnTimer(DWORD dwTimerID)
	{
		if( TIMER_ID == dwTimerID){ OnTrigger();}
	}

private:
	enum { TIMER_ID };
	friend CreateTrig<STimerTrig>;
};


#endif //__TIME_TRIGGER_H__

 

#include "TimerTrig.h"

TriggerEx<STimerTrig>::TriggerEx(){}
TriggerEx<STimerTrig>::~TriggerEx(){}
void TriggerEx<STimerTrig>::OnTrigger()
{
	CLK::Trace::Print(TEXT("TimerTrig ， Lua 
"));
}

 

/********************************************************************
	created:	2011/11/13
	file base:	TimerTrig
	file ext:	h
	author:		Clark/ 
	purpose:	 
*********************************************************************/
#ifndef __MONSTER_MOVE_TRIGGER_H__
#define __MONSTER_MOVE_TRIGGER_H__
#include "..//Trigger.h"



template<>  
class Trigger::CreateTrig<SMonsterMoveTrig>
{
public:
	BOOL operator()(Trigger* pTrigger, SMonsterMoveTrig* pDate)
	{
		CLK::Trace::Print(TEXT("SMonsterMoveTrig 
"));
		TriggerEx<SMonsterMoveTrig>* pMonsterMoveTrig = dynamic_cast<TriggerEx<SMonsterMoveTrig>*>(pTrigger);
		pMonsterMoveTrig->OnTrigger();
		return TRUE;  
	}
};


template<>
class TriggerEx<SMonsterMoveTrig>: public Trigger
{
public:
	TriggerEx();
	virtual ~TriggerEx();

	// ， LUA 
	// ： LUA ，LUA ， 
	virtual void OnTrigger();

private:
	// 
	virtual void OnAction(IEvent *pEvent);
	// 
	virtual void OnResponse(IEvent *pEvent);

	// 
	void SubMsg();
	// 
	void UnSubMsg();
	friend CreateTrig<SMonsterMoveTrig>;
};


#endif //__MONSTER_MOVE_TRIGGER_H__

 

#include "MonsterMoveTrig.h"




TriggerEx<SMonsterMoveTrig>::TriggerEx()
{
}

TriggerEx<SMonsterMoveTrig>::~TriggerEx()
{

}

void TriggerEx<SMonsterMoveTrig>::OnTrigger()
{
	CLK::Trace::Print(TEXT("MonsterMoveTrig ， Lua 
"));
}

void TriggerEx<SMonsterMoveTrig>::OnAction(IEvent *pEvent)
{

}

void TriggerEx<SMonsterMoveTrig>::OnResponse(IEvent *pEvent)
{

}

 

//--------------------------------------------------

#include <iostream>
#include "Trigger//Trigger.h"
#include "Trigger//TimerTrig//TimerTrig.h"
#include "Trigger//MonsterMoveTrig//MonsterMoveTrig.h"

using namespace std;

void main()
{
	CLK::BaseCLK::Init();

	typedef STimerTrig TestClass;
	TestClass data;
	Trigger* pTrigger = new TriggerEx<TestClass>();
	pTrigger->Create(&data);
	pTrigger->Release();
	pTrigger = NULL;

	CLK::BaseCLK::UnInit();
	system("pause");
}