using namespace std;

template<typename T> class MsgCircleEx
{
	size_t m_MaxThreshold;
	INT m_CurPos;

	T *m_pDataQueue;

public:


	MsgCircleEx(void)
	{
		m_CurPos = -1;
		m_MaxThreshold = 0;
		m_pDataQueue = NULL;
	};


	~MsgCircleEx(void)
	{
		Clear();

		if(m_pDataQueue)
		{
			delete []m_pDataQueue;
			m_pDataQueue = NULL;
		}
	};

	bool Clear()
	{

		if(m_pDataQueue)
		{
			memset(m_pDataQueue,0,sizeof(T)*m_MaxThreshold);
			m_CurPos = -1;
		}

		return true;
	};
	void init(size_t LoopThreshold)
	{
		m_MaxThreshold = LoopThreshold*2;
		m_pDataQueue = new T[m_MaxThreshold];
		memset(m_pDataQueue,0,sizeof(T)*m_MaxThreshold);
		m_CurPos = -1;
	};
	
	bool DeQueue(T &rMsg)
	{
		bool ret = false;

		//DebugPrint("before deQue size:%d\n",m_DataQueue.size());
		if(m_CurPos >= 0)
		{
			memcpy(&rMsg,&(m_pDataQueue[m_CurPos]),sizeof(T));
			
			--m_CurPos;
			
			ret = true;
		}


		return ret;
	};
	
	T* PeekLatest()
	{
		if(m_CurPos >= 0)
		{
			return &(m_pDataQueue[m_CurPos]);
		}

		return NULL;
	};
	
	void DeQueueLatest()
	{
		if(m_CurPos >= 0)
		{
			--m_CurPos;
		}
	};

	bool InQueue(T &rMsg)
	{
		bool ret = false;
		if (m_CurPos == -1 || m_CurPos < (INT)m_MaxThreshold)
		{
			memcpy(&(m_pDataQueue[++m_CurPos]),&rMsg,sizeof(T));
			ret = true;
		}

		return ret;
	};

	size_t size()
	{
		if ((m_MaxThreshold / 2) < (size_t)(m_CurPos + 1))
		{
			return (m_MaxThreshold / 2);
		}

		return (size_t)(m_CurPos + 1);
	};
	
	T& operator [] (size_t idx)
	{
		if ((INT)idx > m_CurPos)
		{
			assert(0);
		}
		
		return m_pDataQueue[m_CurPos - idx];
		
	};

	
	
};