template.h

一个更为先进的嵌入式操作系统.采用RMS线程调度算法,具有信号量等同步对象.亦包括GUI. 通过该系统您可以极大知道Windows的内部秘密.

// TEMPLATE.cpp: implementation of the TEMPLATE class.
//
//////////////////////////////////////////////////////////////////////

#ifndef _GOS_TEMPLATE_H_
#define _GOS_TEMPLATE_H_

/////////////////////////////////////////////////////////////////////////////
// CArray<TYPE>

template<class TYPE>
class CArray
{
public:
// Construction
	CArray();
	~CArray();

// Attributes
	int GetSize() const;
	BOOL IsEmpty() const;
	void SetSize(int nNewSize);

// Operations
	// Clean up
	void RemoveAll();

	// Direct Access to the element data (may return NULL)
	TYPE* GetData();

	int Add(const TYPE& newElement);
	int Append(const CArray& src);
	void Copy(const CArray& src);

	// overloaded operator helpers
	TYPE& operator[](int nIndex);

	// Operations that move elements around
	void InsertAt(int nIndex, const TYPE& newElement, int nCount);
	void RemoveAt(int nIndex, int nCount);
	void InsertAt(int nIndex, CArray* pNewArray);
	void InsertAt(int nIndex, const TYPE& newElement);
	void RemoveAt(int nIndex);
	void Move(int nIndex,int nNewIndex);

// Implementation
protected:
	TYPE* m_pData;   // the actual array of data
};

/////////////////////////////////////////////////////////////////////////////
// CList<TYPE, TYPE>

template<class TYPE>
class CList
{
protected:
	struct CNode
	{
		CNode* pNext;
		CNode* pPrev;
		TYPE data;
	};
public:
// Construction
	/* explicit */ CList(int nBlockSize = 10);
	~CList();

// Attributes (head and tail)
	// count of elements
	int GetSize() const;
	BOOL IsEmpty() const;

	// peek at head or tail
	TYPE& GetHead();
	TYPE& GetTail();

// Operations
	// get head or tail (and remove it) - don't call on empty list !
	TYPE RemoveHead();
	TYPE RemoveTail();

	// add before head or after tail
	POSITION AddHead(const TYPE &newElement);
	POSITION AddTail(const TYPE &newElement);

	// add another list of elements before head or after tail
	void AddHead(CList* pNewList);
	void AddTail(CList* pNewList);

	// remove all elements
	void RemoveAll();

	// iteration
	POSITION GetHeadPosition() const;
	POSITION GetTailPosition() const;
	TYPE& GetNext(POSITION& rPosition); // return *Position++
	TYPE& GetPrev(POSITION& rPosition); // return *Position--

	// getting/modifying an element at a given position
	TYPE& GetAt(POSITION position);
	void SetAt(POSITION pos, const TYPE& newElement);
	void RemoveAt(POSITION position);

	// inserting before or after a given position
	POSITION InsertBefore(POSITION position, const TYPE& newElement);
	POSITION InsertAfter(POSITION position, const TYPE& newElement);

	// helper functions (note: O(n) speed)
	POSITION Find(const TYPE& searchValue, POSITION startAfter = NULL) const;
		// defaults to starting at the HEAD, return NULL if not found
	POSITION FindIndex(int nIndex) const;
		// get the 'nIndex'th element (may return NULL)
	int GetIndex(POSITION position) const;
		// get the postion of element (may return -1)

// Implementation
protected:
	CNode* m_pNodeHead;
	CNode* m_pNodeTail;
	CNode* m_pNodeFree;
	CPlex* m_pBlocks;
	int m_nCount;
	int m_nBlockSize;

	PVOID NewNode(CNode*, CNode*);
	void FreeNode(CNode*);
};

/////////////////////////////////////////////////////////////////////////////
// CMap<KEY, KEY, VALUE, VALUE>

template<class KEY, class VALUE>
class CMap
{
public:
	// Association
	class CAssoc
	{
	public:
		KEY key;
		VALUE value;
		CAssoc* pNext;
	};

public:
// Construction
	/* explicit */ CMap(int nBlockSize = 10);
	~CMap();

// Attributes
	// number of elements
	int GetSize() const;
	BOOL IsEmpty() const;

	// Lookup
	BOOL Lookup(const KEY& key, VALUE& rValue) const;

// Operations
	// Lookup and add if not there
	VALUE& operator[](const KEY& key);

	// add a new (key, value) pair
	void SetAt(const KEY& key, const VALUE& newValue);

	// removing existing (key, ?) pair
	BOOL RemoveKey(const KEY& key);
	void RemoveAll();

	// iterating all (key, value) pairs
	POSITION GetStartPosition() const;
	void GetNextAssoc(POSITION& rNextPosition, KEY& rKey, VALUE& rValue) const;

	// advanced features for derived classes
	UINT GetHashTableSize() const;
	void InitHashTable(UINT hashSize);

// Implementation
protected:
	CAssoc** m_pHashTable;
	int m_nCount;
	CAssoc* m_pFreeList;
	CPlex* m_pBlocks;
	int m_nBlockSize;

	CAssoc* NewAssoc(const KEY& key);
	void FreeAssoc(CAssoc*);
	PVOID GetAssocAt(const KEY& key, UINT& nHash)const;
};


#endif // _GOS_TEMPLATE_H_