circularbuffer.h

网络socket,IO,线程池

#ifndef _M_CIRCULAR_BUFFER_2004_7_28_ZHY_H
#define _M_CIRCULAR_BUFFER_2004_7_28_ZHY_H

#include <afxmt.h>

#pragma warning(disable:4786)
#include <vector>
using namespace std;

#include "../Synchronization/Lock.h"
using namespace Synchronization;

namespace IO{

template <typename T>
class	CCircularBuffer
{
public:
	enum	eOper
	{
		READ  = 0x01,
		WRITE = 0x02,
		NO    = 0x03
	};
	////////////////////////////////////////////////////////////////////////////
	// Constructors / Destructor                                              //
	////////////////////////////////////////////////////////////////////////////
	
	// Construct	
	CCircularBuffer(int nSize = 50);
	
	// Destructor
	~CCircularBuffer();
	
	////////////////////////////////////////////////////////////////////////////
	// Operations		                                                  //
	////////////////////////////////////////////////////////////////////////////
	bool		Read(vector<T>& vT,int nLen);
	bool		Write(const vector<T>& vT);

	////////////////////////////////////////////////////////////////////////////
	// Inner Operations	                                                  //
	////////////////////////////////////////////////////////////////////////////
	int			LenToEnd(eOper op);	
	
private:

	vector<T>			m_vBuffer;
	int					m_nSize;
	int					m_nReadPos;
	int					m_nWritePos;
	
	CEvent				m_evNotEmpty;
	CCriSection			m_criSection;
};

////////////////////////////////////////////////////////////////////////////
// Constructors / Destructor                                              //
////////////////////////////////////////////////////////////////////////////
	
// Construct	
template <typename T>
CCircularBuffer<T>::CCircularBuffer(int nSize):m_nSize(nSize),m_evNotEmpty(FALSE,TRUE)
{
	m_vBuffer.reserve(m_nSize);
	m_nReadPos = 0;
	m_nWritePos = 0;
	
}

// Destructor
template <typename T>
CCircularBuffer<T>::~CCircularBuffer()
{
}

////////////////////////////////////////////////////////////////////////////
// Operations															  //
////////////////////////////////////////////////////////////////////////////

template <typename T>
bool 	CCircularBuffer<T>::Read(vector<T>& vT,int nLen)
{
	if(nLen < 0 || nLen > m_nSize)
		return false;
	CLock<CCriSection>	lock(m_criSection);	
	int	nLenToEnd = LenToEnd(READ);
	if(nLenToEnd >= nLen)
	{
		for(int i = 0; i < nLen; i++)
			vT.push_back(m_vBuffer[m_nReadPos++]);
		return true;
	}

	if(nLenToEnd < nLen)
	{
		for(int i = 0; i < nLenToEnd; i++)
			vT.push_back(m_vBuffer[m_nReadPos++]);
	}
	int nRemain = nLen - nLenToEnd;
	if(nRemain > 0)
	{
		m_nReadPos = 0;
		for(int i = 0; i < nRemain; i++)
			vT.push_back(m_vBuffer[m_nReadPos++]);
	}
	return true;
}

template <typename T>
bool	CCircularBuffer<T>::Write(const vector<T>& vT)
{
	int nLen = vT.size();
	if(nLen < 0 || nLen > m_nSize)
		return false;
		
	CLock<CCriSection>	lock(m_criSection);	
	int nLenToEnd = LenToEnd(WRITE);
	if(nLenToEnd >= nLen)
	{
		for(int i = 0; i < nLen; i++)			
			m_vBuffer[m_nWritePos++] = vT[i];
		return true;

	}
	if(nLenToEnd < nLen)
	{
		for(int i = 0; i < nLenToEnd; i++)			
			m_vBuffer[m_nWritePos++] = vT[i];
	}
	
	int nRemain = nLen - nLenToEnd;
	if(nRemain > 0)
	{
		m_nWritePos = 0;
		for(int i = 0; i < nRemain; i++)			
			m_vBuffer[m_nWritePos++] = vT[nLenToEnd + i];
	}
	
}

////////////////////////////////////////////////////////////////////////////
// Inner Operations		                                          //
////////////////////////////////////////////////////////////////////////////
template <typename T>
int	CCircularBuffer<T>::LenToEnd(eOper op)
{
	switch(op)
	{
		case READ:
			return m_nSize - m_nReadPos;
			break;
		case WRITE:
			return m_nSize - m_nWritePos;
			break;
		case NO:
			return 0;
			break;
		default:
			return 0;
			break;			
	}
}

template <>
class	CCircularBuffer<char>
{
public:
	enum	eOper
	{
		READ  = 0x01,
		WRITE = 0x02,
		NO    = 0x03
	};

	CCircularBuffer(int nSize = 50):m_nSize(nSize),m_evNotEmpty(FALSE,TRUE),m_buffer(NULL)
	{
		m_buffer = new char[nSize];
		m_nReadPos = 0;
		m_nWritePos = 0;
	}

	bool		Read(char* pBuf,int nLen)
	{
		if(nLen < 0 || nLen > m_nSize)
			return false;

		CLock<CCriSection>	lock(m_criSection);
		int	nLenToEnd = LenToEnd(READ);
		if(nLenToEnd >= nLen)
		{
			memcpy(pBuf,m_buffer + m_nReadPos,nLen);
			m_nReadPos += nLen;
			return true;
		}

		if(nLenToEnd < nLen)
		{
			memcpy(pBuf,m_buffer + m_nReadPos,nLenToEnd);
			m_nReadPos += nLenToEnd;				
		}
		int nRemain = nLen - nLenToEnd;
		if(nRemain > 0)
		{
			m_nReadPos = 0;
			memcpy(pBuf+nLenToEnd,m_buffer,nRemain);
			m_nReadPos += nRemain;
		}
		return true;
	}

	bool		Write(char* pBuf,int nLen)
	{		
		if(nLen < 0 || nLen > m_nSize)
			return false;
		
		CLock<CCriSection>	lock(m_criSection);		
		int nLenToEnd = LenToEnd(WRITE);

		if(nLenToEnd >= nLen)
		{
			memcpy(m_buffer + m_nWritePos, pBuf ,nLen);
			m_nWritePos += nLen;
			return true;

		}
		if(nLenToEnd < nLen)
		{
			memcpy(m_buffer + m_nWritePos,pBuf,nLenToEnd);
			m_nWritePos += nLenToEnd;
		}
	
		int nRemain = nLen - nLenToEnd;
		if(nRemain > 0)
		{
			m_nWritePos = 0;
			memcpy(m_buffer,pBuf + nLenToEnd,nRemain);
			m_nWritePos += nRemain;		
		}
		return true;
	}

private:
	int	LenToEnd(eOper op)
	{
		switch(op)
		{
		case READ:
			return m_nSize - m_nReadPos;
			break;
		case WRITE:
			return m_nSize - m_nWritePos;
			break;
		case NO:
			return 0;
			break;
		default:
			return 0;
			break;			
		}
	}

	char*				m_buffer;
	int					m_nSize;
	int					m_nReadPos;
	int					m_nWritePos;
	
	CEvent				m_evNotEmpty;
	CCriSection			m_criSection;
};

}
#endif