Servers/%E5%85%A8%E5%B1%80%E5%AE%9A%E4%B9%89/Array.h

#ifndef ARRAY_HEAD_FILE
#define ARRAY_HEAD_FILE

#pragma once

//////////////////////////////////////////////////////////////////////////////////

//<2F><><EFBFBD><EFBFBD>ģ<EFBFBD><C4A3><EFBFBD><EFBFBD>
template <class TYPE, class ARG_TYPE=const TYPE &> class CWHArray
{
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
protected:
	TYPE *							m_pData;							//<2F><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
	INT_PTR							m_nMaxCount;						//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ
	INT_PTR							m_nGrowCount;						//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ
	INT_PTR							m_nElementCount;					//Ԫ<><D4AA><EFBFBD><EFBFBD>Ŀ

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
public:
	//<2F><><EFBFBD>캯<EFBFBD><ECBAAF>
	CWHArray();
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	virtual ~CWHArray();

	//<2F><>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>
public:
	//<2F>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
	bool IsEmpty() const;
	//<2F><>ȡ<EFBFBD><C8A1>Ŀ
	INT_PTR GetCount() const;

	//<2F><><EFBFBD>ܺ<EFBFBD><DCBA><EFBFBD>
public:
	//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
	TYPE * GetData();
	//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
	const TYPE * GetData() const;
	//<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
	INT_PTR Add(ARG_TYPE newElement);
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	VOID Copy(const CWHArray & Src);
	//׷<><D7B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	INT_PTR Append(const CWHArray & Src);
	//<2F><>ȡԪ<C8A1><D4AA>
	TYPE & GetAt(INT_PTR nIndex);
	//<2F><>ȡԪ<C8A1><D4AA>
	const TYPE & GetAt(INT_PTR nIndex) const;
	//<2F><>ȡԪ<C8A1><D4AA>
	TYPE & ElementAt(INT_PTR nIndex);
	//<2F><>ȡԪ<C8A1><D4AA>
	const TYPE & ElementAt(INT_PTR nIndex) const;

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
public:
	//<2F><><EFBFBD>ô<EFBFBD>С
	VOID SetSize(INT_PTR nNewSize);
	//<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
	VOID SetAt(INT_PTR nIndex, ARG_TYPE newElement);
	//<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
	VOID SetAtGrow(INT_PTR nIndex, ARG_TYPE newElement);
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	VOID InsertAt(INT_PTR nIndex, const CWHArray & Src);
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	VOID InsertAt(INT_PTR nIndex, ARG_TYPE newElement, INT_PTR nCount=1);
	//ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	VOID RemoveAt(INT_PTR nIndex, INT_PTR nCount=1);
	//ɾ<><C9BE>Ԫ<EFBFBD><D4AA>
	VOID RemoveAll();

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
public:
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	TYPE & operator[](INT_PTR nIndex);
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	const TYPE & operator[](INT_PTR nIndex) const;

	//<2F>ڴ溯<DAB4><E6BAAF>
public:
	//<2F>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
	VOID FreeMemory();
	//<2F><><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
	VOID AllocMemory(INT_PTR nNewCount);
};

//////////////////////////////////////////////////////////////////////////////////
// CWHArray<TYPE, ARG_TYPE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

//<2F>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE> 
AFX_INLINE bool CWHArray<TYPE, ARG_TYPE>::IsEmpty() const
{
	return (m_nElementCount==0);
}

//<2F><>ȡ<EFBFBD><C8A1>Ŀ
template<class TYPE, class ARG_TYPE>
AFX_INLINE INT_PTR CWHArray<TYPE, ARG_TYPE>::GetCount() const
{
	return m_nElementCount;
}

//<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
template<class TYPE, class ARG_TYPE>
AFX_INLINE INT_PTR CWHArray<TYPE,ARG_TYPE>::Add(ARG_TYPE newElement)
{
	INT_PTR nIndex=m_nElementCount;
	SetAtGrow(nIndex,newElement);
	return nIndex;
}

//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE>
AFX_INLINE TYPE & CWHArray<TYPE, ARG_TYPE>::operator[](INT_PTR nIndex)
{ 
	return ElementAt(nIndex);
}

//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE>
AFX_INLINE const TYPE & CWHArray<TYPE, ARG_TYPE>::operator[](INT_PTR nIndex) const
{ 
	return GetAt(nIndex);
}

//////////////////////////////////////////////////////////////////////////////////
// CWHArray<TYPE, ARG_TYPE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

//<2F><><EFBFBD>캯<EFBFBD><ECBAAF>
template<class TYPE, class ARG_TYPE> 
CWHArray<TYPE, ARG_TYPE>::CWHArray()
{
	m_pData=NULL;
	m_nMaxCount=0;
	m_nGrowCount=0;
	m_nElementCount=0;

	return;
}

//<2F><><EFBFBD>캯<EFBFBD><ECBAAF>
template<class TYPE, class ARG_TYPE> 
CWHArray<TYPE,ARG_TYPE>::~CWHArray()
{
	if (m_pData!=NULL)
	{
		for (INT_PTR i=0;i<m_nElementCount;i++)	(m_pData+i)->~TYPE();
		delete [] (BYTE *)m_pData;
		m_pData=NULL;
	}

	return;
}

//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE> 
TYPE * CWHArray<TYPE,ARG_TYPE>::GetData()
{
	return m_pData;
}

//<2F><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE> 
const TYPE * CWHArray<TYPE,ARG_TYPE>::GetData() const
{
	return m_pData;
}

//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE> 
VOID CWHArray<TYPE,ARG_TYPE>::Copy(const CWHArray & Src)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(this!=&Src);
	if (this==&Src) return;

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	AllocMemory(Src.m_nElementCount);
	if (m_nElementCount>0)
	{
		for (INT_PTR i=0;i<m_nElementCount;i++) (m_pData+i)->~TYPE();
		memset(m_pData,0,m_nElementCount*sizeof(TYPE));
	}
	for (INT_PTR i=0;i<Src.m_nElementCount;i++)	m_pData[i]=Src.m_pData[i];
	m_nElementCount=Src.m_nElementCount;

	return;
}

//׷<><D7B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE> 
INT_PTR CWHArray<TYPE,ARG_TYPE>::Append(const CWHArray & Src)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(this!=&Src);
	if (this==&Src) AfxThrowInvalidArgException();

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	if (Src.m_nElementCount>0)
	{
		INT_PTR nOldCount=m_nElementCount;
		AllocMemory(m_nElementCount+Src.m_nElementCount);
		for (INT_PTR i=0;i<Src.m_nElementCount;i++)	m_pData[m_nElementCount+i]=Src.m_pData[i];
		m_nElementCount+=Src.m_nElementCount;
	}

	return m_nElementCount;
}

//<2F><>ȡԪ<C8A1><D4AA>
template<class TYPE, class ARG_TYPE> 
TYPE & CWHArray<TYPE,ARG_TYPE>::GetAt(INT_PTR nIndex)
{
	ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
	if ((nIndex<0)||(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();
	
	return m_pData[nIndex];
}

//<2F><>ȡԪ<C8A1><D4AA>
template<class TYPE, class ARG_TYPE> 
const TYPE & CWHArray<TYPE,ARG_TYPE>::GetAt(INT_PTR nIndex) const
{
	ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
	if ((nIndex<0)||(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();
	
	return m_pData[nIndex];
}

//<2F><>ȡԪ<C8A1><D4AA>
template<class TYPE, class ARG_TYPE> 
TYPE & CWHArray<TYPE,ARG_TYPE>::ElementAt(INT_PTR nIndex)
{
	ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
	if ((nIndex<0)&&(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();
	
	return m_pData[nIndex];
}

//<2F><>ȡԪ<C8A1><D4AA>
template<class TYPE, class ARG_TYPE> 
const TYPE & CWHArray<TYPE,ARG_TYPE>::ElementAt(INT_PTR nIndex) const
{
	ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
	if ((nIndex<0)&&(nIndex>=m_nElementCount)) AfxThrowInvalidArgException();

	return m_pData[nIndex];
}

//<2F><><EFBFBD>ô<EFBFBD>С
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::SetSize(INT_PTR nNewSize)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(nNewSize>=0);
	if (nNewSize<0)	AfxThrowInvalidArgException();
	
	//<2F><><EFBFBD>ô<EFBFBD>С
	AllocMemory(nNewSize);
	if (nNewSize>m_nElementCount)
	{
		for (INT_PTR i=m_nElementCount;i<nNewSize;i++) new ((VOID *)(m_pData+i)) TYPE;
	}
	else if (nNewSize<m_nElementCount)
	{
		for (INT_PTR i=nNewSize;i<m_nElementCount;i++) (m_pData+i)->~TYPE();
		memset(m_pData+nNewSize,0,(m_nElementCount-nNewSize)*sizeof(TYPE));
	}
	m_nElementCount=nNewSize;

	return;
}

//<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::SetAt(INT_PTR nIndex, ARG_TYPE newElement)
{
	ASSERT((nIndex>=0)&&(nIndex<m_nElementCount));
	if ((nIndex>=0)&&(nIndex<m_nElementCount)) m_pData[nIndex]=newElement;
	else AfxThrowInvalidArgException();

	return;
}

//<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::SetAtGrow(INT_PTR nIndex, ARG_TYPE newElement)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(nIndex>=0);
	if (nIndex<0) AfxThrowInvalidArgException();

	//<2F><><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
	if (nIndex>=m_nElementCount) SetSize(m_nElementCount+1);
	m_pData[nIndex]=newElement;

	return;
}

//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::InsertAt(INT_PTR nIndex, const CWHArray & Src)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(nStartIndex>=0);
	if (nStartIndex<0) AfxThrowInvalidArgException();

	if (Src.m_nElementCount>0)
	{
		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		if (nIndex<m_nElementCount)
		{
			INT_PTR nOldCount=m_nElementCount;
			SetSize(m_nElementCount+Src.m_nElementCount);
			for (INT_PTR i=0;i<nCount;i++) (m_pData+nOldCount+i)->~TYPE();
			memmove(m_pData+nIndex+nCount,m_pData+nIndex,(nOldCount-nIndex)*sizeof(TYPE));
			memset(m_pData+nIndex,0,Src.m_nElementCount*sizeof(TYPE));
			for (INT_PTR i=0;i<Src.m_nElementCount;i++) new (m_pData+nIndex+i) TYPE();
		}
		else SetSize(nIndex+nCount);

		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		ASSERT((nIndex+Src.m_nElementCount)<=m_nElementCount);
		while (nCount--) m_pData[nIndex++]=newElement;
	}

	return;
}

//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::InsertAt(INT_PTR nIndex, ARG_TYPE newElement, INT_PTR nCount)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(nIndex>=0);
	ASSERT(nCount>0);
	if ((nIndex<0)||(nCount<=0)) AfxThrowInvalidArgException();

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	if (nIndex<m_nElementCount)
	{
		INT_PTR nOldCount=m_nElementCount;
		SetSize(m_nElementCount+nCount);
		for (INT_PTR i=0;i<nCount;i++) (m_pData+nOldCount+i)->~TYPE();
		memmove(m_pData+nIndex+nCount,m_pData+nIndex,(nOldCount-nIndex)*sizeof(TYPE));
		memset(m_pData+nIndex,0,nCount*sizeof(TYPE));
		for (INT_PTR i=0;i<nCount;i++) new (m_pData+nIndex+i) TYPE();
	}
	else SetSize(nIndex+nCount);

	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT((nIndex+nCount)<=m_nElementCount);
	while (nCount--) m_pData[nIndex++]=newElement;

	return;
}

//ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::RemoveAt(INT_PTR nIndex, INT_PTR nCount)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(nIndex>=0);
	ASSERT(nCount>=0);
	ASSERT(nIndex+nCount<=m_nElementCount);
	if ((nIndex<0)||(nCount<0)||((nIndex+nCount>m_nElementCount))) AfxThrowInvalidArgException();

	//ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	INT_PTR nMoveCount=m_nElementCount-(nIndex+nCount);
	for (INT_PTR i=0;i<nCount;i++) (m_pData+nIndex+i)->~TYPE();
	if (nMoveCount>0) memmove(m_pData+nIndex,m_pData+nIndex+nCount,nMoveCount*sizeof(TYPE));
	m_nElementCount-=nCount;

	return;
}

//ɾ<><C9BE>Ԫ<EFBFBD><D4AA>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::RemoveAll()
{
	if (m_nElementCount>0)
	{
		for (INT_PTR i=0;i<m_nElementCount;i++) (m_pData+i)->~TYPE();
		memset(m_pData,0,m_nElementCount*sizeof(TYPE));
		m_nElementCount=0;
	}

	return;
}

//<2F>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::FreeMemory()
{
	if (m_nElementCount!=m_nMaxCount)
	{
		TYPE * pNewData=NULL;
		if (m_nElementCount!=0)
		{
			pNewData=(TYPE *) new BYTE[m_nElementCount*sizeof(TYPE)];
			memcpy(pNewData,m_pData,m_nElementCount*sizeof(TYPE));
		}
		delete [] (BYTE *)m_pData;
		m_pData=pNewData;
		m_nMaxCount=m_nElementCount;
	}

	return;
}

//<2F><><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
template<class TYPE, class ARG_TYPE>
VOID CWHArray<TYPE,ARG_TYPE>::AllocMemory(INT_PTR nNewCount)
{
	//Ч<><D0A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ASSERT(nNewCount>=0);

	if (nNewCount>m_nMaxCount)
	{
		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ
		INT_PTR nGrowCount=m_nGrowCount;
		if (nGrowCount==0)
		{
			nGrowCount=m_nElementCount/8;
			nGrowCount=(nGrowCount<4)?4:((nGrowCount>1024)?1024:nGrowCount);
		}
		nNewCount+=nGrowCount;

		//<2F><><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
		TYPE * pNewData=(TYPE *) new BYTE[nNewCount*sizeof(TYPE)];
		memcpy(pNewData,m_pData,m_nElementCount*sizeof(TYPE));
		memset(pNewData+m_nElementCount,0,(nNewCount-m_nElementCount)*sizeof(TYPE));
		delete [] (BYTE *)m_pData;

		//<2F><><EFBFBD>ñ<EFBFBD><C3B1><EFBFBD>
		m_pData=pNewData;
		m_nMaxCount=nNewCount;
	}

	return;
}

//////////////////////////////////////////////////////////////////////////////////

#endif