Tricks of the Windows Gam…ming Gurus (2nd Edition)/Disc2.iso/vc98/mfc/include/afxcoll.h

C/C++ Source or Header | 1998-06-16 | 35KB | 1,497 lines

// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1998 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.

#ifndef __AFXCOLL_H__
#define __AFXCOLL_H__

#ifndef __AFX_H__
    #include <afx.h>
#endif

#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, off)
#endif
#ifndef _AFX_FULLTYPEINFO
#pragma component(mintypeinfo, on)
#endif

#ifdef _AFX_PACKING
#pragma pack(push, _AFX_PACKING)
#endif

/////////////////////////////////////////////////////////////////////////////
// Classes declared in this file

//CObject
    // Arrays
    class CByteArray;           // array of BYTE
    class CWordArray;           // array of WORD
    class CDWordArray;          // array of DWORD
    class CUIntArray;           // array of UINT
    class CPtrArray;            // array of void*
    class CObArray;             // array of CObject*

    // Lists
    class CPtrList;             // list of void*
    class CObList;              // list of CObject*

    // Maps (aka Dictionaries)
    class CMapWordToOb;         // map from WORD to CObject*
    class CMapWordToPtr;        // map from WORD to void*
    class CMapPtrToWord;        // map from void* to WORD
    class CMapPtrToPtr;         // map from void* to void*

    // Special String variants
    class CStringArray;         // array of CStrings
    class CStringList;          // list of CStrings
    class CMapStringToPtr;      // map from CString to void*
    class CMapStringToOb;       // map from CString to CObject*
    class CMapStringToString;   // map from CString to CString

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

#undef AFX_DATA
#define AFX_DATA AFX_CORE_DATA

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

class CByteArray : public CObject
{

    DECLARE_SERIAL(CByteArray)
public:

// Construction
    CByteArray();

// Attributes
    int GetSize() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);

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

    // Accessing elements
    BYTE GetAt(int nIndex) const;
    void SetAt(int nIndex, BYTE newElement);

    BYTE& ElementAt(int nIndex);

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

    // Potentially growing the array
    void SetAtGrow(int nIndex, BYTE newElement);

    int Add(BYTE newElement);

    int Append(const CByteArray& src);
    void Copy(const CByteArray& src);

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

    // Operations that move elements around
    void InsertAt(int nIndex, BYTE newElement, int nCount = 1);

    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, CByteArray* pNewArray);

// Implementation
protected:
    BYTE* m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount


public:
    ~CByteArray();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for class templates
    typedef BYTE BASE_TYPE;
    typedef BYTE BASE_ARG_TYPE;
};


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

class CWordArray : public CObject
{

    DECLARE_SERIAL(CWordArray)
public:

// Construction
    CWordArray();

// Attributes
    int GetSize() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);

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

    // Accessing elements
    WORD GetAt(int nIndex) const;
    void SetAt(int nIndex, WORD newElement);

    WORD& ElementAt(int nIndex);

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

    // Potentially growing the array
    void SetAtGrow(int nIndex, WORD newElement);

    int Add(WORD newElement);

    int Append(const CWordArray& src);
    void Copy(const CWordArray& src);

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

    // Operations that move elements around
    void InsertAt(int nIndex, WORD newElement, int nCount = 1);

    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, CWordArray* pNewArray);

// Implementation
protected:
    WORD* m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount


public:
    ~CWordArray();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for class templates
    typedef WORD BASE_TYPE;
    typedef WORD BASE_ARG_TYPE;
};


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

class CDWordArray : public CObject
{

    DECLARE_SERIAL(CDWordArray)
public:

// Construction
    CDWordArray();

// Attributes
    int GetSize() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);

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

    // Accessing elements
    DWORD GetAt(int nIndex) const;
    void SetAt(int nIndex, DWORD newElement);

    DWORD& ElementAt(int nIndex);

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

    // Potentially growing the array
    void SetAtGrow(int nIndex, DWORD newElement);

    int Add(DWORD newElement);

    int Append(const CDWordArray& src);
    void Copy(const CDWordArray& src);

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

    // Operations that move elements around
    void InsertAt(int nIndex, DWORD newElement, int nCount = 1);

    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, CDWordArray* pNewArray);

// Implementation
protected:
    DWORD* m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount


public:
    ~CDWordArray();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for class templates
    typedef DWORD BASE_TYPE;
    typedef DWORD BASE_ARG_TYPE;
};


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

class CUIntArray : public CObject
{

    DECLARE_DYNAMIC(CUIntArray)
public:

// Construction
    CUIntArray();

// Attributes
    int GetSize() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);

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

    // Accessing elements
    UINT GetAt(int nIndex) const;
    void SetAt(int nIndex, UINT newElement);

    UINT& ElementAt(int nIndex);

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

    // Potentially growing the array
    void SetAtGrow(int nIndex, UINT newElement);

    int Add(UINT newElement);

    int Append(const CUIntArray& src);
    void Copy(const CUIntArray& src);

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

    // Operations that move elements around
    void InsertAt(int nIndex, UINT newElement, int nCount = 1);

    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, CUIntArray* pNewArray);

// Implementation
protected:
    UINT* m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount


public:
    ~CUIntArray();
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for class templates
    typedef UINT BASE_TYPE;
    typedef UINT BASE_ARG_TYPE;
};


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

class CPtrArray : public CObject
{

    DECLARE_DYNAMIC(CPtrArray)
public:

// Construction
    CPtrArray();

// Attributes
    int GetSize() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);

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

    // Accessing elements
    void* GetAt(int nIndex) const;
    void SetAt(int nIndex, void* newElement);

    void*& ElementAt(int nIndex);

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

    // Potentially growing the array
    void SetAtGrow(int nIndex, void* newElement);

    int Add(void* newElement);

    int Append(const CPtrArray& src);
    void Copy(const CPtrArray& src);

    // overloaded operator helpers
    void* operator[](int nIndex) const;
    void*& operator[](int nIndex);

    // Operations that move elements around
    void InsertAt(int nIndex, void* newElement, int nCount = 1);

    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, CPtrArray* pNewArray);

// Implementation
protected:
    void** m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount


public:
    ~CPtrArray();
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for class templates
    typedef void* BASE_TYPE;
    typedef void* BASE_ARG_TYPE;
};


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

class CObArray : public CObject
{

    DECLARE_SERIAL(CObArray)
public:

// Construction
    CObArray();

// Attributes
    int GetSize() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);

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

    // Accessing elements
    CObject* GetAt(int nIndex) const;
    void SetAt(int nIndex, CObject* newElement);

    CObject*& ElementAt(int nIndex);

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

    // Potentially growing the array
    void SetAtGrow(int nIndex, CObject* newElement);

    int Add(CObject* newElement);

    int Append(const CObArray& src);
    void Copy(const CObArray& src);

    // overloaded operator helpers
    CObject* operator[](int nIndex) const;
    CObject*& operator[](int nIndex);

    // Operations that move elements around
    void InsertAt(int nIndex, CObject* newElement, int nCount = 1);

    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, CObArray* pNewArray);

// Implementation
protected:
    CObject** m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount


public:
    ~CObArray();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for class templates
    typedef CObject* BASE_TYPE;
    typedef CObject* BASE_ARG_TYPE;
};


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

class CStringArray : public CObject
{

    DECLARE_SERIAL(CStringArray)
public:

// Construction
    CStringArray();

// Attributes
    int GetSize() const;
    int GetUpperBound() const;
    void SetSize(int nNewSize, int nGrowBy = -1);

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

    // Accessing elements
    CString GetAt(int nIndex) const;
    void SetAt(int nIndex, LPCTSTR newElement);

    void SetAt(int nIndex, const CString& newElement);

    CString& ElementAt(int nIndex);

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

    // Potentially growing the array
    void SetAtGrow(int nIndex, LPCTSTR newElement);

    void SetAtGrow(int nIndex, const CString& newElement);

    int Add(LPCTSTR newElement);

    int Add(const CString& newElement);

    int Append(const CStringArray& src);
    void Copy(const CStringArray& src);

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

    // Operations that move elements around
    void InsertAt(int nIndex, LPCTSTR newElement, int nCount = 1);

    void InsertAt(int nIndex, const CString& newElement, int nCount = 1);

    void RemoveAt(int nIndex, int nCount = 1);
    void InsertAt(int nStartIndex, CStringArray* pNewArray);

// Implementation
protected:
    CString* m_pData;   // the actual array of data
    int m_nSize;     // # of elements (upperBound - 1)
    int m_nMaxSize;  // max allocated
    int m_nGrowBy;   // grow amount

    void InsertEmpty(int nIndex, int nCount);


public:
    ~CStringArray();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for class templates
    typedef CString BASE_TYPE;
    typedef LPCTSTR BASE_ARG_TYPE;
};


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

class CPtrList : public CObject
{

    DECLARE_DYNAMIC(CPtrList)

protected:
    struct CNode
    {
        CNode* pNext;
        CNode* pPrev;
        void* data;
    };
public:

// Construction
    CPtrList(int nBlockSize = 10);

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

    // peek at head or tail
    void*& GetHead();
    void* GetHead() const;
    void*& GetTail();
    void* GetTail() const;

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

    // add before head or after tail
    POSITION AddHead(void* newElement);
    POSITION AddTail(void* newElement);


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

    // remove all elements
    void RemoveAll();

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

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

    void RemoveAt(POSITION position);

    // inserting before or after a given position
    POSITION InsertBefore(POSITION position, void* newElement);
    POSITION InsertAfter(POSITION position, void* newElement);


    // helper functions (note: O(n) speed)
    POSITION Find(void* 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)

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

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

public:
    ~CPtrList();
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif
    // local typedefs for class templates
    typedef void* BASE_TYPE;
    typedef void* BASE_ARG_TYPE;
};


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

class CObList : public CObject
{

    DECLARE_SERIAL(CObList)

protected:
    struct CNode
    {
        CNode* pNext;
        CNode* pPrev;
        CObject* data;
    };
public:

// Construction
    CObList(int nBlockSize = 10);

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

    // peek at head or tail
    CObject*& GetHead();
    CObject* GetHead() const;
    CObject*& GetTail();
    CObject* GetTail() const;

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

    // add before head or after tail
    POSITION AddHead(CObject* newElement);
    POSITION AddTail(CObject* newElement);


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

    // remove all elements
    void RemoveAll();

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

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

    void RemoveAt(POSITION position);

    // inserting before or after a given position
    POSITION InsertBefore(POSITION position, CObject* newElement);
    POSITION InsertAfter(POSITION position, CObject* newElement);


    // helper functions (note: O(n) speed)
    POSITION Find(CObject* 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)

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

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

public:
    ~CObList();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif
    // local typedefs for class templates
    typedef CObject* BASE_TYPE;
    typedef CObject* BASE_ARG_TYPE;
};


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

class CStringList : public CObject
{

    DECLARE_SERIAL(CStringList)

protected:
    struct CNode
    {
        CNode* pNext;
        CNode* pPrev;
        CString data;
    };
public:

// Construction
    CStringList(int nBlockSize = 10);

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

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

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

    // add before head or after tail
    POSITION AddHead(LPCTSTR newElement);
    POSITION AddTail(LPCTSTR newElement);

    POSITION AddHead(const CString& newElement);
    POSITION AddTail(const CString& newElement);


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

    // remove all elements
    void RemoveAll();

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

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

    void SetAt(POSITION pos, const CString& newElement);

    void RemoveAt(POSITION position);

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

    POSITION InsertBefore(POSITION position, const CString& newElement);
    POSITION InsertAfter(POSITION position, const CString& newElement);


    // helper functions (note: O(n) speed)
    POSITION Find(LPCTSTR 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)

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

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

public:
    ~CStringList();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif
    // local typedefs for class templates
    typedef CString BASE_TYPE;
    typedef LPCTSTR BASE_ARG_TYPE;
};


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

class CMapWordToPtr : public CObject
{

    DECLARE_DYNAMIC(CMapWordToPtr)
protected:
    // Association
    struct CAssoc
    {
        CAssoc* pNext;

        WORD key;
        void* value;
    };

public:

// Construction
    CMapWordToPtr(int nBlockSize = 10);

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

    // Lookup
    BOOL Lookup(WORD key, void*& rValue) const;

// Operations
    // Lookup and add if not there
    void*& operator[](WORD key);

    // add a new (key, value) pair
    void SetAt(WORD key, void* newValue);

    // removing existing (key, ?) pair
    BOOL RemoveKey(WORD key);
    void RemoveAll();

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

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Overridables: special non-virtual (see map implementation for details)
    // Routine used to user-provided hash keys
    UINT HashKey(WORD 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(WORD, UINT&) const;

public:
    ~CMapWordToPtr();
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif


protected:
    // local typedefs for CTypedPtrMap class template
    typedef WORD BASE_KEY;
    typedef WORD BASE_ARG_KEY;
    typedef void* BASE_VALUE;
    typedef void* BASE_ARG_VALUE;
};


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

class CMapPtrToWord : public CObject
{

    DECLARE_DYNAMIC(CMapPtrToWord)
protected:
    // Association
    struct CAssoc
    {
        CAssoc* pNext;

        void* key;
        WORD value;
    };

public:

// Construction
    CMapPtrToWord(int nBlockSize = 10);

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

    // Lookup
    BOOL Lookup(void* key, WORD& rValue) const;

// Operations
    // Lookup and add if not there
    WORD& operator[](void* key);

    // add a new (key, value) pair
    void SetAt(void* key, WORD newValue);

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

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

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Overridables: special non-virtual (see map implementation for details)
    // Routine used to user-provided hash keys
    UINT HashKey(void* 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(void*, UINT&) const;

public:
    ~CMapPtrToWord();
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif


protected:
    // local typedefs for CTypedPtrMap class template
    typedef void* BASE_KEY;
    typedef void* BASE_ARG_KEY;
    typedef WORD BASE_VALUE;
    typedef WORD BASE_ARG_VALUE;
};


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

class CMapPtrToPtr : public CObject
{

    DECLARE_DYNAMIC(CMapPtrToPtr)
protected:
    // Association
    struct CAssoc
    {
        CAssoc* pNext;

        void* key;
        void* value;
    };

public:

// Construction
    CMapPtrToPtr(int nBlockSize = 10);

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

    // Lookup
    BOOL Lookup(void* key, void*& rValue) const;

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

    // add a new (key, value) pair
    void SetAt(void* key, void* newValue);

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

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

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Overridables: special non-virtual (see map implementation for details)
    // Routine used to user-provided hash keys
    UINT HashKey(void* 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(void*, UINT&) const;

public:
    ~CMapPtrToPtr();
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

    void* GetValueAt(void* key) const;


protected:
    // local typedefs for CTypedPtrMap class template
    typedef void* BASE_KEY;
    typedef void* BASE_ARG_KEY;
    typedef void* BASE_VALUE;
    typedef void* BASE_ARG_VALUE;
};


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

class CMapWordToOb : public CObject
{

    DECLARE_SERIAL(CMapWordToOb)
protected:
    // Association
    struct CAssoc
    {
        CAssoc* pNext;

        WORD key;
        CObject* value;
    };

public:

// Construction
    CMapWordToOb(int nBlockSize = 10);

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

    // Lookup
    BOOL Lookup(WORD key, CObject*& rValue) const;

// Operations
    // Lookup and add if not there
    CObject*& operator[](WORD key);

    // add a new (key, value) pair
    void SetAt(WORD key, CObject* newValue);

    // removing existing (key, ?) pair
    BOOL RemoveKey(WORD key);
    void RemoveAll();

    // iterating all (key, value) pairs
    POSITION GetStartPosition() const;
    void GetNextAssoc(POSITION& rNextPosition, WORD& rKey, CObject*& rValue) const;

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Overridables: special non-virtual (see map implementation for details)
    // Routine used to user-provided hash keys
    UINT HashKey(WORD 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(WORD, UINT&) const;

public:
    ~CMapWordToOb();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif


protected:
    // local typedefs for CTypedPtrMap class template
    typedef WORD BASE_KEY;
    typedef WORD BASE_ARG_KEY;
    typedef CObject* BASE_VALUE;
    typedef CObject* BASE_ARG_VALUE;
};


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

class CMapStringToPtr : public CObject
{

    DECLARE_DYNAMIC(CMapStringToPtr)
protected:
    // Association
    struct CAssoc
    {
        CAssoc* pNext;
        UINT nHashValue;  // needed for efficient iteration
        CString key;
        void* value;
    };

public:

// Construction
    CMapStringToPtr(int nBlockSize = 10);

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

    // Lookup
    BOOL Lookup(LPCTSTR key, void*& rValue) const;
    BOOL LookupKey(LPCTSTR key, LPCTSTR& rKey) const;

// Operations
    // Lookup and add if not there
    void*& operator[](LPCTSTR key);

    // add a new (key, value) pair
    void SetAt(LPCTSTR key, void* newValue);

    // removing existing (key, ?) pair
    BOOL RemoveKey(LPCTSTR key);
    void RemoveAll();

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

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Overridables: special non-virtual (see map implementation for details)
    // Routine used to user-provided hash keys
    UINT HashKey(LPCTSTR 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(LPCTSTR, UINT&) const;

public:
    ~CMapStringToPtr();
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for CTypedPtrMap class template
    typedef CString BASE_KEY;
    typedef LPCTSTR BASE_ARG_KEY;
    typedef void* BASE_VALUE;
    typedef void* BASE_ARG_VALUE;
};


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

class CMapStringToOb : public CObject
{

    DECLARE_SERIAL(CMapStringToOb)
protected:
    // Association
    struct CAssoc
    {
        CAssoc* pNext;
        UINT nHashValue;  // needed for efficient iteration
        CString key;
        CObject* value;
    };

public:

// Construction
    CMapStringToOb(int nBlockSize = 10);

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

    // Lookup
    BOOL Lookup(LPCTSTR key, CObject*& rValue) const;
    BOOL LookupKey(LPCTSTR key, LPCTSTR& rKey) const;

// Operations
    // Lookup and add if not there
    CObject*& operator[](LPCTSTR key);

    // add a new (key, value) pair
    void SetAt(LPCTSTR key, CObject* newValue);

    // removing existing (key, ?) pair
    BOOL RemoveKey(LPCTSTR key);
    void RemoveAll();

    // iterating all (key, value) pairs
    POSITION GetStartPosition() const;
    void GetNextAssoc(POSITION& rNextPosition, CString& rKey, CObject*& rValue) const;

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Overridables: special non-virtual (see map implementation for details)
    // Routine used to user-provided hash keys
    UINT HashKey(LPCTSTR 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(LPCTSTR, UINT&) const;

public:
    ~CMapStringToOb();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for CTypedPtrMap class template
    typedef CString BASE_KEY;
    typedef LPCTSTR BASE_ARG_KEY;
    typedef CObject* BASE_VALUE;
    typedef CObject* BASE_ARG_VALUE;
};


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

class CMapStringToString : public CObject
{

    DECLARE_SERIAL(CMapStringToString)
protected:
    // Association
    struct CAssoc
    {
        CAssoc* pNext;
        UINT nHashValue;  // needed for efficient iteration
        CString key;
        CString value;
    };

public:

// Construction
    CMapStringToString(int nBlockSize = 10);

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

    // Lookup
    BOOL Lookup(LPCTSTR key, CString& rValue) const;
    BOOL LookupKey(LPCTSTR key, LPCTSTR& rKey) const;

// Operations
    // Lookup and add if not there
    CString& operator[](LPCTSTR key);

    // add a new (key, value) pair
    void SetAt(LPCTSTR key, LPCTSTR newValue);

    // removing existing (key, ?) pair
    BOOL RemoveKey(LPCTSTR key);
    void RemoveAll();

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

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Overridables: special non-virtual (see map implementation for details)
    // Routine used to user-provided hash keys
    UINT HashKey(LPCTSTR 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(LPCTSTR, UINT&) const;

public:
    ~CMapStringToString();

    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

protected:
    // local typedefs for CTypedPtrMap class template
    typedef CString BASE_KEY;
    typedef LPCTSTR BASE_ARG_KEY;
    typedef CString BASE_VALUE;
    typedef LPCTSTR BASE_ARG_VALUE;
};


#ifdef _AFX_PACKING
#pragma pack(pop)
#endif

#ifndef __AFXSTATE_H__
    #include <afxstat_.h>   // for MFC private state structures
#endif

/////////////////////////////////////////////////////////////////////////////
// Inline function declarations

#ifdef _AFX_ENABLE_INLINES
#define _AFXCOLL_INLINE AFX_INLINE
#include <afxcoll.inl>
#endif

#undef AFX_DATA
#define AFX_DATA

#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, on)
#endif
#ifndef _AFX_FULLTYPEINFO
#pragma component(mintypeinfo, off)
#endif

#endif //!__AFXCOLL_H__

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