octets.cpp

一个实现可以在进程间或者线程间通信的高效环形队列类

#include "stdafx.h"

#include "Octets.h"
#include <string.h>

///////////////////////////////////////////////////////////////////////////////////
// COctets

/*
 *  
 */


#ifndef max
#define max(a,b)            (((a) > (b)) ? (a) : (b))
#endif

#ifndef min
#define min(a,b)            (((a) < (b)) ? (a) : (b))
#endif



COctets::COctets()
{
	stream = NULL;
    datalen = 0;
	buflen = 0;
    dynamic = false;
	m_nGrowBy = 10;
}

/*
 *  
 */
COctets::COctets(UINT nLen)
{
	ACE_ASSERT(nLen > 0);

	stream = MyMemAlloc(nLen);

	buflen = nLen;
	datalen = 0;
	dynamic = true;
	m_nGrowBy = 10;
}

/*
 *  如果fAllocByDll == true：对象的stream的内存是本程序来分配
 *  如果fAllocByDll == false：对象的stream的内存直接指向pDatas.
 *  这时用户必须自己管理(释放)这块内存
 */
COctets::COctets(const BYTE* pDatas, UINT nLenOfDatas, int fAllocByDll)
{
	ACE_ASSERT(nLenOfDatas);

	datalen = buflen = nLenOfDatas;
	dynamic = fAllocByDll;
	m_nGrowBy = 10;

	if (fAllocByDll)
	{
		stream = MyMemAlloc(buflen);
		memcpy(stream, pDatas, datalen*sizeof(BYTE));
	}
	else
	{
		stream = (BYTE*)pDatas;
	}
}

/*
 *  如果fAllocByDll == true：对象的stream的内存是本程序来分配
 *  如果fAllocByDll == false：对象的stream的内存直接指向pDatas.
 *  这时用户必须自己管理(释放)这块内存
 */
COctets::COctets(const char* pDatas, UINT nLenOfDatas, int fAllocByDll)
{
	ACE_ASSERT(nLenOfDatas);

	datalen = buflen = nLenOfDatas;
	dynamic = fAllocByDll;
	m_nGrowBy = 10;

	if (fAllocByDll)
	{
		stream = MyMemAlloc(buflen);
		memcpy(stream, pDatas, datalen*sizeof(BYTE));
	}
	else
	{
		stream = (BYTE *)pDatas;
	}
}

/*
 *  复制构造函数
 */
COctets::COctets(const COctets& octet)
{
	datalen = buflen = octet.datalen; // Only data clone
	m_nGrowBy = 10;
	if (buflen > 0)
	{
		stream = MyMemAlloc(buflen);
		memcpy(stream, octet.stream, datalen*sizeof(BYTE));
		dynamic = true;
	}
	else
	{
		dynamic = false;
		stream = NULL;
	}	
}

/*
 *  pDatas:	以NULL结束的原始数据的指针
 */
COctets::COctets(const char * pDatas)
{
	ACE_ASSERT(pDatas && *pDatas);
	buflen = datalen = strlen(pDatas);
	m_nGrowBy = 10;

	if (buflen > 0)
	{
		stream = MyMemAlloc(buflen);
		memcpy(stream, pDatas, datalen*sizeof(BYTE));
		dynamic = true;
	}
	else
	{
		dynamic = false;
		stream = NULL;
	}
}

/*
 *  析构
 */
COctets::~COctets()
{
	Free();
}


void COctets::SetBufferSize(UINT nLen)
{
	Free();

	if (nLen > 0)
	{
		if ((stream = MyMemAlloc(nLen)) != NULL)
		{
			buflen = nLen;
			datalen = 0;
			dynamic = true;
		}
	}
}

/*
 *  释放内部所有数据，但并不释放对象本身
 */
void COctets::Free()
{
	if (buflen > 0 && stream != NULL)
	{
		if (dynamic)		
			MyMemFree(stream);		

		stream = NULL;
		buflen = 0;
		datalen = 0;
		dynamic = false;
	}
}

/*
 *  根据参数，初始化对象, fAllocByDll的含义同构造函数
 */
void COctets::SetData(const BYTE* string, UINT nLength, int fAllocByDll)
{
	if (!fAllocByDll)
	{
		Free();
		stream = (BYTE *)string;
		buflen = nLength;
		datalen = nLength;
	}
	else
	{
		if (nLength > buflen)
		{
			Free();
			stream = MyMemAlloc(nLength+m_nGrowBy);
			ACE_ASSERT(stream != NULL);
			buflen = nLength + m_nGrowBy;
			dynamic = true;
		}
		if (stream != NULL)
		{
			datalen = nLength;
			memcpy(stream, string, nLength);
		}	
	}
}

/*
 *  根据参数，初始化对象
 */
void COctets::SetDataSize(UINT nLength)
{
	if (nLength > buflen)
	{
		Free();

		stream = MyMemAlloc(nLength+m_nGrowBy);
		
		ACE_ASSERT(stream != NULL);
		buflen = nLength + m_nGrowBy;
		dynamic = true;
	}

	if (stream != NULL)
		datalen = nLength;

	return;
}

/*
 *
 */
void COctets::ExtendBuffer(UINT nExtendLen, int bDataCopy)
{
	if (nExtendLen == 0)
		return;
	
	BYTE* pDatas = MyMemAlloc(this->buflen + nExtendLen);
	if (pDatas == NULL)
		return;

	if (bDataCopy)
		memcpy(pDatas, this->stream, this->datalen);

	MyMemFree(this->stream);		
				
	this->stream = pDatas;
	this->buflen = (this->datalen + nExtendLen);
	this->dynamic = true;
	
	return;
}

/*
 *  复制一个对象 (在使用完返回值后，用户必须调用delete函数释放返回的对象)
 */
COctets* COctets::Clone() const
{
	return new COctets(*this);
}

/*
 *  将字符串拷贝到自身, 返回复制后的本对象引用
 *  在函数内部，已经释放掉本对象以前的内存
 */
COctets& COctets::operator = (const COctets& octet)
{
	SetData(octet.stream, octet.datalen);
	return (*this);
}

/*
 *  将字符串拷贝到自身, 返回复制后的本对象引用
 *  在函数内部，已经释放掉本对象以前的内存
 */
COctets& COctets::operator = (const char* s)
{
	SetData((const BYTE*)s, strlen(s));
	return (*this);
}

/*
 *  将指定字符(串)连接到本对象后面, 返回连接后的本对象引用
 */
COctets& COctets::operator += (const COctets& octet)
{
	BYTE* pDatas;

	if (octet.datalen == 0)
		return *this;

	if (this->datalen + octet.datalen <= this->buflen)
	{
		memcpy(stream + datalen, octet.stream, octet.datalen);
		this->datalen += octet.datalen;
		return *this;
	}
	
	pDatas = MyMemAlloc(this->datalen + octet.datalen + m_nGrowBy);
	if (pDatas == NULL)
		return *this;

	memcpy(pDatas, this->stream, this->datalen);
	memcpy(pDatas + this->datalen, octet.stream, octet.datalen);

	MyMemFree(this->stream);		
	
	this->stream = pDatas;
	this->datalen += octet.datalen;
	this->buflen = (this->datalen + m_nGrowBy);
	this->dynamic = true;
	
	return (*this);
}

/*
 *  将指定字符(串)连接到本对象后面, 返回连接后的本对象引用
 */
COctets& COctets::operator += (const char* s)
{
	ACE_ASSERT(s != NULL);

	BYTE* pDatas;	
	UINT srcLength = strlen(s);

	if (srcLength == 0)
		return *this;

	if (this->datalen + srcLength <= this->buflen)
	{
		memcpy(stream + datalen, s, srcLength);
		this->datalen += srcLength;
		return *this;
	}

	pDatas = MyMemAlloc(this->datalen + srcLength + m_nGrowBy);
	if (pDatas == NULL)
		return *this;

	memcpy(pDatas, this->stream, this->datalen);
	memcpy(pDatas + this->datalen, s, srcLength);

	MyMemFree(this->stream);		
	this->stream = pDatas;
	this->datalen += srcLength;
	this->buflen = (this->datalen + m_nGrowBy);
	this->dynamic = true;
	
	return (*this);
}

/*
 *	
 */
void COctets::Append(const BYTE* pDatas, UINT nLenOfDatas)
{
	ACE_ASSERT(pDatas != NULL);
	if (pDatas == NULL || nLenOfDatas == 0)
		return;

	if (this->datalen + nLenOfDatas <= this->buflen)
	{
		memcpy(stream + datalen, pDatas, nLenOfDatas);
		this->datalen += nLenOfDatas;
		return;
	}

	BYTE* pNew = MyMemAlloc(this->datalen + nLenOfDatas + m_nGrowBy);
	if (pNew == NULL)
		return;

	memcpy(pNew, this->stream, this->datalen);
	memcpy(pNew + this->datalen, pDatas, nLenOfDatas);

	MyMemFree(this->stream);		
	this->stream = pNew;
	this->datalen += nLenOfDatas;
	this->buflen = (this->datalen + m_nGrowBy);
	this->dynamic = true;
	
	return;
}

/*
 *  将指定字符(串)连接到本对象后面, 返回连接后的本对象引用
 */
COctets& COctets::operator += (const char ch)
{
	BYTE* pDatas;	
	if (datalen + 1 <= buflen)
	{
		stream[datalen++] = ch;
		return *this;
	}
	
	pDatas = MyMemAlloc(datalen + m_nGrowBy + 1);
	if (pDatas == NULL)
		return *this;

	memcpy(pDatas, stream, datalen);
	pDatas[datalen++] = ch;

	MyMemFree(stream);		
	stream = pDatas;
	buflen = (datalen + m_nGrowBy);
	dynamic = true;

	return *this;
}

/*
 *  根据下标取stream中的对应字符
 */
BYTE& COctets::operator[](const UINT index)
{
	ACE_ASSERT(index < datalen);
	return stream[index];
}

/*
 *	根据下标取stream中的对应字符
 */
BYTE COctets::operator[](const UINT index) const
{
	ACE_ASSERT(index < datalen);
	return stream[index];
}

/*
 *  在一定的长度内，比较两个八位组串(COctets)的大小
 *  如果 > octet(string), 返回一个大于0的数。
 *  如果 = octet(string), 返回0
 *  如果 < octet(string), 否则返回一个小于0的数	
 */
int COctets::NCompare(const COctets& octet, UINT nChars) const
{
	UINT nMinLength;

	nMinLength = min(this->datalen, octet.datalen);
	nMinLength = min(nMinLength, nChars);

	//先比较字符串
	int iRes = memcmp(this->stream, octet.stream, nMinLength*sizeof(BYTE));

	//如果在字符串内都相等，则比较长度
	if (iRes == 0 && nChars > nMinLength  )
		iRes = this->datalen - octet.datalen;

	return iRes;

}

/*
 *  在一定的长度内，比较两个八位组串(COctets)的大小
 *  如果 > octet(string), 返回一个大于0的数。
 *  如果 = octet(string), 返回0
 *  如果 < octet(string), 否则返回一个小于0的数	
 */
int COctets::NCompare(const char * string, UINT nChars) const
{
	UINT nMinLength;

	nMinLength = min(this->datalen, strlen(string));
	nMinLength = min(nMinLength, nChars);

	//先比较字符串
	int iRes = memcmp(this->stream, string, nMinLength*sizeof(BYTE));

	//如果在字符串内都相等，则比较长度
	if (iRes == 0 && nChars > nMinLength  )
		iRes = this->datalen - strlen(string);

	return iRes;
}

/*
 *  比较两个八位组串(COctets)的大小(与NCompare函数不同，该函数比较全部的字符串)
 *  如果 > octet(string), 返回一个大于0的数。
 *  如果 = octet(string), 返回0
 *  如果 < octet(string), 否则返回一个小于0的数	
 */
int COctets::Compare(const COctets& octet) const
{
	UINT nMaxLength;
	nMaxLength = max(this->datalen, octet.datalen);
	return NCompare(octet, nMaxLength*sizeof(BYTE));
}

/*
 *  比较两个八位组串(COctets)的大小(与NCompare函数不同，该函数比较全部的字符串)
 *  如果 > octet(string), 返回一个大于0的数。
 *  如果 = octet(string), 返回0
 *  如果 < octet(string), 否则返回一个小于0的数	
 */
int COctets::Compare(const char * octet) const
{
	UINT nMaxLength;
	nMaxLength = max(this->datalen, strlen(octet));
	return NCompare(octet, nMaxLength*sizeof(BYTE));
}

/*
 *  友元比较函数
 */
int operator == (const COctets& octet1, const COctets& octet2)
{	
	return (octet1.Compare(octet2) == 0);	
}

/*
 *  友元比较函数
 */
int operator != (const COctets& octet1, const COctets& octet2)
{
	return (octet1.Compare(octet2) != 0);	
}

/*
 *  友元比较函数
 */
int operator >  (const COctets& octet1, const COctets& octet2)
{	
	return (octet1.Compare(octet2) > 0);	
}

/*
 *  友元比较函数
 */
int operator <  (const COctets& octet1, const COctets& octet2)
{	
	return (octet1.Compare(octet2) < 0);	
}

/*
 *  友元比较函数
 */
int operator >= (const COctets& octet1, const COctets& octet2)
{	
	return (octet1.Compare(octet2) >= 0);	
}

/*
 *  友元比较函数
 */
int operator <= (const COctets& octet1, const COctets& octet2)
{	
	return (octet1.Compare(octet2) <= 0);	
}

/*
 *  友元比较函数
 */
int operator == (const COctets& octet1, const char * octet2)
{	
	return (octet1.Compare(octet2) == 0);	
}

/*
 *  友元比较函数
 */
int operator != (const COctets& octet1, const char * octet2)
{	
	return (octet1.Compare(octet2) != 0);	
}

/*
 *  友元比较函数
 */
int operator >  (const COctets& octet1, const char * octet2)
{	
	return (octet1.Compare(octet2) > 0);	
}

/*
 *  友元比较函数
 */
int operator <  (const COctets& octet1, const char * octet2)
{	
	return (octet1.Compare(octet2) < 0);	
}

/*
 *  友元比较函数
 */
int operator >= (const COctets& octet1, const char * octet2)
{	
	return (octet1.Compare(octet2) >= 0);	
}

/*
 *  友元比较函数
 */
int operator <= (const COctets& octet1, const char * octet2)
{	
	return (octet1.Compare(octet2) <= 0);	
}

/*
 *	压缩
 */
void COctets::Compress()
{
	if (datalen == 0)
	{
		Free();
		return;
	}
	
	if (buflen > datalen)
	{
		BYTE* pNew = MyMemAlloc(datalen);
		ACE_ASSERT(pNew != NULL);
		memcpy(pNew, stream, datalen);

		MyMemFree(stream);

		stream = pNew;
		buflen = datalen;
		dynamic = true;
	}


	return;
}