![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to afxcoll.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / mfc / include|
Return to afxcoll.h CVS log | Up to [WindowsNT SDKs] / mstools / mfc / include |
1.1 root 1: // Microsoft Foundation Classes C++ library.
2: // Copyright (C) 1992 Microsoft Corporation,
3: // All rights reserved.
4:
5: // This source code is only intended as a supplement to the
6: // Microsoft Foundation Classes Reference and Microsoft
7: // QuickHelp documentation provided with the library.
8: // See these sources for detailed information regarding the
9: // Microsoft Foundation Classes product.
10:
11:
12: #ifndef __AFXCOLL_H__
13: #define __AFXCOLL_H__
14:
15: #ifndef __AFX_H__
16: #include "afx.h"
17: #endif
18:
19: /////////////////////////////////////////////////////////////////////////////
20: // Classes declared in this file
21:
22: //CObject
23: // Arrays
24: class CByteArray; // array of BYTE
25: class CWordArray; // array of WORD
26: class CDWordArray; // array of DWORD
27: class CPtrArray; // array of void*
28: class CObArray; // array of CObject*
29:
30: // Lists
31: class CPtrList; // list of void*
32: class CObList; // list of CObject*
33:
34: // Maps (aka Dictionaries)
35: class CMapWordToOb; // map from WORD to CObject*
36: class CMapWordToPtr; // map from WORD to void*
37: class CMapPtrToWord; // map from void* to WORD
38: class CMapPtrToPtr; // map from void* to void*
39:
40: // Special String variants
41: class CStringArray; // array of CStrings
42: class CStringList; // list of CStrings
43: class CMapStringToPtr; // map from CString to void*
44: class CMapStringToOb; // map from CString to CObject*
45: class CMapStringToString; // map from CString to CString
46:
47: /////////////////////////////////////////////////////////////////////////////
48:
49: #ifdef _DEBUG
50: extern char BASED_CODE _afxSzAfxColl[]; // defined in dumpcont.cpp
51: #undef THIS_FILE
52: #define THIS_FILE _afxSzAfxColl
53: #endif
54:
55:
56: ////////////////////////////////////////////////////////////////////////////
57:
58:
59: class CByteArray : public CObject
60: {
61:
62: DECLARE_SERIAL(CByteArray)
63: public:
64:
65: // Construction
66: CByteArray();
67:
68: // Attributes
69: int GetSize() const
70: { return m_nSize; }
71: int GetUpperBound() const
72: { return m_nSize-1; }
73: void SetSize(int nNewSize, int nGrowBy = -1);
74:
75: // Operations
76: // Clean up
77: void FreeExtra();
78: void RemoveAll()
79: { SetSize(0); }
80:
81: // Accessing elements
82: BYTE GetAt(int nIndex) const
83: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
84: return m_pData[nIndex]; }
85: void SetAt(int nIndex, BYTE newElement)
86: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
87: m_pData[nIndex] = newElement; }
88: BYTE& ElementAt(int nIndex)
89: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
90: return m_pData[nIndex]; }
91:
92: // Potentially growing the array
93: void SetAtGrow(int nIndex, BYTE newElement);
94: int Add(BYTE newElement)
95: { int nIndex = m_nSize;
96: SetAtGrow(nIndex, newElement);
97: return nIndex; }
98:
99: // overloaded operator helpers
100: BYTE operator[](int nIndex) const
101: { return GetAt(nIndex); }
102: BYTE& operator[](int nIndex)
103: { return ElementAt(nIndex); }
104:
105: // Operations that move elements around
106: void InsertAt(int nIndex, BYTE newElement, int nCount = 1);
107: void RemoveAt(int nIndex, int nCount = 1);
108: void InsertAt(int nStartIndex, CByteArray* pNewArray);
109:
110: // Implementation
111: protected:
112: BYTE* m_pData; // the actual array of data
113: int m_nSize; // # of elements (upperBound - 1)
114: int m_nMaxSize; // max allocated
115: int m_nGrowBy; // grow amount
116:
117: public:
118: ~CByteArray();
119:
120: void Serialize(CArchive&);
121: #ifdef _DEBUG
122: void Dump(CDumpContext&) const;
123: void AssertValid() const;
124: #endif
125: };
126:
127:
128:
129: ////////////////////////////////////////////////////////////////////////////
130:
131:
132: class CWordArray : public CObject
133: {
134:
135: DECLARE_SERIAL(CWordArray)
136: public:
137:
138: // Construction
139: CWordArray();
140:
141: // Attributes
142: int GetSize() const
143: { return m_nSize; }
144: int GetUpperBound() const
145: { return m_nSize-1; }
146: void SetSize(int nNewSize, int nGrowBy = -1);
147:
148: // Operations
149: // Clean up
150: void FreeExtra();
151: void RemoveAll()
152: { SetSize(0); }
153:
154: // Accessing elements
155: WORD GetAt(int nIndex) const
156: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
157: return m_pData[nIndex]; }
158: void SetAt(int nIndex, WORD newElement)
159: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
160: m_pData[nIndex] = newElement; }
161: WORD& ElementAt(int nIndex)
162: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
163: return m_pData[nIndex]; }
164:
165: // Potentially growing the array
166: void SetAtGrow(int nIndex, WORD newElement);
167: int Add(WORD newElement)
168: { int nIndex = m_nSize;
169: SetAtGrow(nIndex, newElement);
170: return nIndex; }
171:
172: // overloaded operator helpers
173: WORD operator[](int nIndex) const
174: { return GetAt(nIndex); }
175: WORD& operator[](int nIndex)
176: { return ElementAt(nIndex); }
177:
178: // Operations that move elements around
179: void InsertAt(int nIndex, WORD newElement, int nCount = 1);
180: void RemoveAt(int nIndex, int nCount = 1);
181: void InsertAt(int nStartIndex, CWordArray* pNewArray);
182:
183: // Implementation
184: protected:
185: WORD* m_pData; // the actual array of data
186: int m_nSize; // # of elements (upperBound - 1)
187: int m_nMaxSize; // max allocated
188: int m_nGrowBy; // grow amount
189:
190: public:
191: ~CWordArray();
192:
193: void Serialize(CArchive&);
194: #ifdef _DEBUG
195: void Dump(CDumpContext&) const;
196: void AssertValid() const;
197: #endif
198: };
199:
200:
201:
202: ////////////////////////////////////////////////////////////////////////////
203:
204:
205: class CDWordArray : public CObject
206: {
207:
208: DECLARE_SERIAL(CDWordArray)
209: public:
210:
211: // Construction
212: CDWordArray();
213:
214: // Attributes
215: int GetSize() const
216: { return m_nSize; }
217: int GetUpperBound() const
218: { return m_nSize-1; }
219: void SetSize(int nNewSize, int nGrowBy = -1);
220:
221: // Operations
222: // Clean up
223: void FreeExtra();
224: void RemoveAll()
225: { SetSize(0); }
226:
227: // Accessing elements
228: DWORD GetAt(int nIndex) const
229: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
230: return m_pData[nIndex]; }
231: void SetAt(int nIndex, DWORD newElement)
232: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
233: m_pData[nIndex] = newElement; }
234: DWORD& ElementAt(int nIndex)
235: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
236: return m_pData[nIndex]; }
237:
238: // Potentially growing the array
239: void SetAtGrow(int nIndex, DWORD newElement);
240: int Add(DWORD newElement)
241: { int nIndex = m_nSize;
242: SetAtGrow(nIndex, newElement);
243: return nIndex; }
244:
245: // overloaded operator helpers
246: DWORD operator[](int nIndex) const
247: { return GetAt(nIndex); }
248: DWORD& operator[](int nIndex)
249: { return ElementAt(nIndex); }
250:
251: // Operations that move elements around
252: void InsertAt(int nIndex, DWORD newElement, int nCount = 1);
253: void RemoveAt(int nIndex, int nCount = 1);
254: void InsertAt(int nStartIndex, CDWordArray* pNewArray);
255:
256: // Implementation
257: protected:
258: DWORD* m_pData; // the actual array of data
259: int m_nSize; // # of elements (upperBound - 1)
260: int m_nMaxSize; // max allocated
261: int m_nGrowBy; // grow amount
262:
263: public:
264: ~CDWordArray();
265:
266: void Serialize(CArchive&);
267: #ifdef _DEBUG
268: void Dump(CDumpContext&) const;
269: void AssertValid() const;
270: #endif
271: };
272:
273:
274:
275: ////////////////////////////////////////////////////////////////////////////
276:
277:
278: class CPtrArray : public CObject
279: {
280:
281: DECLARE_DYNAMIC(CPtrArray)
282: public:
283:
284: // Construction
285: CPtrArray();
286:
287: // Attributes
288: int GetSize() const
289: { return m_nSize; }
290: int GetUpperBound() const
291: { return m_nSize-1; }
292: void SetSize(int nNewSize, int nGrowBy = -1);
293:
294: // Operations
295: // Clean up
296: void FreeExtra();
297: void RemoveAll()
298: { SetSize(0); }
299:
300: // Accessing elements
301: void* GetAt(int nIndex) const
302: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
303: return m_pData[nIndex]; }
304: void SetAt(int nIndex, void* newElement)
305: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
306: m_pData[nIndex] = newElement; }
307: void*& ElementAt(int nIndex)
308: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
309: return m_pData[nIndex]; }
310:
311: // Potentially growing the array
312: void SetAtGrow(int nIndex, void* newElement);
313: int Add(void* newElement)
314: { int nIndex = m_nSize;
315: SetAtGrow(nIndex, newElement);
316: return nIndex; }
317:
318: // overloaded operator helpers
319: void* operator[](int nIndex) const
320: { return GetAt(nIndex); }
321: void*& operator[](int nIndex)
322: { return ElementAt(nIndex); }
323:
324: // Operations that move elements around
325: void InsertAt(int nIndex, void* newElement, int nCount = 1);
326: void RemoveAt(int nIndex, int nCount = 1);
327: void InsertAt(int nStartIndex, CPtrArray* pNewArray);
328:
329: // Implementation
330: protected:
331: void** m_pData; // the actual array of data
332: int m_nSize; // # of elements (upperBound - 1)
333: int m_nMaxSize; // max allocated
334: int m_nGrowBy; // grow amount
335:
336: public:
337: ~CPtrArray();
338: #ifdef _DEBUG
339: void Dump(CDumpContext&) const;
340: void AssertValid() const;
341: #endif
342: };
343:
344:
345:
346: ////////////////////////////////////////////////////////////////////////////
347:
348:
349: class CObArray : public CObject
350: {
351:
352: DECLARE_SERIAL(CObArray)
353: public:
354:
355: // Construction
356: CObArray();
357:
358: // Attributes
359: int GetSize() const
360: { return m_nSize; }
361: int GetUpperBound() const
362: { return m_nSize-1; }
363: void SetSize(int nNewSize, int nGrowBy = -1);
364:
365: // Operations
366: // Clean up
367: void FreeExtra();
368: void RemoveAll()
369: { SetSize(0); }
370:
371: // Accessing elements
372: CObject* GetAt(int nIndex) const
373: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
374: return m_pData[nIndex]; }
375: void SetAt(int nIndex, CObject* newElement)
376: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
377: m_pData[nIndex] = newElement; }
378: CObject*& ElementAt(int nIndex)
379: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
380: return m_pData[nIndex]; }
381:
382: // Potentially growing the array
383: void SetAtGrow(int nIndex, CObject* newElement);
384: int Add(CObject* newElement)
385: { int nIndex = m_nSize;
386: SetAtGrow(nIndex, newElement);
387: return nIndex; }
388:
389: // overloaded operator helpers
390: CObject* operator[](int nIndex) const
391: { return GetAt(nIndex); }
392: CObject*& operator[](int nIndex)
393: { return ElementAt(nIndex); }
394:
395: // Operations that move elements around
396: void InsertAt(int nIndex, CObject* newElement, int nCount = 1);
397: void RemoveAt(int nIndex, int nCount = 1);
398: void InsertAt(int nStartIndex, CObArray* pNewArray);
399:
400: // Implementation
401: protected:
402: CObject** m_pData; // the actual array of data
403: int m_nSize; // # of elements (upperBound - 1)
404: int m_nMaxSize; // max allocated
405: int m_nGrowBy; // grow amount
406:
407: public:
408: ~CObArray();
409:
410: void Serialize(CArchive&);
411: #ifdef _DEBUG
412: void Dump(CDumpContext&) const;
413: void AssertValid() const;
414: #endif
415: };
416:
417:
418:
419: ////////////////////////////////////////////////////////////////////////////
420:
421:
422: class CStringArray : public CObject
423: {
424:
425: DECLARE_SERIAL(CStringArray)
426: public:
427:
428: // Construction
429: CStringArray();
430:
431: // Attributes
432: int GetSize() const
433: { return m_nSize; }
434: int GetUpperBound() const
435: { return m_nSize-1; }
436: void SetSize(int nNewSize, int nGrowBy = -1);
437:
438: // Operations
439: // Clean up
440: void FreeExtra();
441: void RemoveAll()
442: { SetSize(0); }
443:
444: // Accessing elements
445: CString GetAt(int nIndex) const
446: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
447: return m_pData[nIndex]; }
448: void SetAt(int nIndex, const char* newElement)
449: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
450: m_pData[nIndex] = newElement; }
451: CString& ElementAt(int nIndex)
452: { ASSERT(nIndex >= 0 && nIndex < m_nSize);
453: return m_pData[nIndex]; }
454:
455: // Potentially growing the array
456: void SetAtGrow(int nIndex, const char* newElement);
457: int Add(const char* newElement)
458: { int nIndex = m_nSize;
459: SetAtGrow(nIndex, newElement);
460: return nIndex; }
461:
462: // overloaded operator helpers
463: CString operator[](int nIndex) const
464: { return GetAt(nIndex); }
465: CString& operator[](int nIndex)
466: { return ElementAt(nIndex); }
467:
468: // Operations that move elements around
469: void InsertAt(int nIndex, const char* newElement, int nCount = 1);
470: void RemoveAt(int nIndex, int nCount = 1);
471: void InsertAt(int nStartIndex, CStringArray* pNewArray);
472:
473: // Implementation
474: protected:
475: CString* m_pData; // the actual array of data
476: int m_nSize; // # of elements (upperBound - 1)
477: int m_nMaxSize; // max allocated
478: int m_nGrowBy; // grow amount
479:
480: public:
481: ~CStringArray();
482:
483: void Serialize(CArchive&);
484: #ifdef _DEBUG
485: void Dump(CDumpContext&) const;
486: void AssertValid() const;
487: #endif
488: };
489:
490:
491:
492: /////////////////////////////////////////////////////////////////////////////
493:
494:
495: class CPtrList : public CObject
496: {
497:
498: DECLARE_DYNAMIC(CPtrList)
499:
500: protected:
501: struct CNode
502: {
503: CNode* pNext;
504: CNode* pPrev;
505: void* data;
506: };
507: public:
508:
509: // Construction
510: CPtrList(int nBlockSize=10);
511:
512: // Attributes (head and tail)
513: // count of elements
514: int GetCount() const
515: { return m_nCount; }
516: BOOL IsEmpty() const
517: { return m_nCount == 0; }
518:
519: // peek at head or tail
520: void*& GetHead()
521: { ASSERT(m_pNodeHead != NULL);
522: return m_pNodeHead->data; }
523: void* GetHead() const
524: { ASSERT(m_pNodeHead != NULL);
525: return m_pNodeHead->data; }
526: void*& GetTail()
527: { ASSERT(m_pNodeTail != NULL);
528: return m_pNodeTail->data; }
529: void* GetTail() const
530: { ASSERT(m_pNodeTail != NULL);
531: return m_pNodeTail->data; }
532:
533: // Operations
534: // get head or tail (and remove it) - don't call on empty list !
535: void* RemoveHead();
536: void* RemoveTail();
537:
538: // add before head or after tail
539: POSITION AddHead(void* newElement);
540: POSITION AddTail(void* newElement);
541:
542: // add another list of elements before head or after tail
543: void AddHead(CPtrList* pNewList);
544: void AddTail(CPtrList* pNewList);
545:
546: // remove all elements
547: void RemoveAll();
548:
549: // iteration
550: POSITION GetHeadPosition() const
551: { return (POSITION) m_pNodeHead; }
552: POSITION GetTailPosition() const
553: { return (POSITION) m_pNodeTail; }
554: void*& GetNext(POSITION& rPosition) // return *Position++
555: { CNode* pNode = (CNode*) rPosition;
556: ASSERT(pNode != NULL);
557: rPosition = (POSITION) pNode->pNext;
558: return pNode->data; }
559: void* GetNext(POSITION& rPosition) const // return *Position++
560: { CNode* pNode = (CNode*) rPosition;
561: ASSERT(pNode != NULL);
562: rPosition = (POSITION) pNode->pNext;
563: return pNode->data; }
564: void*& GetPrev(POSITION& rPosition) // return *Position--
565: { CNode* pNode = (CNode*) rPosition;
566: ASSERT(pNode != NULL);
567: rPosition = (POSITION) pNode->pPrev;
568: return pNode->data; }
569: void* GetPrev(POSITION& rPosition) const // return *Position--
570: { CNode* pNode = (CNode*) rPosition;
571: ASSERT(pNode != NULL);
572: rPosition = (POSITION) pNode->pPrev;
573: return pNode->data; }
574:
575: // getting/modifying an element at a given position
576: void*& GetAt(POSITION position)
577: { CNode* pNode = (CNode*) position;
578: ASSERT(pNode != NULL);
579: return pNode->data; }
580: void* GetAt(POSITION position) const
581: { CNode* pNode = (CNode*) position;
582: ASSERT(pNode != NULL);
583: return pNode->data; }
584: void SetAt(POSITION pos, void* newElement)
585: { CNode* pNode = (CNode*) pos;
586: ASSERT(pNode != NULL);
587: pNode->data = newElement; }
588: void RemoveAt(POSITION position);
589:
590: // inserting before or after a given position
591: POSITION InsertBefore(POSITION position, void* newElement);
592: POSITION InsertAfter(POSITION position, void* newElement);
593:
594: // helper functions (note: O(n) speed)
595: POSITION Find(void* searchValue, POSITION startAfter = NULL) const;
596: // defaults to starting at the HEAD
597: // return NULL if not found
598: POSITION FindIndex(int nIndex) const;
599: // get the 'nIndex'th element (may return NULL)
600:
601: // Implementation
602: protected:
603: CNode* m_pNodeHead;
604: CNode* m_pNodeTail;
605: int m_nCount;
606: CNode* m_pNodeFree;
607: struct CPlex* m_pBlocks;
608: int m_nBlockSize;
609:
610: CNode* NewNode(CNode*, CNode*);
611: void FreeNode(CNode*);
612:
613: public:
614: ~CPtrList();
615: #ifdef _DEBUG
616: void Dump(CDumpContext&) const;
617: void AssertValid() const;
618: #endif
619: };
620:
621:
622:
623: /////////////////////////////////////////////////////////////////////////////
624:
625:
626: class CObList : public CObject
627: {
628:
629: DECLARE_SERIAL(CObList)
630:
631: protected:
632: struct CNode
633: {
634: CNode* pNext;
635: CNode* pPrev;
636: CObject* data;
637: };
638: public:
639:
640: // Construction
641: CObList(int nBlockSize=10);
642:
643: // Attributes (head and tail)
644: // count of elements
645: int GetCount() const
646: { return m_nCount; }
647: BOOL IsEmpty() const
648: { return m_nCount == 0; }
649:
650: // peek at head or tail
651: CObject*& GetHead()
652: { ASSERT(m_pNodeHead != NULL);
653: return m_pNodeHead->data; }
654: CObject* GetHead() const
655: { ASSERT(m_pNodeHead != NULL);
656: return m_pNodeHead->data; }
657: CObject*& GetTail()
658: { ASSERT(m_pNodeTail != NULL);
659: return m_pNodeTail->data; }
660: CObject* GetTail() const
661: { ASSERT(m_pNodeTail != NULL);
662: return m_pNodeTail->data; }
663:
664: // Operations
665: // get head or tail (and remove it) - don't call on empty list !
666: CObject* RemoveHead();
667: CObject* RemoveTail();
668:
669: // add before head or after tail
670: POSITION AddHead(CObject* newElement);
671: POSITION AddTail(CObject* newElement);
672:
673: // add another list of elements before head or after tail
674: void AddHead(CObList* pNewList);
675: void AddTail(CObList* pNewList);
676:
677: // remove all elements
678: void RemoveAll();
679:
680: // iteration
681: POSITION GetHeadPosition() const
682: { return (POSITION) m_pNodeHead; }
683: POSITION GetTailPosition() const
684: { return (POSITION) m_pNodeTail; }
685: CObject*& GetNext(POSITION& rPosition) // return *Position++
686: { CNode* pNode = (CNode*) rPosition;
687: ASSERT(pNode != NULL);
688: rPosition = (POSITION) pNode->pNext;
689: return pNode->data; }
690: CObject* GetNext(POSITION& rPosition) const // return *Position++
691: { CNode* pNode = (CNode*) rPosition;
692: ASSERT(pNode != NULL);
693: rPosition = (POSITION) pNode->pNext;
694: return pNode->data; }
695: CObject*& GetPrev(POSITION& rPosition) // return *Position--
696: { CNode* pNode = (CNode*) rPosition;
697: ASSERT(pNode != NULL);
698: rPosition = (POSITION) pNode->pPrev;
699: return pNode->data; }
700: CObject* GetPrev(POSITION& rPosition) const // return *Position--
701: { CNode* pNode = (CNode*) rPosition;
702: ASSERT(pNode != NULL);
703: rPosition = (POSITION) pNode->pPrev;
704: return pNode->data; }
705:
706: // getting/modifying an element at a given position
707: CObject*& GetAt(POSITION position)
708: { CNode* pNode = (CNode*) position;
709: ASSERT(pNode != NULL);
710: return pNode->data; }
711: CObject* GetAt(POSITION position) const
712: { CNode* pNode = (CNode*) position;
713: ASSERT(pNode != NULL);
714: return pNode->data; }
715: void SetAt(POSITION pos, CObject* newElement)
716: { CNode* pNode = (CNode*) pos;
717: ASSERT(pNode != NULL);
718: pNode->data = newElement; }
719: void RemoveAt(POSITION position);
720:
721: // inserting before or after a given position
722: POSITION InsertBefore(POSITION position, CObject* newElement);
723: POSITION InsertAfter(POSITION position, CObject* newElement);
724:
725: // helper functions (note: O(n) speed)
726: POSITION Find(CObject* searchValue, POSITION startAfter = NULL) const;
727: // defaults to starting at the HEAD
728: // return NULL if not found
729: POSITION FindIndex(int nIndex) const;
730: // get the 'nIndex'th element (may return NULL)
731:
732: // Implementation
733: protected:
734: CNode* m_pNodeHead;
735: CNode* m_pNodeTail;
736: int m_nCount;
737: CNode* m_pNodeFree;
738: struct CPlex* m_pBlocks;
739: int m_nBlockSize;
740:
741: CNode* NewNode(CNode*, CNode*);
742: void FreeNode(CNode*);
743:
744: public:
745: ~CObList();
746:
747: void Serialize(CArchive&);
748: #ifdef _DEBUG
749: void Dump(CDumpContext&) const;
750: void AssertValid() const;
751: #endif
752: };
753:
754:
755:
756: /////////////////////////////////////////////////////////////////////////////
757:
758:
759: class CStringList : public CObject
760: {
761:
762: DECLARE_SERIAL(CStringList)
763:
764: protected:
765: struct CNode
766: {
767: CNode* pNext;
768: CNode* pPrev;
769: CString data;
770: };
771: public:
772:
773: // Construction
774: CStringList(int nBlockSize=10);
775:
776: // Attributes (head and tail)
777: // count of elements
778: int GetCount() const
779: { return m_nCount; }
780: BOOL IsEmpty() const
781: { return m_nCount == 0; }
782:
783: // peek at head or tail
784: CString& GetHead()
785: { ASSERT(m_pNodeHead != NULL);
786: return m_pNodeHead->data; }
787: CString GetHead() const
788: { ASSERT(m_pNodeHead != NULL);
789: return m_pNodeHead->data; }
790: CString& GetTail()
791: { ASSERT(m_pNodeTail != NULL);
792: return m_pNodeTail->data; }
793: CString GetTail() const
794: { ASSERT(m_pNodeTail != NULL);
795: return m_pNodeTail->data; }
796:
797: // Operations
798: // get head or tail (and remove it) - don't call on empty list !
799: CString RemoveHead();
800: CString RemoveTail();
801:
802: // add before head or after tail
803: POSITION AddHead(const char* newElement);
804: POSITION AddTail(const char* newElement);
805:
806: // add another list of elements before head or after tail
807: void AddHead(CStringList* pNewList);
808: void AddTail(CStringList* pNewList);
809:
810: // remove all elements
811: void RemoveAll();
812:
813: // iteration
814: POSITION GetHeadPosition() const
815: { return (POSITION) m_pNodeHead; }
816: POSITION GetTailPosition() const
817: { return (POSITION) m_pNodeTail; }
818: CString& GetNext(POSITION& rPosition) // return *Position++
819: { CNode* pNode = (CNode*) rPosition;
820: ASSERT(pNode != NULL);
821: rPosition = (POSITION) pNode->pNext;
822: return pNode->data; }
823: CString GetNext(POSITION& rPosition) const // return *Position++
824: { CNode* pNode = (CNode*) rPosition;
825: ASSERT(pNode != NULL);
826: rPosition = (POSITION) pNode->pNext;
827: return pNode->data; }
828: CString& GetPrev(POSITION& rPosition) // return *Position--
829: { CNode* pNode = (CNode*) rPosition;
830: ASSERT(pNode != NULL);
831: rPosition = (POSITION) pNode->pPrev;
832: return pNode->data; }
833: CString GetPrev(POSITION& rPosition) const // return *Position--
834: { CNode* pNode = (CNode*) rPosition;
835: ASSERT(pNode != NULL);
836: rPosition = (POSITION) pNode->pPrev;
837: return pNode->data; }
838:
839: // getting/modifying an element at a given position
840: CString& GetAt(POSITION position)
841: { CNode* pNode = (CNode*) position;
842: ASSERT(pNode != NULL);
843: return pNode->data; }
844: CString GetAt(POSITION position) const
845: { CNode* pNode = (CNode*) position;
846: ASSERT(pNode != NULL);
847: return pNode->data; }
848: void SetAt(POSITION pos, const char* newElement)
849: { CNode* pNode = (CNode*) pos;
850: ASSERT(pNode != NULL);
851: pNode->data = newElement; }
852: void RemoveAt(POSITION position);
853:
854: // inserting before or after a given position
855: POSITION InsertBefore(POSITION position, const char* newElement);
856: POSITION InsertAfter(POSITION position, const char* newElement);
857:
858: // helper functions (note: O(n) speed)
859: POSITION Find(const char* searchValue, POSITION startAfter = NULL) const;
860: // defaults to starting at the HEAD
861: // return NULL if not found
862: POSITION FindIndex(int nIndex) const;
863: // get the 'nIndex'th element (may return NULL)
864:
865: // Implementation
866: protected:
867: CNode* m_pNodeHead;
868: CNode* m_pNodeTail;
869: int m_nCount;
870: CNode* m_pNodeFree;
871: struct CPlex* m_pBlocks;
872: int m_nBlockSize;
873:
874: CNode* NewNode(CNode*, CNode*);
875: void FreeNode(CNode*);
876:
877: public:
878: ~CStringList();
879:
880: void Serialize(CArchive&);
881: #ifdef _DEBUG
882: void Dump(CDumpContext&) const;
883: void AssertValid() const;
884: #endif
885: };
886:
887:
888:
889: /////////////////////////////////////////////////////////////////////////////
890:
891:
892: class CMapWordToPtr : public CObject
893: {
894:
895: DECLARE_DYNAMIC(CMapWordToPtr)
896: protected:
897: // Association
898: struct CAssoc
899: {
900: CAssoc* pNext;
901: UINT nHashValue; // needed for efficient iteration
902: WORD key;
903: void* value;
904: };
905: public:
906:
907: // Construction
908: CMapWordToPtr(int nBlockSize=10);
909:
910: // Attributes
911: // number of elements
912: int GetCount() const
913: { return m_nCount; }
914: BOOL IsEmpty() const
915: { return m_nCount == 0; }
916: // Lookup
917: BOOL Lookup(WORD key, void*& rValue) const;
918:
919: // Operations
920: // Lookup and add if not there
921: void*& operator[](WORD key);
922:
923: // add a new (key, value) pair
924: void SetAt(WORD key, void* newValue)
925: { (*this)[key] = newValue; }
926:
927: // removing existing (key, ?) pair
928: BOOL RemoveKey(WORD key);
929: void RemoveAll();
930:
931: // iterating all (key, value) pairs
932: POSITION GetStartPosition() const
933: { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
934: void GetNextAssoc(POSITION& rNextPosition, WORD& rKey, void*& rValue) const;
935:
936: // advanced features for derived classes
937: UINT GetHashTableSize() const
938: { return m_nHashTableSize; }
939: void InitHashTable(UINT hashSize);
940:
941: // Overridables: special non-virtual (see map implementation for details)
942: // Routine used to user-provided hash keys
943: UINT HashKey(WORD key) const;
944:
945: // Implementation
946: protected:
947: CAssoc** m_pHashTable;
948: UINT m_nHashTableSize;
949: int m_nCount;
950: CAssoc* m_pFreeList;
951: struct CPlex* m_pBlocks;
952: int m_nBlockSize;
953:
954: CAssoc* NewAssoc();
955: void FreeAssoc(CAssoc*);
956: CAssoc* GetAssocAt(WORD, UINT&) const;
957:
958: public:
959: ~CMapWordToPtr();
960: #ifdef _DEBUG
961: void Dump(CDumpContext&) const;
962: void AssertValid() const;
963: #endif
964: };
965:
966:
967:
968: /////////////////////////////////////////////////////////////////////////////
969:
970:
971: class CMapPtrToWord : public CObject
972: {
973:
974: DECLARE_DYNAMIC(CMapPtrToWord)
975: protected:
976: // Association
977: struct CAssoc
978: {
979: CAssoc* pNext;
980: UINT nHashValue; // needed for efficient iteration
981: void* key;
982: WORD value;
983: };
984: public:
985:
986: // Construction
987: CMapPtrToWord(int nBlockSize=10);
988:
989: // Attributes
990: // number of elements
991: int GetCount() const
992: { return m_nCount; }
993: BOOL IsEmpty() const
994: { return m_nCount == 0; }
995: // Lookup
996: BOOL Lookup(void* key, WORD& rValue) const;
997:
998: // Operations
999: // Lookup and add if not there
1000: WORD& operator[](void* key);
1001:
1002: // add a new (key, value) pair
1003: void SetAt(void* key, WORD newValue)
1004: { (*this)[key] = newValue; }
1005:
1006: // removing existing (key, ?) pair
1007: BOOL RemoveKey(void* key);
1008: void RemoveAll();
1009:
1010: // iterating all (key, value) pairs
1011: POSITION GetStartPosition() const
1012: { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
1013: void GetNextAssoc(POSITION& rNextPosition, void*& rKey, WORD& rValue) const;
1014:
1015: // advanced features for derived classes
1016: UINT GetHashTableSize() const
1017: { return m_nHashTableSize; }
1018: void InitHashTable(UINT hashSize);
1019:
1020: // Overridables: special non-virtual (see map implementation for details)
1021: // Routine used to user-provided hash keys
1022: UINT HashKey(void* key) const;
1023:
1024: // Implementation
1025: protected:
1026: CAssoc** m_pHashTable;
1027: UINT m_nHashTableSize;
1028: int m_nCount;
1029: CAssoc* m_pFreeList;
1030: struct CPlex* m_pBlocks;
1031: int m_nBlockSize;
1032:
1033: CAssoc* NewAssoc();
1034: void FreeAssoc(CAssoc*);
1035: CAssoc* GetAssocAt(void*, UINT&) const;
1036:
1037: public:
1038: ~CMapPtrToWord();
1039: #ifdef _DEBUG
1040: void Dump(CDumpContext&) const;
1041: void AssertValid() const;
1042: #endif
1043: };
1044:
1045:
1046:
1047: /////////////////////////////////////////////////////////////////////////////
1048:
1049:
1050: class CMapPtrToPtr : public CObject
1051: {
1052:
1053: DECLARE_DYNAMIC(CMapPtrToPtr)
1054: protected:
1055: // Association
1056: struct CAssoc
1057: {
1058: CAssoc* pNext;
1059: UINT nHashValue; // needed for efficient iteration
1060: void* key;
1061: void* value;
1062: };
1063: public:
1064:
1065: // Construction
1066: CMapPtrToPtr(int nBlockSize=10);
1067:
1068: // Attributes
1069: // number of elements
1070: int GetCount() const
1071: { return m_nCount; }
1072: BOOL IsEmpty() const
1073: { return m_nCount == 0; }
1074: // Lookup
1075: BOOL Lookup(void* key, void*& rValue) const;
1076:
1077: // Operations
1078: // Lookup and add if not there
1079: void*& operator[](void* key);
1080:
1081: // add a new (key, value) pair
1082: void SetAt(void* key, void* newValue)
1083: { (*this)[key] = newValue; }
1084:
1085: // removing existing (key, ?) pair
1086: BOOL RemoveKey(void* key);
1087: void RemoveAll();
1088:
1089: // iterating all (key, value) pairs
1090: POSITION GetStartPosition() const
1091: { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
1092: void GetNextAssoc(POSITION& rNextPosition, void*& rKey, void*& rValue) const;
1093:
1094: // advanced features for derived classes
1095: UINT GetHashTableSize() const
1096: { return m_nHashTableSize; }
1097: void InitHashTable(UINT hashSize);
1098:
1099: // Overridables: special non-virtual (see map implementation for details)
1100: // Routine used to user-provided hash keys
1101: UINT HashKey(void* key) const;
1102:
1103: // Implementation
1104: protected:
1105: CAssoc** m_pHashTable;
1106: UINT m_nHashTableSize;
1107: int m_nCount;
1108: CAssoc* m_pFreeList;
1109: struct CPlex* m_pBlocks;
1110: int m_nBlockSize;
1111:
1112: CAssoc* NewAssoc();
1113: void FreeAssoc(CAssoc*);
1114: CAssoc* GetAssocAt(void*, UINT&) const;
1115:
1116: public:
1117: ~CMapPtrToPtr();
1118: #ifdef _DEBUG
1119: void Dump(CDumpContext&) const;
1120: void AssertValid() const;
1121: #endif
1122: };
1123:
1124:
1125:
1126: /////////////////////////////////////////////////////////////////////////////
1127:
1128:
1129: class CMapWordToOb : public CObject
1130: {
1131:
1132: DECLARE_SERIAL(CMapWordToOb)
1133: protected:
1134: // Association
1135: struct CAssoc
1136: {
1137: CAssoc* pNext;
1138: UINT nHashValue; // needed for efficient iteration
1139: WORD key;
1140: CObject* value;
1141: };
1142: public:
1143:
1144: // Construction
1145: CMapWordToOb(int nBlockSize=10);
1146:
1147: // Attributes
1148: // number of elements
1149: int GetCount() const
1150: { return m_nCount; }
1151: BOOL IsEmpty() const
1152: { return m_nCount == 0; }
1153: // Lookup
1154: BOOL Lookup(WORD key, CObject*& rValue) const;
1155:
1156: // Operations
1157: // Lookup and add if not there
1158: CObject*& operator[](WORD key);
1159:
1160: // add a new (key, value) pair
1161: void SetAt(WORD key, CObject* newValue)
1162: { (*this)[key] = newValue; }
1163:
1164: // removing existing (key, ?) pair
1165: BOOL RemoveKey(WORD key);
1166: void RemoveAll();
1167:
1168: // iterating all (key, value) pairs
1169: POSITION GetStartPosition() const
1170: { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
1171: void GetNextAssoc(POSITION& rNextPosition, WORD& rKey, CObject*& rValue) const;
1172:
1173: // advanced features for derived classes
1174: UINT GetHashTableSize() const
1175: { return m_nHashTableSize; }
1176: void InitHashTable(UINT hashSize);
1177:
1178: // Overridables: special non-virtual (see map implementation for details)
1179: // Routine used to user-provided hash keys
1180: UINT HashKey(WORD key) const;
1181:
1182: // Implementation
1183: protected:
1184: CAssoc** m_pHashTable;
1185: UINT m_nHashTableSize;
1186: int m_nCount;
1187: CAssoc* m_pFreeList;
1188: struct CPlex* m_pBlocks;
1189: int m_nBlockSize;
1190:
1191: CAssoc* NewAssoc();
1192: void FreeAssoc(CAssoc*);
1193: CAssoc* GetAssocAt(WORD, UINT&) const;
1194:
1195: public:
1196: ~CMapWordToOb();
1197:
1198: void Serialize(CArchive&);
1199: #ifdef _DEBUG
1200: void Dump(CDumpContext&) const;
1201: void AssertValid() const;
1202: #endif
1203: };
1204:
1205:
1206:
1207: /////////////////////////////////////////////////////////////////////////////
1208:
1209:
1210: class CMapStringToPtr : public CObject
1211: {
1212:
1213: DECLARE_DYNAMIC(CMapStringToPtr)
1214: protected:
1215: // Association
1216: struct CAssoc
1217: {
1218: CAssoc* pNext;
1219: UINT nHashValue; // needed for efficient iteration
1220: CString key;
1221: void* value;
1222: };
1223: public:
1224:
1225: // Construction
1226: CMapStringToPtr(int nBlockSize=10);
1227:
1228: // Attributes
1229: // number of elements
1230: int GetCount() const
1231: { return m_nCount; }
1232: BOOL IsEmpty() const
1233: { return m_nCount == 0; }
1234: // Lookup
1235: BOOL Lookup(const char* key, void*& rValue) const;
1236:
1237: // Operations
1238: // Lookup and add if not there
1239: void*& operator[](const char* key);
1240:
1241: // add a new (key, value) pair
1242: void SetAt(const char* key, void* newValue)
1243: { (*this)[key] = newValue; }
1244:
1245: // removing existing (key, ?) pair
1246: BOOL RemoveKey(const char* key);
1247: void RemoveAll();
1248:
1249: // iterating all (key, value) pairs
1250: POSITION GetStartPosition() const
1251: { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
1252: void GetNextAssoc(POSITION& rNextPosition, CString& rKey, void*& rValue) const;
1253:
1254: // advanced features for derived classes
1255: UINT GetHashTableSize() const
1256: { return m_nHashTableSize; }
1257: void InitHashTable(UINT hashSize);
1258:
1259: // Overridables: special non-virtual (see map implementation for details)
1260: // Routine used to user-provided hash keys
1261: UINT HashKey(const char* key) const;
1262:
1263: // Implementation
1264: protected:
1265: CAssoc** m_pHashTable;
1266: UINT m_nHashTableSize;
1267: int m_nCount;
1268: CAssoc* m_pFreeList;
1269: struct CPlex* m_pBlocks;
1270: int m_nBlockSize;
1271:
1272: CAssoc* NewAssoc();
1273: void FreeAssoc(CAssoc*);
1274: CAssoc* GetAssocAt(const char*, UINT&) const;
1275:
1276: public:
1277: ~CMapStringToPtr();
1278: #ifdef _DEBUG
1279: void Dump(CDumpContext&) const;
1280: void AssertValid() const;
1281: #endif
1282: };
1283:
1284:
1285:
1286: /////////////////////////////////////////////////////////////////////////////
1287:
1288:
1289: class CMapStringToOb : public CObject
1290: {
1291:
1292: DECLARE_SERIAL(CMapStringToOb)
1293: protected:
1294: // Association
1295: struct CAssoc
1296: {
1297: CAssoc* pNext;
1298: UINT nHashValue; // needed for efficient iteration
1299: CString key;
1300: CObject* value;
1301: };
1302: public:
1303:
1304: // Construction
1305: CMapStringToOb(int nBlockSize=10);
1306:
1307: // Attributes
1308: // number of elements
1309: int GetCount() const
1310: { return m_nCount; }
1311: BOOL IsEmpty() const
1312: { return m_nCount == 0; }
1313: // Lookup
1314: BOOL Lookup(const char* key, CObject*& rValue) const;
1315:
1316: // Operations
1317: // Lookup and add if not there
1318: CObject*& operator[](const char* key);
1319:
1320: // add a new (key, value) pair
1321: void SetAt(const char* key, CObject* newValue)
1322: { (*this)[key] = newValue; }
1323:
1324: // removing existing (key, ?) pair
1325: BOOL RemoveKey(const char* key);
1326: void RemoveAll();
1327:
1328: // iterating all (key, value) pairs
1329: POSITION GetStartPosition() const
1330: { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
1331: void GetNextAssoc(POSITION& rNextPosition, CString& rKey, CObject*& rValue) const;
1332:
1333: // advanced features for derived classes
1334: UINT GetHashTableSize() const
1335: { return m_nHashTableSize; }
1336: void InitHashTable(UINT hashSize);
1337:
1338: // Overridables: special non-virtual (see map implementation for details)
1339: // Routine used to user-provided hash keys
1340: UINT HashKey(const char* key) const;
1341:
1342: // Implementation
1343: protected:
1344: CAssoc** m_pHashTable;
1345: UINT m_nHashTableSize;
1346: int m_nCount;
1347: CAssoc* m_pFreeList;
1348: struct CPlex* m_pBlocks;
1349: int m_nBlockSize;
1350:
1351: CAssoc* NewAssoc();
1352: void FreeAssoc(CAssoc*);
1353: CAssoc* GetAssocAt(const char*, UINT&) const;
1354:
1355: public:
1356: ~CMapStringToOb();
1357:
1358: void Serialize(CArchive&);
1359: #ifdef _DEBUG
1360: void Dump(CDumpContext&) const;
1361: void AssertValid() const;
1362: #endif
1363: };
1364:
1365:
1366:
1367: /////////////////////////////////////////////////////////////////////////////
1368:
1369:
1370: class CMapStringToString : public CObject
1371: {
1372:
1373: DECLARE_SERIAL(CMapStringToString)
1374: protected:
1375: // Association
1376: struct CAssoc
1377: {
1378: CAssoc* pNext;
1379: UINT nHashValue; // needed for efficient iteration
1380: CString key;
1381: CString value;
1382: };
1383: public:
1384:
1385: // Construction
1386: CMapStringToString(int nBlockSize=10);
1387:
1388: // Attributes
1389: // number of elements
1390: int GetCount() const
1391: { return m_nCount; }
1392: BOOL IsEmpty() const
1393: { return m_nCount == 0; }
1394: // Lookup
1395: BOOL Lookup(const char* key, CString& rValue) const;
1396:
1397: // Operations
1398: // Lookup and add if not there
1399: CString& operator[](const char* key);
1400:
1401: // add a new (key, value) pair
1402: void SetAt(const char* key, const char* newValue)
1403: { (*this)[key] = newValue; }
1404:
1405: // removing existing (key, ?) pair
1406: BOOL RemoveKey(const char* key);
1407: void RemoveAll();
1408:
1409: // iterating all (key, value) pairs
1410: POSITION GetStartPosition() const
1411: { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
1412: void GetNextAssoc(POSITION& rNextPosition, CString& rKey, CString& rValue) const;
1413:
1414: // advanced features for derived classes
1415: UINT GetHashTableSize() const
1416: { return m_nHashTableSize; }
1417: void InitHashTable(UINT hashSize);
1418:
1419: // Overridables: special non-virtual (see map implementation for details)
1420: // Routine used to user-provided hash keys
1421: UINT HashKey(const char* key) const;
1422:
1423: // Implementation
1424: protected:
1425: CAssoc** m_pHashTable;
1426: UINT m_nHashTableSize;
1427: int m_nCount;
1428: CAssoc* m_pFreeList;
1429: struct CPlex* m_pBlocks;
1430: int m_nBlockSize;
1431:
1432: CAssoc* NewAssoc();
1433: void FreeAssoc(CAssoc*);
1434: CAssoc* GetAssocAt(const char*, UINT&) const;
1435:
1436: public:
1437: ~CMapStringToString();
1438:
1439: void Serialize(CArchive&);
1440: #ifdef _DEBUG
1441: void Dump(CDumpContext&) const;
1442: void AssertValid() const;
1443: #endif
1444: };
1445:
1446: #undef THIS_FILE
1447: #define THIS_FILE __FILE__
1448: #endif //!__AFXCOLL_H__
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.