ptrcontrol.cpp

指针链表

		DeleteAt(0) ;
	}
}

void CPtrListCtrl::ClearAll()
{
	DeleteAll() ;
}

CPtrListCtrl& CPtrListCtrl::operator=(CPtrCtrl &sPtrCtrlInit)
{
	CopyPtrCtrl(&sPtrCtrlInit) ;

	return *this ;
}

CPtrListCtrl& CPtrListCtrl::operator+=(CPtrCtrl &sPtrCtrlAdd)
{
	AddPtrCtrl(&sPtrCtrlAdd) ;

	return *this ;
}

CPtrListCtrl __stdcall operator+(CPtrListCtrl &sPtrCtrlAdd1, CPtrListCtrl &sPtrCtrlAdd2)
{
	CPtrListCtrl List(sPtrCtrlAdd1) ;
	List.AddPtrCtrl(&sPtrCtrlAdd2) ;

	return List ;
}

// CLASS PTR ARRAY CONTORL
#define MIN_ARRAY_SIZE		1024

CPtrArrayCtrl::CPtrArrayCtrl():
m_lMMFParam(0),
m_pfMMFAlloc(DefAllocFunc),
m_pfMMFReAlloc(DefReAllocFunc),
m_pfMMFFree(DefFreeFunc)
{
	m_nSize			= 0 ;
	m_nCapability	= 0 ;
	m_pDataPtrAarry		= NULL ;	

	SetCurPos(-1) ;
	SetFindData(-1, -1) ;
}

CPtrArrayCtrl::CPtrArrayCtrl(CPtrCtrl *pPtrCtrlInit):
m_lMMFParam(pPtrCtrlInit->GetMMFParam()),
m_pfMMFAlloc(pPtrCtrlInit->GetMMFAllocFunc()),
m_pfMMFReAlloc(pPtrCtrlInit->GetMMFReAllocFunc()),
m_pfMMFFree(pPtrCtrlInit->GetMMFFreeFunc())
{
	m_nSize			= 0 ;
	m_nCapability	= 0 ;
	m_pDataPtrAarry		= NULL ;

	SetCurPos(-1) ;
	SetFindData(-1, -1) ;

	CopyPtrCtrl(pPtrCtrlInit) ;
}

CPtrArrayCtrl::CPtrArrayCtrl(long lMMFParam, AllocFunc pfMMFAlloc, 
							 ReAllocFunc pfMMFReAlloc, FreeFunc pfMMFFree):
m_lMMFParam(lMMFParam),
m_pfMMFAlloc(pfMMFAlloc),
m_pfMMFReAlloc(pfMMFReAlloc),
m_pfMMFFree(pfMMFFree)
{
	m_nSize			= 0 ;
	m_nCapability	= 0 ;
	m_pDataPtrAarry		= NULL ;	

	SetCurPos(-1) ;
	SetFindData(-1, -1) ;
}

CPtrArrayCtrl::~CPtrArrayCtrl()
{
	if (m_pDataPtrAarry)
	{
		m_pfMMFFree(m_pDataPtrAarry, m_lMMFParam) ;
		m_pDataPtrAarry = NULL ;
	}
}

int CPtrArrayCtrl::AddData(void* pData, int nPos/* =-1 */)
{
	if (!OnSizeChange(m_nSize+1))
	{
		return -1 ;
	}

	if (nPos < 0 || nPos > m_nSize)
	{
		nPos = m_nSize ;
	}

	if (nPos < m_nSize)
	{
		memmove(m_pDataPtrAarry+nPos+1, m_pDataPtrAarry+nPos, (m_nSize-nPos)*sizeof(DATAPTR)) ;
	}

	m_pDataPtrAarry[nPos] = (DATAPTR)pData ;

	m_nSize ++ ;

	SetCurPos(nPos) ;

	return nPos ;
}

int CPtrArrayCtrl::AddPtrCtrl(CPtrCtrl *pPtrCtrl, int nPos/* =-1 */)
{
	if (!pPtrCtrl)
	{
		return -1 ;
	}

	int nAddSize = pPtrCtrl->GetCount() ;
	if (nAddSize <= 0)
	{
		return -1 ;
	}

	CPtrArrayCtrl pTmp(m_lMMFParam, m_pfMMFAlloc, m_pfMMFReAlloc, m_pfMMFFree) ;
	if (pPtrCtrl == this)
	{
		pTmp.CopyPtrCtrl(pPtrCtrl) ;
		pPtrCtrl = &pTmp ;
	}

	const char *cClassName = pPtrCtrl->GetClassName() ;
	if (strcmp(cClassName, "CPtrArrayCtrl") == 0)
	{
		CPtrArrayCtrl *pPtrArrayCtrl = (CPtrArrayCtrl *)pPtrCtrl ;

		if (!OnSizeChange(m_nSize+nAddSize))
		{
			return -1 ;
		}
		
		if (nPos < 0 || nPos > m_nSize)
		{
			nPos = m_nSize ;
		}

		if (nPos < m_nSize)
		{
			memmove(m_pDataPtrAarry+nPos+nAddSize, m_pDataPtrAarry+nPos, (m_nSize-nPos)*sizeof(DATAPTR)) ;
		}

		memcpy(m_pDataPtrAarry+nPos, pPtrArrayCtrl->m_pDataPtrAarry, nAddSize*sizeof(DATAPTR)) ;

		m_nSize += nAddSize ;
	}
	else
	{
		if (!OnSizeChange(m_nSize+nAddSize))
		{
			return -1 ;
		}

		int nCount = pPtrCtrl->GetCount() ;
		int i = 0 ;
		for (i = 0 ; i < nCount ; i++)
		{
			void *pData = pPtrCtrl->GetAt(i) ;
			AddData(pData, (nPos==-1) ? -1 : (nPos++)) ;
		}

		SetCurPos(nPos) ;
	}

	return nPos ;
}

int CPtrArrayCtrl::CopyPtrCtrl(CPtrCtrl *pPtrCtrl)
{
	if (!pPtrCtrl)
	{
		return 0 ;
	}

	DeleteAll() ;

	AddPtrCtrl(pPtrCtrl) ;

	SetCurPos(0) ;

	return m_nSize ;
}

int CPtrArrayCtrl::Set(int nPos, void *pNewData)
{
	if (nPos >= 0 && nPos < m_nSize)
	{
		m_pDataPtrAarry[nPos] = (DATAPTR)pNewData ;
		
		SetCurPos(nPos) ;

		return nPos ;
	}
	else
	{
		return -1 ;
	}
}

bool CPtrArrayCtrl::IsDataAvailable(int nPos)
{
	if (nPos >= 0 && nPos < m_nSize)
	{
		return true ;
	}
	else
	{
		return false ;
	}
}

void * CPtrArrayCtrl::GetAt(int nPos)
{
	if (nPos >= 0 && nPos < m_nSize)
	{
		SetCurPos(nPos) ;

		return (void *)m_pDataPtrAarry[nPos] ;
	}
	else
	{
		return NULL ;
	}
}

void * CPtrArrayCtrl::GetHead()
{
	if (m_nSize > 0)
	{
		SetCurPos(0) ;

		return (void *)m_pDataPtrAarry[0] ;
	}
	else
	{
		return NULL ;
	}
}

void *CPtrArrayCtrl::GetTail()
{
	if (m_nSize > 0)
	{
		SetCurPos(m_nSize-1) ;

		return (void *)m_pDataPtrAarry[m_nSize-1] ;
	}
	else
	{
		return NULL ;
	}
}

bool CPtrArrayCtrl::FindDataAtPos(int nFindPos, void *pData, FINDFUNC pfn)
{
	if ( pfn  )
	{
		if (pfn((void *)m_pDataPtrAarry[nFindPos], pData))
		{
			SetFindData(nFindPos, nFindPos) ;

			return true ;
		}
	}
	else
	{
		if ((void *)m_pDataPtrAarry[nFindPos] == pData)
		{
			SetFindData(nFindPos, nFindPos) ;

			return true ;
		}
	}

	return false ;
}

int CPtrArrayCtrl::FindFirst(void *pData, FINDFUNC pfn)
{
	if (!pfn)
	{
		return -1 ;
	}

	if (m_nSize <= 0)
	{
		return -1 ;
	}

	if (m_nCurPos < 0 || m_nCurPos >= m_nSize)
	{
		m_nCurPos = 0 ;
	}

	int i ;
	int nSearchStart = m_nCurPos ;
	
	int nSearchCount = (m_nSize+1) >> 1 ;
	int nFindPosInc, nFindPosDec ;

	for (i = 0 ; i < nSearchCount ; i++)
	{
		nFindPosInc = (nSearchStart+i)%m_nSize ;
		if (FindDataAtPos(nFindPosInc, pData, pfn))
		{
			return nFindPosInc ;
		}

		nFindPosDec = (m_nSize+nSearchStart-i)%m_nSize ;
		if ( nFindPosDec != nFindPosInc )
		{
			if (FindDataAtPos(nFindPosDec, pData, pfn))
			{
				return nFindPosDec ;
			}
		}
	}

	return -1 ;
}

int CPtrArrayCtrl::FindNext(void *pData, FINDFUNC pfn)
{
	if (!pfn)
	{
		return -1 ;
	}

	if (m_nSize <= 0)
	{
		return -1 ;
	}

	if (m_FindData.nFindPos < -1 || m_FindData.nFindPos >= m_nSize)
	{
		m_FindData.nFindPos = -1 ;
	}

	if (m_FindData.nStartPos < 0 || m_FindData.nStartPos >= m_nSize)
	{
		m_FindData.nStartPos = 0 ;
	}

	int i ;
	int nSearchStart = (m_FindData.nFindPos + 1) % m_nSize ;

	int nSearchNumber = 0 ;
	if (m_FindData.nStartPos < nSearchStart)
	{
		nSearchNumber = m_nSize - (nSearchStart-m_FindData.nStartPos) ;
	}
	else
	{
		nSearchNumber = (m_FindData.nStartPos-nSearchStart) ;
	}

	int nFindPos ;
	for (i = 0 ; i < nSearchNumber ; i++, nSearchStart++)
	{
		nFindPos = nSearchStart%m_nSize ;
		if (FindDataAtPos(nFindPos, pData, pfn))
		{
			return nFindPos ;
		}
	}

	return -1 ;
}

void  CPtrArrayCtrl::FindAll(CPtrCtrl *pPtrCtrl, void *pData, FINDFUNC pfn)
{
	if (!pfn || !pPtrCtrl)
	{
		return ;
	}

	pPtrCtrl->DeleteAll() ;

	int i ;
	for (i = 0 ; i < m_nSize ; i++)
	{
		if (FindDataAtPos(i, pData, pfn))
		{
			pPtrCtrl->AddData((void*)i) ;
		}
	}
}

int CPtrArrayCtrl::GetCapability()
{
	return m_nCapability ;
}

void * CPtrArrayCtrl::DeleteAt(int nPos, int nCount/*=1*/)
{
	void *pData = NULL ;

	if (nPos == m_nSize-1 && nPos == m_nCurPos)
	{
		SetCurPos(nPos) ;
	}	

	if (nPos >= 0 && nPos < m_nSize)
	{
		pData = (void *)m_pDataPtrAarry[nPos] ;

		int nDelCount = (m_nSize-nPos) < nCount ? (m_nSize-nPos) : nCount ;
		int nMoveCount = m_nSize-nPos-nDelCount ;
		if (nMoveCount > 0)
		{
			memmove(m_pDataPtrAarry+nPos, m_pDataPtrAarry+(nPos+nDelCount), nMoveCount*sizeof(DATAPTR)) ;
		}

		m_nSize -= nDelCount ;
		OnSizeChange(m_nSize) ;
	}

	SetFindData(m_FindData.nStartPos, m_FindData.nFindPos) ;

	return pData ;
}

void * CPtrArrayCtrl::DeleteHead(void)
{
	return DeleteAt(0) ;
}

void * CPtrArrayCtrl::DeleteTail(void)
{
	return DeleteAt(m_nSize-1) ;
}

void CPtrArrayCtrl::DeleteAll()
{
	m_nSize = 0 ;
	if (m_nCapability > MIN_ARRAY_SIZE)
	{
		OnSizeChange(MIN_ARRAY_SIZE) ;
	}

	SetCurPos(-1) ;
	SetFindData(-1, -1) ;
}

void CPtrArrayCtrl::ClearAll()
{
	DeleteAll() ;
}

bool CPtrArrayCtrl::OnSizeChange(int nNewSize)
{	
	int nCapability = m_nCapability ;
	if (nNewSize >= (m_nCapability>>1))
	{
		nCapability = (m_nCapability<<1) ;		
	}
	else if (nNewSize < (m_nCapability>>2))
	{
		nCapability = (m_nCapability>>1) ;
	}
	else
	{
		return true ;
	}

	if (nCapability < MIN_ARRAY_SIZE)
	{
		nCapability = MIN_ARRAY_SIZE ;
	}

	if (nCapability != m_nCapability)
	{
		DATAPTR *pTemp = NULL ;
		if (m_pDataPtrAarry)
		{
			pTemp = (DATAPTR*)m_pfMMFReAlloc(m_pDataPtrAarry, nCapability*sizeof(DATAPTR), m_lMMFParam) ;
		}
		else
		{
			pTemp = (DATAPTR*)m_pfMMFAlloc(nCapability*sizeof(DATAPTR), m_lMMFParam) ;
		}

		if (pTemp)
		{
			m_pDataPtrAarry = pTemp ;
			m_nCapability = nCapability ;
		}
		else
		{
			// keep current sutiation
			return false ;
		}
	}

	return true ;
}

void CPtrArrayCtrl::SetCurPos(int nPos)
{
	m_nCurPos = nPos ;
}

void CPtrArrayCtrl::SetFindData(int nStartPos, int nFindPos)
{
	m_FindData.nStartPos = nStartPos ;	
	m_FindData.nFindPos = nFindPos ;

	if (m_FindData.nStartPos < -1 || m_FindData.nStartPos >= m_nSize)
	{
		m_FindData.nStartPos = -1 ;
	}

	if (m_FindData.nFindPos < -1 || m_FindData.nFindPos >= m_nSize)
	{
		m_FindData.nFindPos = -1 ;
	}
}

CPtrArrayCtrl& CPtrArrayCtrl::operator=(CPtrCtrl &sPtrCtrlInit)
{
	CopyPtrCtrl(&sPtrCtrlInit) ;

	return *this ;
}

CPtrArrayCtrl& CPtrArrayCtrl::operator+=(CPtrCtrl &sPtrCtrlAdd)
{
	AddPtrCtrl(&sPtrCtrlAdd) ;

	return *this ;
}

CPtrArrayCtrl __stdcall operator+(CPtrArrayCtrl &sPtrCtrlAdd1, CPtrArrayCtrl &sPtrCtrlAdd2)
{
	CPtrArrayCtrl Aarry(&sPtrCtrlAdd1) ;
	Aarry.AddPtrCtrl(&sPtrCtrlAdd2) ;

	return Aarry ;
}