Deliver/include/MsgVector.h

#pragma once
#include "CcosLock.h"
#include "LinuxEvent.h"

#include <vector>
#include <algorithm>


using namespace std;

template<typename T> class MsgVector
{
	CcosLock m_Lock;
	std::shared_ptr<LinuxEvent> m_NotifyInVec;
	vector<T> m_DataVector;

public:


	MsgVector(void)
	{
		m_NotifyInVec = LinuxEvent::CreateEvent(LinuxEvent::MANUAL_RESET,false);
	};


	~MsgVector(void)
	{
		Clear();
	};
	
	//suppose it locked already...
	T &operator [](size_t idx)
	{
		return m_DataVector[idx];
	};
	
	//suppose it locked already...
	T &operator [](int idx)
	{
		return m_DataVector[idx];
	};

	void Lock()
	{
		m_Lock.Thread_Lock();
	};
	
	void UnLock()
	{
		m_Lock.Thread_UnLock();
	};
	
	size_t Size()
	{
		Lock();

		size_t size = m_DataVector.size();

		UnLock();

		return size;
	};

	bool Clear()
	{
		m_NotifyInVec->ResetEvent();
		Lock();

		m_DataVector.clear();

		UnLock();

		return true;
	};

	bool PopBack(T &rMsg)
	{
		bool ret = false;
		Lock();

		//DebugPrint("before deQue size:%d\n",m_DataVector.size());
		if (m_DataVector.size() > 0)
		{
			rMsg = m_DataVector.pop_back();

			ret = true;
		}
		//DebugPrint("after deQue size:%d\n",m_DataVector.size());
		if (m_DataVector.size() == 0)
		{
			m_NotifyInVec->ResetEvent();
		}

		UnLock();

		return ret;
	};

	bool FindAndClear(T &rMsg)
	{
		bool ret = false;
		Lock();
		typename vector<T>::iterator result1 = find(m_DataVector.begin(), m_DataVector.end(), rMsg);
		if (result1 != m_DataVector.end())
		{
			m_DataVector.erase(result1);
			ret = true;
		}
		if (m_DataVector.size() == 0)
		{
			m_NotifyInVec->ResetEvent();
		}
		UnLock();

		return ret;

	};

	bool PushBack(T &rMsg)
	{
		Lock();
		m_DataVector.push_back(rMsg);
		UnLock();

		m_NotifyInVec->SetEvent();

		return true;
	};

	DWORD WaitForInVec(DWORD timeout)
	{
		DWORD ret = WAIT_TIMEOUT;
		Lock();

		if (m_DataVector.size() > 0)
		{
			ret = WAIT_OBJECT_0;
		}

		UnLock();

		if (ret == WAIT_TIMEOUT)
		{
			return m_NotifyInVec->Wait(timeout);
		}

		return ret;

	};

};