linebuffer.cpp

下棋

// LineBuffer.cpp: implementation of the CLineBuffer class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "LineBuffer.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
/**********************************************************************/
/*id=CLineBuffer													  */
/*func=构造线形缓冲区									 		       */
/*format=CPingBuffer()                                                */
/*io=                                                                 */
/*date=2000/10/9    YQ	                                              */
/**********************************************************************/
CLineBuffer::CLineBuffer()
{
	m_pBuffer=NULL;
	m_nMaxLength=0;
	m_nLength=0;
}

/**********************************************************************/
/*id=~CLineBuffer													  */
/*func=析构线形缓冲区									 		       */
/*format=~CPingBuffer()                                               */
/*io=                                                                 */
/*date=2000/10/9    YQ	                                              */
/**********************************************************************/
CLineBuffer::~CLineBuffer()
{
	delete m_pBuffer;
}

/***********************************************************************/
/*id=CLineBuffer													   */
/*func=用指定的长度构造线形缓冲区			     					 	*/
/*format=CLineBuffer(DWORD nLen)                                       */
/*io=nLen 指定的数据长度                                                */
/*date=2000/10/9    YQ	                                               */
/***********************************************************************/
CLineBuffer::CLineBuffer(DWORD nLen)
{
	m_pBuffer=new BYTE[nLen];
	memset(m_pBuffer,0,nLen);
	m_nMaxLength=nLen;
	m_nLength=0;
}

/***********************************************************************/
/*id=CLineBuffer													   */
/*func=类拷贝函数			     					 		            */
/*format=CLineBuffer(DWORD &other)                                     */
/*io=other 被拷贝的类                                                   */
/*date=2000/10/9    YQ	                                               */
/***********************************************************************/
CLineBuffer::CLineBuffer(CLineBuffer &other)
{
	*this=other;
}

/***********************************************************************/
/*id=CLineBuffer													   */
/*func=用指定的缓冲和缓冲区长度构造线形缓冲区			 		         */
/*format=CLineBuffer(LPVOID pBuf, int nLen)                            */
/*io=pBuf 指定的缓冲区												    */
/*   nLen 指定的数据长度                                                */
/*return=									                           */
/*date=2000/10/9    YQ	                                               */
/***********************************************************************/
CLineBuffer::CLineBuffer(LPVOID pBuf, int nLen)
{
	m_pBuffer=new BYTE[nLen];
	memcpy(m_pBuffer,pBuf,nLen);
	m_nMaxLength=nLen;
	m_nLength=nLen;
}

/***********************************************************************/
/*id=GetCount													       */
/*func=得到缓冲区的长度，以字节BYTE计量			 		                 */
/*format=GetCount()													   */
/*io=					                                               */
/*return=返回DWORD表示缓冲区的长度									    */
/*date=2000/10/9    YQ	                                               */
/***********************************************************************/
DWORD CLineBuffer::GetCount()
{
	return (m_nLength);
}

/***********************************************************************/
/*id=GetBuffer													       */
/*func=返回线形缓冲区的指针			 									*/
/*format=GetBuffer()												   */
/*io=					                                               */
/*return=返回 BYTE*表示的缓冲区的指针		                            */
/*date=2000/10/9    YQ	                                               */
/***********************************************************************/
BYTE* CLineBuffer::GetBuffer()
{
	if (m_pBuffer!=NULL) return m_pBuffer;
	else return NULL;
}

/***********************************************************************/
/*id= operator =													   */
/*func=重载“=”操作符			 							            */
/*format=operator =(CLineBuffer &buf)                                  */
/*io=buf  指定的被等于类											    */
/*return= CLineBuffer&返回的被等于类		                            */
/*date=2000/10/10    YQ	                                               */
/***********************************************************************/
const CLineBuffer& CLineBuffer::operator =(CLineBuffer &buf)
{
	DWORD	nLength=buf.GetCount();
	if (m_nMaxLength<nLength)
	{
		if (m_nMaxLength!=0) delete m_pBuffer;
		m_pBuffer=new BYTE[nLength];
		m_nMaxLength=nLength;
	}
	memcpy(m_pBuffer,buf.GetBuffer(),nLength);
	m_nLength=nLength;
	return *this;
}

/***********************************************************************/
/*id= operator +=													   */
/*func=重载“+=”操作符			 							            */
/*format= +=(const CLineBuffer &buf)                                   */
/*io=buf  指定的不变值加数类											*/
/*return= CLineBuffer&返回的被加数类		                            */
/*date=2000/10/10    YQ	                                               */
/***********************************************************************/
const CLineBuffer& CLineBuffer::operator +=(CLineBuffer &buf)
{
	DWORD nLength=buf.GetCount();
	if (m_nMaxLength<m_nLength+nLength)
	{
		if (m_nMaxLength!=0) 
		{
			BYTE* pTemp;
			m_nMaxLength=m_nLength+nLength;
			pTemp=new BYTE[m_nLength+m_nMaxLength];
			memcpy(pTemp,m_pBuffer,m_nLength);
			delete m_pBuffer;
			m_pBuffer=pTemp;
		}
		else
		{
			m_pBuffer=new BYTE[nLength];
			m_nMaxLength=nLength;
		}
	}
	memcpy(m_pBuffer+m_nLength,buf.GetBuffer(),nLength);
	m_nLength+=nLength;

	return *this;
}

/***********************************************************************/
/*id= operator ==													   */
/*func=重载“==”操作符			 							            */
/*format= operator ==(const CLineBuffer &buf)                          */
/*io=buf  用来做比较的CLineBuffer类    									*/
/*return= TRUE	两个CLineBuffer类实例相等                               */
/*        FALSE	两个CLineBuffer类实例不等                               */
/*date=2000/10/10    YQ	                                               */
/***********************************************************************/
BOOL CLineBuffer::operator ==(CLineBuffer &buf)
{
	if (m_nLength!=buf.GetCount()) return FALSE;
	if (memcmp(m_pBuffer,buf.GetBuffer(),m_nLength)==0)
		return TRUE;
	else
		return FALSE;
}

/***********************************************************************/
/*id= FromBuffer													   */
/*func=直接利用pBuf生成线形缓冲区类							            */
/*format=FromBuffer(LPBYTE pBuf, DWORD nLen)                           */
/*io=LPBYTE  指定将pBuf赋给线形缓冲区，								    */
/*   DWORD   nLen指定pBuf的长度										   */
/*return=TRUE 分配成功(总是会返回TRUE）					                */
/*       FALSE 分配失败											       */
/*date=2000/10/9    YQ	                                              */
/**********************************************************************/
BOOL CLineBuffer::FromBuffer(LPBYTE pBuf, DWORD nLen)
{
	if (m_nMaxLength==0)
	{
		m_nMaxLength=m_nLength=nLen;
		m_pBuffer=new BYTE[m_nMaxLength];
		memcpy(m_pBuffer,pBuf,m_nMaxLength);
	}
	else
	{
		if(nLen>m_nMaxLength)
		{
			delete m_pBuffer;
			m_pBuffer=new BYTE[nLen];
			m_nMaxLength=nLen;
		}
		memcpy(m_pBuffer,pBuf,nLen);
		m_nLength=nLen;
	}
	return TRUE;
}

/******************************************************************/
/*id=IsEmpty													  */
/*func=检查线形缓冲区是否为空	     					 		   */
/*format=IsEmpty()												  */
/*io=															  */
/*return=TRUE 缓冲区为空										   */
/*       FALSE缓冲区不为空										   */	
/*date=2000/10/9    YQ	                                          */
/******************************************************************/
BOOL CLineBuffer::IsEmpty()
{
	if (m_nLength==0)
		return TRUE;
	else
		return FALSE;
}

/***********************************************************************/
/*id= EmptyBuffer													   */
/*func=清空缓冲但并将它置为0			 					            */
/*format= EmptyBuffer()                                                */
/*io=																   */
/*return															   */
/*date=2000/10/9    YQ	                                               */
/***********************************************************************/
void CLineBuffer::EmptyBuffer()
{
	if (m_nMaxLength!=0) memset(m_pBuffer,0,m_nMaxLength);
	m_nLength=0;
}

/***********************************************************************/
/*id= ReadFromFile													   */
/*func=从一个CFile实例中读取指定长度的缓冲段				             */
/*format= ReadFromFile(CFile &file, DWORD nLen)                        */
/*io= file指定将要读取的CFile对象实例								    */
/*    nLen指定将要读取的缓冲区的长度								    */
/*return=TRUE 读取成功												   */
/*       FALSE读取失败                          					   */
/*date=2000/10/11   YQ	                                               */
/***********************************************************************/
BOOL CLineBuffer::ReadFromFile(CFile &file, DWORD nLen)
{
	if (m_nMaxLength<nLen)
	{
		if (m_nMaxLength!=0) delete m_pBuffer;
		m_pBuffer=new BYTE[nLen];
		m_nMaxLength=nLen;
	}
	m_nLength=nLen;

	TRY
	{
		file.Read(m_pBuffer,nLen);
	}
	CATCH(CFileException,e)
	{
		return FALSE;
	}
	END_CATCH;   
	return TRUE;
}

/***********************************************************************/
/*id= WriteToFile													   */
/*func=将指定长度的缓冲区内容写入CFile实例中去				             */
/*format= WriteToFile(CFile &file, DWORD nLen)                         */
/*io= file指定将要写入的CFile对象实例								    */
/*    nLen指定将要写入的缓冲区的长度								    */
/*return=TRUE 读取成功												   */
/*       FALSE读取失败                          					   */
/*date=2000/10/11   YQ	                                               */
/***********************************************************************/
BOOL CLineBuffer::WriteToFile(CFile &file, DWORD nLen)
{
	if (nLen>m_nMaxLength) return FALSE;
	TRY
	{
		file.Write(m_pBuffer,nLen);
	}
	CATCH(CFileException,e)
	{
		return FALSE;
	}
	END_CATCH;
	return TRUE;
}

/***********************************************************************/
/*id= WriteToFile													   */
/*func=把全部数据写入到文件中。				                            */
/*format= WriteToFile(CFile &file)                                     */
/*io= file指定将要写入的CFile文件对象实例								*/
/*return=TRUE 读取成功												   */
/*       FALSE读取失败                          					   */
/*date=2000/10/11   YQ	                                               */
/***********************************************************************/
BOOL CLineBuffer::WriteToFile(CFile &file)
{
	if (m_nMaxLength==0) return FALSE;
	TRY
	{
		file.Write(m_pBuffer,m_nMaxLength);
	}
	CATCH(CFileException,e)
	{
		return FALSE;
	}
	END_CATCH;
	return TRUE;
}

/***********************************************************************/
/*id=SetLength													       */
/*func=设置线形缓冲区的有效长度		 									*/
/*format=SetLength(DWORD nLen)										   */
/*io=DWORD nLen为将要设置的有效长度                                     */
/*return=TRUE 设置成功，返回TRUE		                                */
/*       FALSE表示设置失败	                                            */
/*Note:  现在此函数总是返回TRUE											*/
/*date=2000/10/10    YQ	                                               */
/***********************************************************************/
BOOL CLineBuffer::SetLength(DWORD nLen)
{
	if (nLen>m_nMaxLength) 
	{
		if(m_nMaxLength!=0)
		{
			BYTE*  pTemp;
			pTemp=new BYTE[nLen];
			memcpy(pTemp,m_pBuffer,m_nLength);

			delete m_pBuffer;
			m_pBuffer=pTemp;			

		}
		else
			m_pBuffer=new BYTE[nLen];
		m_nMaxLength=nLen;
	}
	if(m_nMaxLength>m_nLength)
		memset(m_pBuffer+m_nLength,0,m_nMaxLength-m_nLength);
	m_nLength=nLen;
	return TRUE;
}

/***********************************************************************/
/*id=BufferSet													       */
/*func=设置线形缓冲区的值		 									    */
/*format=BufferSet(BYTE val)										   */
/*io=BYTE val为将要设置的指定值                                         */
/*date=2000/10/10    YQ	                                               */
/***********************************************************************/
void CLineBuffer::BufferSet(BYTE val)
{
	if (m_nMaxLength!=0) memset(m_pBuffer,val,m_nMaxLength);
}

void CLineBuffer::AddData(void *pBuf, int nLength)
{
	if (m_nMaxLength<m_nLength+nLength)
	{
		if (m_nMaxLength!=0) 
		{
			BYTE* pTemp;
			pTemp=new BYTE[m_nLength+nLength];
			memcpy(pTemp,m_pBuffer,m_nLength);

			delete m_pBuffer;
			m_pBuffer=pTemp;
			m_nMaxLength=m_nLength+nLength;
		}
		else
		{
			m_pBuffer=new BYTE[nLength];
			m_nMaxLength=nLength;
		}
	}
	memcpy(m_pBuffer+m_nLength,pBuf,nLength);
	m_nLength+=nLength;
}