orderarray.h

这是一个程序的一般架构方法

//-- {CycleCode: 96} file [0..4812]
//-- {AddDecl: 97} module.includes preserve=yes [0..327]
//## begin module.includes preserve=yes
#include "stdafx.h"
// Copyright (C) 1991 - 1999 Rational Software Corporation

#if defined (_MSC_VER) && (_MSC_VER >= 1000)
#pragma once
#endif
#ifndef _INC_ORDERARRAY_4316BA23001F_INCLUDED
#define _INC_ORDERARRAY_4316BA23001F_INCLUDED


//必须含有关键字：KeyValue
//##ModelId=4316BA23001F
#include <afxtempl.h>

//## end module.includes preserve=yes
//-- {AddDecl: 98} class [328..4757]
template<class KeyTYPE , class TYPE >
class OrderArray
{
//-- {AddDecl: 99} region.generated [387..411]
private:
	//元素数量
//-- {AddDecl: 100} region.inlineAnnotation [412..438]
	//##ModelId=4316D8EC0186
//-- {AddDecl: 101} region.generated [439..475]
	UINT nSize;

	//当前元素最大容量
//-- {AddDecl: 102} region.inlineAnnotation [476..502]
	//##ModelId=4316D8F80251
//-- {AddDecl: 103} region.generated [503..534]
	UINT nMaxSize;

	//数据指针
//-- {AddDecl: 104} region.inlineAnnotation [535..561]
	//##ModelId=4316D92A02FD
//-- {AddDecl: 105} region.generated [562..588]
	TYPE * pData;

public:
//-- {AddDecl: 106} region.inlineAnnotation [589..615]
	//##ModelId=4316D26C0128
//-- {AddDecl: 107} region.unprotectedFunction [616..794]
	OrderArray()
	{
//## begin OrderArray::OrderArray%55481D26FEED.body preserve=yes
		// TODO: Add your specialized code here.
		nMaxSize = 2;
		nSize = 0;
		pData = (TYPE *)new BYTE[sizeof(TYPE) * 2 ];
		ConstructElements(pData , 2);

	
//## end OrderArray::OrderArray%55481D26FEED.body
}
//-- {AddDecl: 108} region.inlineAnnotation [795..827]


	//##ModelId=4316D2760000
//-- {AddDecl: 109} region.unprotectedFunction [828..1005]
	~OrderArray()
	{
//## begin OrderArray::~OrderArray%ECBDF95BFEED.body preserve=yes
		if (pData)
		{
			DestructElements(pData , nMaxSize );
			delete[] (BYTE*)pData;
			pData = NULL;

		}
		// TODO: Add your specialized code here.
	
//## end OrderArray::~OrderArray%ECBDF95BFEED.body
}
//-- {AddDecl: 110} region.inlineAnnotation [1006..1112]


	//描述：
	//  删除所有元素
	//返回：
	//  void
	//参数：
	//  void
	//##ModelId=4316D2D403C8
//-- {AddDecl: 111} region.unprotectedFunction [1113..1195]
	void RemoveAll()
	{
//## begin OrderArray::RemoveAll%7FB1D964FEED.body preserve=yes
		nSize = 0;
		// TODO: Add your specialized code here.
	
//## end OrderArray::RemoveAll%7FB1D964FEED.body
}
//-- {AddDecl: 112} region.inlineAnnotation [1196..1315]


	//描述：
	//  通过关键字删除
	//返回：
	//  void
	//参数：
	//  KeyValue 关键字
	//##ModelId=4316D2EB03A9
//-- {AddDecl: 113} region.unprotectedFunction [1316..1571]
	void RemoveAt(KeyTYPE keyvalue)
	{
//## begin OrderArray::RemoveAt%6B35E40AFEED.body preserve=yes
		// TODO: Add your specialized code here.
		UINT uPos;
		if ( FindAt( keyvalue , NULL , &uPos ) )
		{
			memcpy ( pData + uPos , pData + uPos + 1
				, sizeof(KeyTYPE) * nSize - uPos - 1);
			nSize --;
		}
	
//## end OrderArray::RemoveAt%6B35E40AFEED.body
}
//-- {AddDecl: 114} region.inlineAnnotation [1572..1700]


	//描述：
	//  通过位置返回元素
	//返回：
	//  元素
	//参数：
	//  uElementPos 元素的位置
	//##ModelId=4316D79601A5
//-- {AddDecl: 115} region.unprotectedFunction [1701..1900]
	TYPE GetAt(UINT uElementPos)
	{
//## begin OrderArray::GetAt%FEDF08D3FEED.body preserve=yes
		ASSERT( uElementPos < nSize);
		return pData[uElementPos];
		// TODO: Add your specialized code here.
		// NOTE: Requires a correct return value to compile.
	
//## end OrderArray::GetAt%FEDF08D3FEED.body
}
//-- {AddDecl: 116} region.unprotectedFunction [1901..2108]

	TYPE * GetPtrAt(UINT uElementPos)
	{
//## begin OrderArray::GetPtrAt%435EA7AFFEED.body preserve=yes
		ASSERT( uElementPos < nSize);
		return pData+uElementPos;
		// TODO: Add your specialized code here.
		// NOTE: Requires a correct return value to compile.
	
//## end OrderArray::GetPtrAt%435EA7AFFEED.body
}
//-- {AddDecl: 117} region.inlineAnnotation [2109..2269]

	//描述：
	//  通过位置元素,修改该位置的元素
	//返回：
	//  void
	//参数：
	//  uElementPos 元素的位置
	//  Element 元素值
	//##ModelId=4316FA78005D
//-- {AddDecl: 118} region.unprotectedFunction [2270..2410]
	void SetAt(UINT uElement, TYPE Element)
	{
//## begin OrderArray::SetAt%4B0532FEFEED.body preserve=yes
		// TODO: Add your specialized code here.
		ASSERT( uElement < nSize)
		pData = Element;
	
//## end OrderArray::SetAt%4B0532FEFEED.body
}
//-- {AddDecl: 119} region.inlineAnnotation [2411..2598]

	//描述：
	//  通过关键字查找
	//返回：
	//  是否成功
	//参数：
	//  KeyValue 关键字
	//  pElement 返回找到的内容元素
	//  pElementPos返回找到的位置
	//##ModelId=4316C1CA02DE
//-- {AddDecl: 120} region.unprotectedFunction [2599..3371]
	BOOL FindAt(KeyTYPE unknowKeyValue, TYPE * * ppElement  = NULL, UINT *pElementPos = NULL)
	{
//## begin OrderArray::FindAt%5A41F582FEED.body preserve=yes
		int PosStart = 0 ;
		int PosEnd = nSize;
		int PosMid = (PosStart + PosEnd) / 2;
		while (PosEnd >= PosStart)
		{
			TYPE * pE = pData + PosMid;
			
			int ret = unknowKeyValue >pE->KeyValue ;
			if ( ret == 0)
			{
				if (ppElement)
				{
					* ppElement = pE;
				}
				if (pElementPos)
				{
					* pElementPos = PosMid;
				}
				return TRUE;
				break;
			}
			else if (ret > 0)
			{
				PosStart = PosMid + 1;
			}
			else
			{
				PosEnd = PosMid - 1;
			}
			PosMid = (PosStart + PosEnd + 1) / 2;
		}
		if (ppElement)
		{
			* ppElement = NULL;
		}
		if (pElementPos)
		{
			* pElementPos = PosMid;
		}
		return FALSE;
	
//## end OrderArray::FindAt%5A41F582FEED.body
}
//-- {AddDecl: 121} region.inlineAnnotation [3372..3549]

	//描述：
	//  关键字排序插入到数组中
	//返回：
	//  是否成功
	//参数：
	//  Element 要插入的元素
	//  isCanEquality 元素关键字是否可以相等
	//##ModelId=4316C172035B
//-- {AddDecl: 122} region.unprotectedFunction [3550..4053]
	void SetMaxSize( UINT nElemSize)
	{
//## begin OrderArray::SetMaxSize%EB4A435BFEED.body preserve=yes
		if (nElemSize <= nMaxSize )
		{
			return;
		}

		TYPE* pNewData = (TYPE*) new BYTE[nElemSize * sizeof(TYPE)];
		// copy new data from old
		memcpy(pNewData, pData, nSize * sizeof(TYPE));
		
		// construct remaining elements
		ASSERT(nElemSize > nSize);
		ConstructElements<TYPE>(&pNewData[nSize], nElemSize-nSize);
		
		// get rid of old stuff (note: no destructors called)
		delete[] (BYTE*)pData;
		pData = pNewData;
		nMaxSize = nElemSize;
	
//## end OrderArray::SetMaxSize%EB4A435BFEED.body
}
//-- {AddDecl: 123} region.unprotectedFunction [4054..4711]
	
	BOOL Insert(TYPE & Element, BOOL isCanEquality = FALSE  )
	{
//## begin OrderArray::Insert%647D0FFFFEED.body preserve=yes
		UINT uPos;
		BOOL ret = FindAt( Element.KeyValue , NULL , &uPos );
		if ( ret  && !isCanEquality)
		{
			return FALSE;
		}
		ASSERT(uPos <= nSize);
		ASSERT(uPos >= 0);
		
		if (uPos >= nMaxSize)
		{
			SetMaxSize( nMaxSize * 2);
		}
		// shift old data up to fill gap
		memmove(&pData[uPos+1], &pData[uPos],
			(nSize-uPos) * sizeof(TYPE));
		
		// re-init slots we copied from
		ConstructElements<TYPE>(&pData[uPos], 1);
		pData[uPos] = Element;
		return TRUE;
		// TODO: Add your specialized code here.
		// NOTE: Requires a correct return value to compile.
	
//## end OrderArray::Insert%647D0FFFFEED.body
}
//-- {AddDecl: 124} region.unprotectedFunction [4712..4753]
	UINT GetSize()
	{
//## begin OrderArray::GetSize%27EA4458FEED.body preserve=yes
		return nSize;
	
//## end OrderArray::GetSize%27EA4458FEED.body
}
//-- {InsertRegion: 125} module.vulnerableDeclarations [4754..4755]
};
//-- {InsertRegion: 126} module.vulnerableDeclarations [4758..4812]
//## begin module.epilog preserve=yes
#endif /* _INC_ORDERARRAY_4316BA23001F_INCLUDED */ 
//## end module.epilog