Return to map_s.ctt CVS log

Up to [WindowsNT SDKs] / mstools / mfc / samples / templdef

Microsoft Windows NT Build 297 06-28-1992

/////////////////////////////////////////////////////////////////////////////
// class CMapStringTo - a mapping from CStrings to 'VALUE's.
//
// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and Microsoft
// QuickHelp documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.
/////////////////////////////////////////////////////////////////////////////

//$DECLARE_TEMPLATE

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

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
class CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE> : public CObject
{
#if IS_SERIAL
	DECLARE_SERIAL(CMapStringTo)
#else
	DECLARE_DYNAMIC(CMapStringTo)
#endif //!IS_SERIAL
protected:
	// Association
	struct CAssoc
	{
		CAssoc* pNext;
		UINT    nHashValue; // needed for efficient iteration
		CString key;
		VALUE   value;
	};
public:

// Construction
	CMapStringTo(int nBlockSize=10);

// Attributes
	// number of elements
	int     GetCount() const
				{ return m_nCount; }
	BOOL    IsEmpty() const
				{ return m_nCount == 0; }
	// Lookup
	BOOL    Lookup(const char* key, VALUE& rValue) const;

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

	// add a new (key, value) pair
	void    SetAt(const char* key, ARG_VALUE newValue)
				{ (*this)[key] = newValue; }

	// removing existing (key, ?) pair
	BOOL    RemoveKey(const char* key);
	void    RemoveAll();

	// iterating all (key, value) pairs
	POSITION GetStartPosition() const
				{ return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
	void    GetNextAssoc(POSITION& rNextPosition, CString& rKey, VALUE& rValue) const;

	// advanced features for derived classes
	UINT    GetHashTableSize() const
				{ return m_nHashTableSize; }
	void    InitHashTable(UINT hashSize);

// Overridables: special non-virtual (see map implementation for details)
	// Routine used to user-provided hash keys
	UINT    HashKey(const char* key) const;

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

	CAssoc* NewAssoc();
	void    FreeAssoc(CAssoc*);
	CAssoc* GetAssocAt(const char*, UINT&) const;

public:
	~CMapStringTo();
#if IS_SERIAL
	void    Serialize(CArchive&);
#endif //IS_SERIAL
#ifdef _DEBUG
	void    Dump(CDumpContext&) const;
	void    AssertValid() const;
#endif
};

//$IMPLEMENT_TEMPLATE
/////////////////////////////////////////////////////////////////////////////
//
// Implementation of Map from CString to VALUE
//
/////////////////////////////////////////////////////////////////////////////

#include "afxcoll.h"
#pragma hdrstop

#include "plex.h"

#ifdef AFX_COLL_SEG
#pragma code_seg(AFX_COLL_SEG)
#endif

#if IS_SERIAL
IMPLEMENT_SERIAL(CMapStringTo, CObject, 0);
#else
IMPLEMENT_DYNAMIC(CMapStringTo, CObject);
#endif //!IS_SERIAL

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

#if HAS_CREATE
#include "elements.h"       // used for special creation
#endif

#define new DEBUG_NEW

extern const CString NEAR afxEmptyString;   // for creating empty key strings

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

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::CMapStringTo(int nBlockSize)
{
	ASSERT(nBlockSize > 0);

	m_pHashTable = NULL;
	m_nHashTableSize = 17;      // default size
	m_nCount = 0;
	m_pFreeList = NULL;
	m_pBlocks = NULL;
	m_nBlockSize = nBlockSize;
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
inline UINT CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::HashKey(const char* key) const
{
	register UINT nHash = 0;
	while (*key)
		nHash = (nHash<<5) + nHash + *key++;
	return nHash;
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
void CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::InitHashTable(UINT nHashSize)
//
// Used to force allocation of a hash table or to override the default
//   hash table size of (which is fairly small)
{
	ASSERT_VALID(this);
	ASSERT(m_nCount == 0);
	ASSERT(nHashSize > 0);

	// if had a hash table - get rid of it
	if (m_pHashTable != NULL)
		delete m_pHashTable;
	m_pHashTable = NULL;

	m_pHashTable = new CAssoc* [nHashSize];
	memset(m_pHashTable, 0, sizeof(CAssoc*) * nHashSize);
	m_nHashTableSize = nHashSize;
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
void CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::RemoveAll()
{
	ASSERT_VALID(this);

	if (m_pHashTable != NULL)
	{
		// destroy elements
		for (UINT nHash = 0; nHash < m_nHashTableSize; nHash++)
		{
			register CAssoc* pAssoc;
			for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL;
			  pAssoc = pAssoc->pNext)
			{
				pAssoc->key.Empty();        // free up string data
#if HAS_CREATE
				DestructElement(&pAssoc->value);
#endif
			}
		}

		// free hash table
		delete m_pHashTable;
		m_pHashTable = NULL;
	}

	m_nCount = 0;
	m_pFreeList = NULL;
	m_pBlocks->FreeDataChain();
	m_pBlocks = NULL;
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::~CMapStringTo()
{
	RemoveAll();
	ASSERT(m_nCount == 0);
}

/////////////////////////////////////////////////////////////////////////////
// Assoc helpers
// same as CList implementation except we store CAssoc's not CNode's
//    and CAssoc's are singly linked all the time

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::CAssoc* CMapStringTo::NewAssoc()
{
	if (m_pFreeList == NULL)
	{
		// add another block
		CPlex* newBlock = CPlex::Create(m_pBlocks, m_nBlockSize, 
							sizeof(CMapStringTo::CAssoc));
		// chain them into free list
		register CMapStringTo::CAssoc* pAssoc = 
				(CMapStringTo::CAssoc*) newBlock->data();
		// free in reverse order to make it easier to debug
		pAssoc += m_nBlockSize - 1;
		for (int i = m_nBlockSize-1; i >= 0; i--, pAssoc--)
		{
			pAssoc->pNext = m_pFreeList;
			m_pFreeList = pAssoc;
		}
	}
	ASSERT(m_pFreeList != NULL); // we must have something

	CMapStringTo::CAssoc* pAssoc = m_pFreeList;
	m_pFreeList = m_pFreeList->pNext;
	m_nCount++;
	ASSERT(m_nCount > 0);       // make sure we don't overflow
	memcpy(&pAssoc->key, &afxEmptyString, sizeof(CString));
#if HAS_CREATE
	ConstructElement(&pAssoc->value);
#else
	memset(&pAssoc->value, 0, sizeof(VALUE));
#endif
	return pAssoc;
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
void CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::FreeAssoc(CMapStringTo::CAssoc* pAssoc)
{
	pAssoc->key.Empty();        // free up string data
#if HAS_CREATE
	DestructElement(&pAssoc->value);
#endif
	pAssoc->pNext = m_pFreeList;
	m_pFreeList = pAssoc;
	m_nCount--;
	ASSERT(m_nCount >= 0);      // make sure we don't underflow
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::CAssoc*
CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::GetAssocAt(const char* key, UINT& nHash) const
// find association (or return NULL)
{
	nHash = HashKey(key) % m_nHashTableSize;

	if (m_pHashTable == NULL)
		return NULL;

	// see if it exists
	register CAssoc* pAssoc;
	for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL; pAssoc = pAssoc->pNext)
	{
		if (pAssoc->key == key)
			return pAssoc;
	}
	return NULL;
}

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

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
BOOL CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::Lookup(const char* key, VALUE& rValue) const
{
	ASSERT_VALID(this);

	UINT nHash;
	register CAssoc* pAssoc = GetAssocAt(key, nHash);
	if (pAssoc == NULL)
		return FALSE;       // not in map

	rValue = pAssoc->value;
	return TRUE;
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
VALUE& CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::operator[](const char* key)
{
	ASSERT_VALID(this);

	UINT nHash;
	register CAssoc* pAssoc;
	if ((pAssoc = GetAssocAt(key, nHash)) == NULL)
	{
		if (m_pHashTable == NULL)
			InitHashTable(m_nHashTableSize);

		// it doesn't exist, add a new Association
		pAssoc = NewAssoc();
		pAssoc->nHashValue = nHash;
		pAssoc->key = key;
		// 'pAssoc->value' is a constructed object, nothing more

		// put into hash table
		pAssoc->pNext = m_pHashTable[nHash];
		m_pHashTable[nHash] = pAssoc;
	}
	return pAssoc->value;           // return new reference
}


template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
BOOL CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::RemoveKey(const char* key)
// remove key - return TRUE if removed
{
	ASSERT_VALID(this);

	if (m_pHashTable == NULL)
		return FALSE;       // nothing in the table

	CAssoc** ppAssocPrev;
	ppAssocPrev = &m_pHashTable[HashKey(key) % m_nHashTableSize];

	CAssoc* pAssoc;
	for (pAssoc = *ppAssocPrev; pAssoc != NULL; pAssoc = pAssoc->pNext)
	{
		if (pAssoc->key == key)
		{
			// remove it
			*ppAssocPrev = pAssoc->pNext;       // remove from list
			FreeAssoc(pAssoc);
			return TRUE;
		}
		ppAssocPrev = &pAssoc->pNext;
	}
	return FALSE;   // not found
}


/////////////////////////////////////////////////////////////////////////////
// Iterating

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
void CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::GetNextAssoc(POSITION& rNextPosition,
	CString& rKey, VALUE& rValue) const
{
	ASSERT_VALID(this);
	ASSERT(m_pHashTable != NULL);       // never call on empty map

	register CAssoc* pAssocRet = (CAssoc*)rNextPosition;
	ASSERT(pAssocRet != NULL);

	if (pAssocRet == (CAssoc*) BEFORE_START_POSITION)
	{
		// find the first association
		for (UINT nBucket = 0; nBucket < m_nHashTableSize; nBucket++)
			if ((pAssocRet = m_pHashTable[nBucket]) != NULL)
				break;
		ASSERT(pAssocRet != NULL);  // must find something
	}

	// find next association
	register CAssoc* pAssocNext;
	if ((pAssocNext = pAssocRet->pNext) == NULL)
	{
		// go to next bucket
		for (UINT nBucket = pAssocRet->nHashValue + 1;
		  nBucket < m_nHashTableSize; nBucket++)
			if ((pAssocNext = m_pHashTable[nBucket]) != NULL)
				break;
	}

	rNextPosition = (POSITION) pAssocNext;

	// fill in return data
	rKey = pAssocRet->key;
	rValue = pAssocRet->value;
}

/////////////////////////////////////////////////////////////////////////////
// Serialization

#if IS_SERIAL
template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
void CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::Serialize(CArchive& ar)
{
	ASSERT_VALID(this);

	CObject::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << (WORD) m_nCount;
		if (m_nCount == 0)
			return; // nothing more to do

		ASSERT(m_pHashTable != NULL);
		for (UINT nHash = 0; nHash < m_nHashTableSize; nHash++)
		{
			register CAssoc* pAssoc;
			for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL;
			  pAssoc = pAssoc->pNext)
			{
				ar << pAssoc->key;
				ar << pAssoc->value;
			}
		}
	}
	else
	{
		WORD wNewCount;
		ar >> wNewCount;
		while (wNewCount--)
		{
			CString newKey;
			VALUE newValue;
			ar >> newKey;
			ar >> newValue;
			SetAt(newKey, newValue);
		}
	}
}
#endif //IS_SERIAL

/////////////////////////////////////////////////////////////////////////////
// Diagnostics

#ifdef _DEBUG

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
void CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::Dump(CDumpContext& dc) const
{
	ASSERT_VALID(this);

#define MAKESTRING(x) #x
	dc << "A " MAKESTRING(CMapStringTo) " with " << m_nCount << " elements\n";
#undef MAKESTRING
	if (dc.GetDepth() > 0)
	{
		// Dump in format "[key] -> value"
		dc << "\n";
		POSITION pos = GetStartPosition();
		CString key;
		VALUE val;
		while (pos != NULL)
		{
			GetNextAssoc(pos, key, val);
			dc << "\n\t[" << key << "] = " << val;
		}
	}
}

template<class VALUE, class ARG_VALUE, int IS_SERIAL, int HAS_CREATE>
void CMapStringTo<VALUE, ARG_VALUE, IS_SERIAL, HAS_CREATE>::AssertValid() const
{
	CObject::AssertValid();

	ASSERT(m_nHashTableSize > 0);
	ASSERT(m_nCount == 0 || m_pHashTable != NULL);
			 // non-empty map should have hash table
}
#endif //_DEBUG

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.