circularbuffer.h.bak

来自「网络socket,IO,线程池」· BAK 代码 · 共 156 行

#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;

tempalte <>
class	CCircularBuffer<char>
{
public:
	bool		Read(vector<T>& vT,int nLen)
	{
		return true;
	}
	bool		Write(const vector<T>& vT)
	{
		return true;
	}
};

tempalte <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);	
	
private:

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

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

// Destructor
CCircularBuffer::~CCircularBuffer()
{
}

tempalte <typename T>
bool 	CCircularBuffer::Read(vector<T>& vT,int nLen)
{
	if(nLen < 0 || nLen > m_nSize)
		return false;
	CLock<CCriSection>	lock;
	int	nLenToEnd = LenToEnd(READ);
	if(nLenToEnd > 0)
	{
		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++]);
	}
}

tempalte <typename T>
bool	CCircularBuffer::Write(const vector<T>& vT)
{
	int nLen = vT.size();
	if(nLen < 0 || nLen > m_nSize)
		return false;
		
	CLock<CCriSection>	lock;	
	int nLenToEnd = LenToEnd(WRITE);
	if(nLenToEnd > 0)
	{
		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		                                          //
////////////////////////////////////////////////////////////////////////////
int	CCircularBuffer::LenToEnd(eOper)
{
	switch(eOper)
	{
		case READ:
			return m_nSize - m_nReadPos;
			break;
		case READ:
			return m_nSize - m_nWritePos;
			break;
		case NO:
			return 0;
			break;
		default:
			return 0;
			break;			
	}
}

#endif