ringbuffer.cpp

下棋

// RingBuffer.cpp: implementation of the CRingBuffer class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
//#include "PowerWatch.h"
#include "RingBuffer.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
/***********************************************************************/
/*id=CRingBuffer													   */
/*func=创建一个指定大小循环缓冲区        						       */
/*format=CRingBuffer(DWORD nKB)                                        */
/*date=2000/9/21 xiepf;	                                               */
/***********************************************************************/
CRingBuffer::CRingBuffer()
{
	m_pBuffer=NULL;
	m_readPoint=m_writePoint=0;
	m_nSize=0;
	m_bFull=0;
	m_bLocked[0]=m_bLocked[1]=FALSE;
}

CRingBuffer::~CRingBuffer()
{
	Release();
}

/**********************************************************************/
/*id=Release													      */
/*func=释放所有资源’											      */
/*format=void Release()                                               */
/*io=                                                                 */
/*return=void                                                         */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/

void CRingBuffer::Release()
{
	 if(m_pBuffer) delete m_pBuffer;
	 m_readPoint=0;
	 m_writePoint=0;
	 m_bFull=0;
	 m_pBuffer=NULL;
}

/**********************************************************************/
/*id=Init													          */
/*func=初始化数据缓冲区，使用前必须调用							      */
/*format=BOOL Init()                                                  */
/*io=nKb:I:DWORD:Ring Buffer Size                                      */
/*return=TRUE:成功                                                    */
/*       FALSE:失败                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/

BOOL CRingBuffer::Init(DWORD nKb)
{
	 m_nSize=nKb*1024;
	 if(m_pBuffer) delete m_pBuffer;
     m_pBuffer=new BYTE[m_nSize];
	 if(m_pBuffer==NULL) return FALSE;
	 m_readPoint=0;
	 m_writePoint=0;
	 m_bFull=0;
	 return TRUE;
}

/**********************************************************************/
/*id=GetDataCount													  */
/*func=读取缓冲区中所有的数据长度							          */
/*format=DWORD GetDataCount()                                         */
/*io=                                                                 */
/*return=DWORD:数据长度                                               */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


DWORD CRingBuffer::GetDataCount()
{
	 ASSERT(m_pBuffer!=NULL);
	 if(m_bFull) return m_nSize;
	 if(m_readPoint==m_writePoint) return 0;	 
	 if(m_writePoint>m_readPoint) return m_writePoint-m_readPoint;
	 else return m_writePoint+m_nSize-m_readPoint;;
}

/**********************************************************************/
/*id=IsFull													          */
/*func=检查缓冲区是否为‘满’							              */
/*format=BOOL IsFull()                                                */
/*io=                                                                 */
/*return=TRUE:缓冲区满                                                */
/*       FALSE:缓冲区不满                                             */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/

BOOL CRingBuffer::IsFull()
{
	 ASSERT(m_pBuffer!=NULL);
	 return m_bFull;
}

/**********************************************************************/
/*id=IsEmpty												          */
/*func=检查缓冲区是否为‘空’							              */
/*format=BOOL IsEmpty()                                               */
/*io=                                                                 */
/*return=TRUE:缓冲区空                                                */
/*       FALSE:缓冲区非空                                             */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


BOOL CRingBuffer::IsEmpty()
{
	 ASSERT(m_pBuffer!=NULL);
	 if(m_bFull) return FALSE;
	 return m_readPoint==m_writePoint;
}

/**********************************************************************/
/*id=Reset													          */
/*func=复位缓冲区							                          */
/*format=void Reset()                                                 */
/*io=                                                                 */
/*return=void                                                         */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


void CRingBuffer::Reset(DWORD nKb)
{
	ASSERT(m_pBuffer!=NULL);
	if(nKb>0) m_nSize=nKb*1024;
    m_readPoint=m_writePoint=0;
	m_bFull=FALSE;
	m_bLocked[0]=m_bLocked[1]=FALSE;
}

/**********************************************************************/
/*id=Read													          */
/*func=读取指定长度的数据并移动读指针                                 */
/*format=BOOL Read(LPBYTE pBuf,DWORD nLen)                            */
/*io=pBuf:O:LPBYTE:数据缓冲区地址                                     */
/*   nLen:I:DWORD:要读取的数据长度									  */
/*return=TRUE:成功                                                    */  
/*       FALSE:失败                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/

BOOL CRingBuffer::Read(LPBYTE pBuf, DWORD nLen)
{
	ASSERT(m_pBuffer!=NULL);
	if(nLen>GetDataCount()) return FALSE;
	ReadData(pBuf,nLen);
	m_readPoint+=nLen;
	m_bFull=0;
	if(m_readPoint>=m_nSize) m_readPoint-=m_nSize;
	return TRUE;
}

/**********************************************************************/
/*id=ReadData												          */
/*func=读取指定长度的数据(不移动读指针)			                      */
/*format=BOOL ReadData(LPBYTE pBuf,DWORD nLen)                        */
/*io=pBuf:O:LPBYTE:数据缓冲区地址                                     */
/*   nLen:I:DWORD:要读取的数据长度									  */
/*return=TRUE:成功                                                    */  
/*       FALSE:失败                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/

void CRingBuffer::ReadData(LPBYTE pBuf, int nLen)
{
    if(m_readPoint+nLen<m_nSize)
		memcpy(pBuf,m_pBuffer+m_readPoint,nLen);
	else
	{
		int nSize=m_nSize-m_readPoint;
		memcpy(pBuf,m_pBuffer+m_readPoint,nSize);
		memcpy(pBuf+nSize,m_pBuffer,nLen-nSize);
	}
}

/**********************************************************************/
/*id=GetFreeCount									                  */
/*func=取得剩余空间大小				                                  */
/*format=DWORD GetFreeCount()                                         */
/*io=                                                                 */
/*return=DWORD:空间大小字节数                                         */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


DWORD CRingBuffer::GetFreeCount()
{
	ASSERT(m_pBuffer!=NULL);
	if(m_bFull) return 0;
	if(m_writePoint>=m_readPoint) return m_nSize+m_readPoint-m_writePoint;
	else return m_readPoint-m_writePoint;
}

/**********************************************************************/
/*id=Write													          */
/*func=写入指定长度的数据,并移动写指针                                */
/*format=BOOL Write(LPBYTE pBuf,DWORD nLen)                           */
/*io=pBuf:I:LPBYTE:数据缓冲区地址                                     */
/*   nLen:I:DWORD:要写入的数据长度									  */
/*return=TRUE:成功                                                    */  
/*       FALSE:失败                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


BOOL CRingBuffer::Write(LPBYTE pBuf, DWORD nLen)
{
	ASSERT(m_pBuffer!=NULL);
    if(nLen>GetFreeCount()) return FALSE;
	if(m_writePoint+nLen<m_nSize) memcpy(m_pBuffer+m_writePoint,pBuf,nLen);
	else
	{
		int nSize=m_nSize-m_writePoint;
		memcpy(m_pBuffer+m_writePoint,pBuf,nSize);
		memcpy(m_pBuffer,pBuf+nSize,nLen-nSize);
	}
	m_writePoint+=nLen;
	if(m_writePoint>m_nSize) m_writePoint-=m_nSize;
	m_bFull=(m_writePoint==m_readPoint);
	return TRUE;
}

/**********************************************************************/
/*id=GetData													      */
/*func=读取指定长度的数据(不移动写指针)	                              */
/*format=BOOL GetData(LPBYTE pBuf,DWORD nLen)                         */
/*io=pBuf:O:LPBYTE:数据缓冲区地址                                     */
/*   nLen:I:DWORD:要读取的数据长度									  */
/*return=TRUE:成功                                                    */  
/*       FALSE:失败                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


BOOL CRingBuffer::GetData(LPBYTE pBuf, DWORD nLen)
{
	ASSERT(m_pBuffer!=NULL);
	if(nLen>GetDataCount()) return FALSE;
	ReadData(pBuf,nLen);
	return TRUE;
}

/**********************************************************************/
/*id=CanWrite												          */
/*func=测试缓冲区是否有足够空间可以写入指定长度的数据                 */
/*format=BOOL CanWrite(DWORD nLen)                                    */
/*io=nLen:I:DWORD:要写入的数据长度									  */
/*return=TRUE:可以                                                    */  
/*       FALSE:不行                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


BOOL CRingBuffer::CanWrite(DWORD nLen)
{
	ASSERT(m_pBuffer!=NULL);
	return GetFreeCount()>=nLen;
}

/**********************************************************************/
/*id=CanRead												          */
/*func=测试缓冲区是否有足够数据可读                                   */
/*format=BOOL CanRead(DWORD nLen)                                     */
/*io=nLen:I:DWORD:要读取的数据长度									  */
/*return=TRUE:可以                                                    */  
/*       FALSE:不行                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


BOOL CRingBuffer::CanRead(DWORD nLen)
{
	ASSERT(m_pBuffer!=NULL);
    return GetDataCount()>=nLen;
}

/**********************************************************************/
/*id=Skip												              */
/*func=跳过指定长度的数据(移动读指针，负数则恢复，不能为零)           */
/*format=BOOL Skip(int nLen)                                          */
/*io=nLen:I:int:要跳过的数据长度									  */
/*return=TRUE:成功                                                    */  
/*       FALSE:失败                                                   */
/*date=2000/9/21 xiepf	                                              */
/**********************************************************************/


BOOL CRingBuffer::Skip(int nLen)
{
	ASSERT(m_pBuffer!=NULL);
	if(nLen==0) return FALSE;
	if(nLen>0)
	{
	   if((DWORD)nLen>GetDataCount()) return FALSE;
	   m_readPoint+=nLen;
	   if(m_readPoint>=m_nSize) m_readPoint-=m_nSize;
	}
	else
	{
	   if((DWORD)-nLen>GetFreeCount()) return FALSE;
	   if(m_readPoint>(DWORD)-nLen)  m_readPoint+=nLen;
	   else m_readPoint+=(m_nSize+nLen);	   
	}
	return TRUE;
}

BOOL CRingBuffer::IsLocked()
{
	return m_bLocked[0]&&m_bLocked[1];
}

void CRingBuffer::Lock(BOOL bLock)
{
	if(bLock)
	{
	   if(!m_bLocked[0]) m_bLocked[0]=1;
	   else if(!m_bLocked[1]) m_bLocked[1]=1;
	}
	else
	{
	   if(m_bLocked[0]) m_bLocked[0]=0;
	   else if(m_bLocked[1]) m_bLocked[1]=0;
	}
}

BOOL CRingBuffer::WriteToFile(CFile &file, DWORD nLen)
{
	ASSERT(m_pBuffer!=NULL);
	if(nLen>GetDataCount()) return FALSE;
	TRY
	{
		if(m_readPoint+nLen<m_nSize)
			file.Write(m_pBuffer+m_readPoint,nLen);
		else
		{
			int nSize=m_nSize-m_readPoint;
			file.Write(m_pBuffer+m_readPoint,nSize);
			file.Write(m_pBuffer,nLen-nSize);
		}	
	}CATCH(CFileException,e)
	{
		return FALSE;
	}END_CATCH;
	m_readPoint+=nLen;
	m_bFull=0;
	if(m_readPoint>=m_nSize) m_readPoint-=m_nSize;
	return TRUE;    
}

BOOL CRingBuffer::WriteToFile(CFile &file)
{
    DWORD nLen=GetDataCount();
	if(nLen==0) return FALSE;
	TRY
	{
		if(m_readPoint+nLen<m_nSize)
			file.Write(m_pBuffer+m_readPoint,nLen);
		else
		{
			int nSize=m_nSize-m_readPoint;
			file.Write(m_pBuffer+m_readPoint,nSize);
			file.Write(m_pBuffer,nLen-nSize);
		}
	}CATCH(CFileException,e)
	{
		return FALSE;
	}END_CATCH;
	m_readPoint=m_writePoint;
	m_bFull=0;
	return TRUE;
}

BOOL CRingBuffer::ReadFromFile(CFile &file, DWORD nLen)
{
   DWORD nFree=GetFreeCount();
   if(nFree<nLen) return FALSE;
   TRY
   {
	  if(m_writePoint+nLen<m_nSize) 
		  file.Read(m_pBuffer+m_writePoint,nLen);
	  else
	  {
		int nSize=m_nSize-m_writePoint;
		file.Read(m_pBuffer+m_writePoint,nSize);
		file.Read(m_pBuffer,nLen-nSize);
	  }
   }
   CATCH(CFileException,e)
   {
   }END_CATCH;   
   m_writePoint+=nLen;
   if(m_writePoint>m_nSize) m_writePoint-=m_nSize;
   m_bFull=(m_writePoint==m_readPoint);
   return TRUE;
}