|
|
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
Abstract:
map.hxx
Author:
Benjamin Leis (benl) 11/13/95
Revision History:
--*/
#ifndef _MAP
#define _MAP
#define MAP_STACK_SIZE 40
//+---------------------------------------------------------------------------
//
// Class: CMap ()
//
// Purpose:
//
// Interface: CMap --
// ~CMap --
// Insert -- insert a key and item into map
// Replace -- replaces a key's data or inserts it if is not in
// the map already
// Remove --
// Lookup --
// DeleteAll -- removes all the entries in the map and sets it to
// empty
// Lookup --
// Enum --
// DeleteNode --
// pRoot --
//
// History: 12-05-1996 benl Created
// 12-18-1997 benl modified
//
// Notes: works by copying values not be reference - so need constructors
// / destructors
//
//----------------------------------------------------------------------------
template <class T, class S> class CMapIter;
template <class T, class S> class CMap {public: friend CMapIter<T,S>;
CMap(void); ~CMap(void);
void Insert(const T & tKey, const S & sItem); void Replace(const T & tkey, const S& sItem); BOOL Remove(const T & tKey); BOOL Lookup(const T & tKey, S & sItem) const; void DeleteAll();
// Second style of lookup
S * Lookup(const T & tKey); CMapIter<T,S> * Enum();
protected:
class CNode { public: CNode(const T & t, const S & s) { tKey = t; sData = s; pLeft = NULL; pRight = NULL; bDeleted = FALSE; }
CNode() { pLeft = NULL; pRight = NULL; bDeleted = FALSE; }
CNode * pLeft; CNode * pRight; T tKey; S sData; BOOL bDeleted; };
void DeleteNode(CNode * pNode);
CNode * pRoot;};
//+---------------------------------------------------------------------------
//
// Class: CMapIter ()
//
// Purpose:
//
// Interface: CMapIter --
// ~CMapIter --
// Next --
// _nodeStack --
// _iTop --
// _nodeDummy --
//
// History: 2-13-1997 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template <class T, class S> class CMapIter {public: CMapIter ( CMap<T,S>::CNode * pRoot); ~CMapIter();
BOOLEAN Next(T & t, S & s);
private: //data
CMap<T,S>::CNode * _nodeStack[MAP_STACK_SIZE]; INT _iTop; CMap<T,S>::CNode _nodeDummy;};
//+---------------------------------------------------------------------------
//
// Member: CMapIter::CMapiter
//
// Synopsis: Constructor
//
// Arguments: [pRoot] --
//
// Returns:
//
// History: 7-10-1997 benl Created
//
// Notes: called by CMap and given root to traverse
//
//----------------------------------------------------------------------------
template <class T, class S>CMapIter<T,S>::CMapIter(CMap<T,S>::CNode * pRoot){ _iTop = 0; _nodeStack[_iTop] = pRoot;
while (_nodeStack[_iTop]->pLeft != NULL) {// assert(_iTop < MAP_STACK_SIZE);
_nodeStack[_iTop + 1] = _nodeStack[_iTop]->pLeft; _iTop++; }
//add a dummy node at the bottom
// assert(_iTop < MAP_STACK_SIZE);
_nodeStack[_iTop + 1] = &_nodeDummy; _iTop++;} // ::CNode
//+---------------------------------------------------------------------------
//
// Member: ::~CMapIter
//
// Synopsis:
//
// Arguments: (none)
//
// Returns:
//
// History: 2-13-1997 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template <class T, class S>CMapIter<T,S>::~CMapIter(){} //::~CMapIter
//+---------------------------------------------------------------------------
//
// Member: ::Next
//
// Synopsis:
//
// Arguments: [t] --
// [s] --
//
// Returns:
//
// History: 2-13-1997 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template <class T, class S>BOOLEAN CMapIter<T,S>::Next(T & t, S & s){ CMap<T,S>::CNode * pTemp;
if (_nodeStack[_iTop]->pRight != NULL) { //go to the leftmostest item below
_nodeStack[_iTop] = _nodeStack[_iTop]->pRight; while (_nodeStack[_iTop]->pLeft != NULL) {// assert(_iTop < MAP_STACK_SIZE);
_nodeStack[_iTop + 1] = _nodeStack[_iTop]->pLeft; _iTop++; } } else if (_iTop != 0) { // o.w backtrack up one level
_iTop--; } else { //o.w we're done
return FALSE; }
//if current element is deleted recurse
if (_nodeStack[_iTop]->bDeleted) { return Next(t, s); } else { t = _nodeStack[_iTop]->tKey; s = _nodeStack[_iTop]->sData; return TRUE; }
} //::Next
//+---------------------------------------------------------------------------
//
// Member: CMap::CMap
//
// Synopsis:
//
// Arguments: (none)
//
// Returns:
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline CMap<T,S>::CMap(void){ pRoot = NULL;} //::CMap
//+---------------------------------------------------------------------------
//
// Member: ::DeleteNode
//
// Synopsis:
//
// Arguments: [pNode] --
//
// Returns:
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline void CMap<T,S>::DeleteNode(CNode * pNode){ if (pNode != NULL) { DeleteNode(pNode->pLeft); DeleteNode(pNode->pRight); delete pNode; }} //::DeleteNode
//+---------------------------------------------------------------------------
//
// Member: ::~CMap
//
// Synopsis:
//
// Arguments: (none)
//
// Returns:
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline CMap<T,S>::~CMap(void){// printf("map destruct %x\n", this);
DeleteAll();} //::~CMap
//+---------------------------------------------------------------------------
//
// Member: ::Insert
//
// Synopsis:
//
// Arguments: [tKey] --
// [sData] --
//
// Returns:
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline void CMap<T,S>::Insert(const T & tKey, const S & sData){ CNode * pnodeTemp = pRoot;
if (pRoot == NULL) pRoot = new CNode(tKey,sData); else { while (pnodeTemp != NULL) { if (pnodeTemp->tKey <= tKey) { if (pnodeTemp->pRight == NULL) { pnodeTemp->pRight = new CNode(tKey,sData); return; } else pnodeTemp = pnodeTemp->pRight; } else { if (pnodeTemp->pLeft == NULL) { pnodeTemp->pLeft = new CNode(tKey,sData); return; } else pnodeTemp = pnodeTemp->pLeft; } } //endwhile
} //endif
} //::Insert
//+---------------------------------------------------------------------------
//
// Member: ::Replace
//
// Synopsis: if the key exits replace its data with the new data
// o.w just insert it
//
// Arguments: [tKey] -- the key to search for
// [sData] -- the new data
//
// Returns: always succeeds
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline void CMap<T,S>::Replace(const T & tKey, const S & sData){ CNode * pnodeTemp = pRoot;
if (pRoot == NULL) { pRoot = new CNode(tKey,sData); } else { while (pnodeTemp != NULL) { //match - so replace its data
if (pnodeTemp->tKey == tKey && !pnodeTemp->bDeleted) { pnodeTemp->sData = sData; return; } //recurse right
else if (pnodeTemp->tKey < tKey) { if (NULL == pnodeTemp->pRight) { pnodeTemp->pRight = new CNode(tKey,sData); return; } else pnodeTemp = pnodeTemp->pRight; } //recurse left
else { if (NULL == pnodeTemp->pLeft) { pnodeTemp->pLeft = new CNode(tKey,sData); return; } else pnodeTemp = pnodeTemp->pLeft; } } //endwhile
} //endif
} //::Replace
//+---------------------------------------------------------------------------
//
// Member: ::Remove
//
// Synopsis:
//
// Arguments: [tKey] --
//
// Returns:
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline BOOL CMap<T,S>::Remove(const T & tKey){ CNode * pnodeTemp = pRoot; CNode * pnodeParent = NULL; CNode * pnodeOrphan = NULL;
if (pRoot == NULL) return FALSE; else { while (pnodeTemp != NULL) { if (pnodeTemp->tKey == tKey && (pnodeTemp->bDeleted == FALSE)) {
if (pnodeParent == NULL) {
//
// deleting the root
//
if (pnodeTemp->pLeft != NULL) { pRoot = pnodeTemp->pLeft; pnodeOrphan = pnodeTemp->pRight; } else { pRoot = pnodeTemp->pRight; pnodeOrphan = pnodeTemp->pLeft; } } else {
//
// deleting an interor node
//
if (pnodeParent->pLeft == pnodeTemp) { pnodeParent->pLeft = pnodeTemp->pRight; pnodeOrphan = pnodeTemp->pLeft; } else { pnodeParent->pRight = pnodeTemp->pLeft; pnodeOrphan = pnodeTemp->pRight; } }
delete pnodeTemp;
//
// re-insert the orphan
//
if (pnodeOrphan != NULL) {
pnodeTemp = pRoot;
while (pnodeTemp != NULL) { if (pnodeTemp->tKey <= pnodeOrphan->tKey) { if (pnodeTemp->pRight == NULL) { pnodeTemp->pRight = pnodeOrphan; break; } else pnodeTemp = pnodeTemp->pRight; } else { if (pnodeTemp->pLeft == NULL) { pnodeTemp->pLeft = pnodeOrphan; break; } else pnodeTemp = pnodeTemp->pLeft; } } //endwhile
}
return TRUE; } else if (pnodeTemp->tKey < tKey) { pnodeParent = pnodeTemp; pnodeTemp = pnodeTemp->pRight; } else { pnodeParent = pnodeTemp; pnodeTemp = pnodeTemp->pLeft; } } //endwhile
} //endif
return FALSE;} //::Remove
//+---------------------------------------------------------------------------
//
// Member: ::Lookup
//
// Synopsis:
//
// Arguments: [tKey] --
// [sItem] --
//
// Returns:
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline BOOL CMap<T,S>::Lookup(const T & tKey, S & sItem) const{ CNode * pnodeTemp = pRoot;
if (pRoot == NULL) return FALSE; else { while (pnodeTemp != NULL) { if (pnodeTemp->tKey == tKey && pnodeTemp->bDeleted == FALSE) { sItem = pnodeTemp->sData; return TRUE; } else if (pnodeTemp->tKey <= tKey) { pnodeTemp = pnodeTemp->pRight; } else { pnodeTemp = pnodeTemp->pLeft; } } //endwhile
} //endif
return FALSE;} //::Lookup
//+---------------------------------------------------------------------------
//
// Member: ::Lookup
//
// Synopsis:
//
// Arguments: [tKey] --
//
// Returns:
//
// History: 12-05-1996 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline S * CMap<T,S>::Lookup(const T & tKey){ CNode * pnodeTemp = pRoot;
if (pRoot == NULL) return NULL; else { while (pnodeTemp != NULL) { if (pnodeTemp->tKey == tKey && pnodeTemp->bDeleted == FALSE) { return &(pnodeTemp->sData); } else if (pnodeTemp->tKey < tKey) { pnodeTemp = pnodeTemp->pRight; } else { pnodeTemp = pnodeTemp->pLeft; } } //endwhile
} //endif
return NULL;} //::Lookup
//+---------------------------------------------------------------------------
//
// Member: ::Enum
//
// Synopsis: returns the iterator
//
// Arguments: (none)
//
// Returns: iterator or null if map is empty
//
// History: 2-13-1997 benl Created
//
// Notes:
//
//----------------------------------------------------------------------------
template<class T, class S>inline CMapIter<T,S> * CMap<T,S>::Enum(){ if (pRoot) { return new CMapIter<T,S>(pRoot); } else { return NULL; }
} //::Enum
//+---------------------------------------------------------------------------
//
// Member: ::DeleteAll
//
// Synopsis: NonRecursive delete
//
// Arguments: (none)
//
// Returns:
//
// History: 12-18-1997 benl Created
//
// Notes: Cleans up the entire tree and sets it to empty
// Does it nonrecursively but swiveling ptrs around
//
//----------------------------------------------------------------------------
template <class T, class S>inline void CMap<T,S>::DeleteAll(){ CNode * pParent = 0; CNode * pNext = 0; CNode * pCurrent = pRoot;
while (pCurrent) { //advance next to left and the set the left back to parent
pNext = pCurrent->pLeft; pCurrent->pLeft = pParent;
//If there is a left child move onto it
//else if there is a right child move to it
//o.w move up thru left ptr and delete current node
if (pNext) { pParent = pCurrent; pCurrent = pNext; } else if (pCurrent->pRight) { pParent = pCurrent; pCurrent = pCurrent->pRight; pParent->pRight = 0; } else { //this is really a move up back the parent is now in pLeft
pParent = pCurrent->pLeft;
delete pCurrent; pCurrent = pParent; if (pCurrent) { pParent = pCurrent->pLeft; pCurrent->pLeft = 0; } } }
pRoot = NULL;} // ::DeleteAll
#endif
|
