home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c480 / 19.ddi / MFC / INCLUDE / AFXCOLL.IN_ / AFXCOLL.IN
Encoding:
Text File  |  1993-02-08  |  18.6 KB  |  469 lines
  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 and/or WinHelp documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. // Inlines for AFXCOLL.H
  12.  
  13. #ifdef _AFXCOLL_INLINE
  14.  
  15. ////////////////////////////////////////////////////////////////////////////
  16.  
  17. _AFXCOLL_INLINE int CByteArray::GetSize() const
  18.     { return m_nSize; }
  19. _AFXCOLL_INLINE int CByteArray::GetUpperBound() const
  20.     { return m_nSize-1; }
  21. _AFXCOLL_INLINE void CByteArray::RemoveAll()
  22.     { SetSize(0); }
  23. _AFXCOLL_INLINE BYTE CByteArray::GetAt(int nIndex) const
  24.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  25.         return m_pData[nIndex]; }
  26. _AFXCOLL_INLINE void CByteArray::SetAt(int nIndex, BYTE newElement)
  27.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  28.         m_pData[nIndex] = newElement; }
  29. _AFXCOLL_INLINE BYTE& CByteArray::ElementAt(int nIndex)
  30.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  31.         return m_pData[nIndex]; }
  32. _AFXCOLL_INLINE int CByteArray::Add(BYTE newElement)
  33.     { int nIndex = m_nSize;
  34.         SetAtGrow(nIndex, newElement);
  35.         return nIndex; }
  36. _AFXCOLL_INLINE BYTE CByteArray::operator[](int nIndex) const
  37.     { return GetAt(nIndex); }
  38. _AFXCOLL_INLINE BYTE& CByteArray::operator[](int nIndex)
  39.     { return ElementAt(nIndex); }
  40.  
  41.  
  42. ////////////////////////////////////////////////////////////////////////////
  43.  
  44. _AFXCOLL_INLINE int CWordArray::GetSize() const
  45.     { return m_nSize; }
  46. _AFXCOLL_INLINE int CWordArray::GetUpperBound() const
  47.     { return m_nSize-1; }
  48. _AFXCOLL_INLINE void CWordArray::RemoveAll()
  49.     { SetSize(0); }
  50. _AFXCOLL_INLINE WORD CWordArray::GetAt(int nIndex) const
  51.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  52.         return m_pData[nIndex]; }
  53. _AFXCOLL_INLINE void CWordArray::SetAt(int nIndex, WORD newElement)
  54.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  55.         m_pData[nIndex] = newElement; }
  56. _AFXCOLL_INLINE WORD& CWordArray::ElementAt(int nIndex)
  57.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  58.         return m_pData[nIndex]; }
  59. _AFXCOLL_INLINE int CWordArray::Add(WORD newElement)
  60.     { int nIndex = m_nSize;
  61.         SetAtGrow(nIndex, newElement);
  62.         return nIndex; }
  63. _AFXCOLL_INLINE WORD CWordArray::operator[](int nIndex) const
  64.     { return GetAt(nIndex); }
  65. _AFXCOLL_INLINE WORD& CWordArray::operator[](int nIndex)
  66.     { return ElementAt(nIndex); }
  67.  
  68.  
  69. ////////////////////////////////////////////////////////////////////////////
  70.  
  71. _AFXCOLL_INLINE int CDWordArray::GetSize() const
  72.     { return m_nSize; }
  73. _AFXCOLL_INLINE int CDWordArray::GetUpperBound() const
  74.     { return m_nSize-1; }
  75. _AFXCOLL_INLINE void CDWordArray::RemoveAll()
  76.     { SetSize(0); }
  77. _AFXCOLL_INLINE DWORD CDWordArray::GetAt(int nIndex) const
  78.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  79.         return m_pData[nIndex]; }
  80. _AFXCOLL_INLINE void CDWordArray::SetAt(int nIndex, DWORD newElement)
  81.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  82.         m_pData[nIndex] = newElement; }
  83. _AFXCOLL_INLINE DWORD& CDWordArray::ElementAt(int nIndex)
  84.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  85.         return m_pData[nIndex]; }
  86. _AFXCOLL_INLINE int CDWordArray::Add(DWORD newElement)
  87.     { int nIndex = m_nSize;
  88.         SetAtGrow(nIndex, newElement);
  89.         return nIndex; }
  90. _AFXCOLL_INLINE DWORD CDWordArray::operator[](int nIndex) const
  91.     { return GetAt(nIndex); }
  92. _AFXCOLL_INLINE DWORD& CDWordArray::operator[](int nIndex)
  93.     { return ElementAt(nIndex); }
  94.  
  95.  
  96. ////////////////////////////////////////////////////////////////////////////
  97.  
  98. _AFXCOLL_INLINE int CUIntArray::GetSize() const
  99.     { return m_nSize; }
  100. _AFXCOLL_INLINE int CUIntArray::GetUpperBound() const
  101.     { return m_nSize-1; }
  102. _AFXCOLL_INLINE void CUIntArray::RemoveAll()
  103.     { SetSize(0); }
  104. _AFXCOLL_INLINE UINT CUIntArray::GetAt(int nIndex) const
  105.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  106.         return m_pData[nIndex]; }
  107. _AFXCOLL_INLINE void CUIntArray::SetAt(int nIndex, UINT newElement)
  108.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  109.         m_pData[nIndex] = newElement; }
  110. _AFXCOLL_INLINE UINT& CUIntArray::ElementAt(int nIndex)
  111.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  112.         return m_pData[nIndex]; }
  113. _AFXCOLL_INLINE int CUIntArray::Add(UINT newElement)
  114.     { int nIndex = m_nSize;
  115.         SetAtGrow(nIndex, newElement);
  116.         return nIndex; }
  117. _AFXCOLL_INLINE UINT CUIntArray::operator[](int nIndex) const
  118.     { return GetAt(nIndex); }
  119. _AFXCOLL_INLINE UINT& CUIntArray::operator[](int nIndex)
  120.     { return ElementAt(nIndex); }
  121.  
  122.  
  123. ////////////////////////////////////////////////////////////////////////////
  124.  
  125. _AFXCOLL_INLINE int CPtrArray::GetSize() const
  126.     { return m_nSize; }
  127. _AFXCOLL_INLINE int CPtrArray::GetUpperBound() const
  128.     { return m_nSize-1; }
  129. _AFXCOLL_INLINE void CPtrArray::RemoveAll()
  130.     { SetSize(0); }
  131. _AFXCOLL_INLINE void* CPtrArray::GetAt(int nIndex) const
  132.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  133.         return m_pData[nIndex]; }
  134. _AFXCOLL_INLINE void CPtrArray::SetAt(int nIndex, void* newElement)
  135.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  136.         m_pData[nIndex] = newElement; }
  137. _AFXCOLL_INLINE void*& CPtrArray::ElementAt(int nIndex)
  138.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  139.         return m_pData[nIndex]; }
  140. _AFXCOLL_INLINE int CPtrArray::Add(void* newElement)
  141.     { int nIndex = m_nSize;
  142.         SetAtGrow(nIndex, newElement);
  143.         return nIndex; }
  144. _AFXCOLL_INLINE void* CPtrArray::operator[](int nIndex) const
  145.     { return GetAt(nIndex); }
  146. _AFXCOLL_INLINE void*& CPtrArray::operator[](int nIndex)
  147.     { return ElementAt(nIndex); }
  148.  
  149.  
  150. ////////////////////////////////////////////////////////////////////////////
  151.  
  152. _AFXCOLL_INLINE int CObArray::GetSize() const
  153.     { return m_nSize; }
  154. _AFXCOLL_INLINE int CObArray::GetUpperBound() const
  155.     { return m_nSize-1; }
  156. _AFXCOLL_INLINE void CObArray::RemoveAll()
  157.     { SetSize(0); }
  158. _AFXCOLL_INLINE CObject* CObArray::GetAt(int nIndex) const
  159.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  160.         return m_pData[nIndex]; }
  161. _AFXCOLL_INLINE void CObArray::SetAt(int nIndex, CObject* newElement)
  162.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  163.         m_pData[nIndex] = newElement; }
  164. _AFXCOLL_INLINE CObject*& CObArray::ElementAt(int nIndex)
  165.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  166.         return m_pData[nIndex]; }
  167. _AFXCOLL_INLINE int CObArray::Add(CObject* newElement)
  168.     { int nIndex = m_nSize;
  169.         SetAtGrow(nIndex, newElement);
  170.         return nIndex; }
  171. _AFXCOLL_INLINE CObject* CObArray::operator[](int nIndex) const
  172.     { return GetAt(nIndex); }
  173. _AFXCOLL_INLINE CObject*& CObArray::operator[](int nIndex)
  174.     { return ElementAt(nIndex); }
  175.  
  176.  
  177. ////////////////////////////////////////////////////////////////////////////
  178.  
  179. _AFXCOLL_INLINE int CStringArray::GetSize() const
  180.     { return m_nSize; }
  181. _AFXCOLL_INLINE int CStringArray::GetUpperBound() const
  182.     { return m_nSize-1; }
  183. _AFXCOLL_INLINE void CStringArray::RemoveAll()
  184.     { SetSize(0); }
  185. _AFXCOLL_INLINE CString CStringArray::GetAt(int nIndex) const
  186.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  187.         return m_pData[nIndex]; }
  188. _AFXCOLL_INLINE void CStringArray::SetAt(int nIndex, const char* newElement)
  189.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  190.         m_pData[nIndex] = newElement; }
  191. _AFXCOLL_INLINE CString& CStringArray::ElementAt(int nIndex)
  192.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  193.         return m_pData[nIndex]; }
  194. _AFXCOLL_INLINE int CStringArray::Add(const char* newElement)
  195.     { int nIndex = m_nSize;
  196.         SetAtGrow(nIndex, newElement);
  197.         return nIndex; }
  198. _AFXCOLL_INLINE CString CStringArray::operator[](int nIndex) const
  199.     { return GetAt(nIndex); }
  200. _AFXCOLL_INLINE CString& CStringArray::operator[](int nIndex)
  201.     { return ElementAt(nIndex); }
  202.  
  203.  
  204. ////////////////////////////////////////////////////////////////////////////
  205.  
  206. _AFXCOLL_INLINE int CPtrList::GetCount() const
  207.     { return m_nCount; }
  208. _AFXCOLL_INLINE BOOL CPtrList::IsEmpty() const
  209.     { return m_nCount == 0; }
  210. _AFXCOLL_INLINE void*& CPtrList::GetHead()
  211.     { ASSERT(m_pNodeHead != NULL);
  212.         return m_pNodeHead->data; }
  213. _AFXCOLL_INLINE void* CPtrList::GetHead() const
  214.     { ASSERT(m_pNodeHead != NULL);
  215.         return m_pNodeHead->data; }
  216. _AFXCOLL_INLINE void*& CPtrList::GetTail()
  217.     { ASSERT(m_pNodeTail != NULL);
  218.         return m_pNodeTail->data; }
  219. _AFXCOLL_INLINE void* CPtrList::GetTail() const
  220.     { ASSERT(m_pNodeTail != NULL);
  221.         return m_pNodeTail->data; }
  222. _AFXCOLL_INLINE POSITION CPtrList::GetHeadPosition() const
  223.     { return (POSITION) m_pNodeHead; }
  224. _AFXCOLL_INLINE POSITION CPtrList::GetTailPosition() const
  225.     { return (POSITION) m_pNodeTail; }
  226. _AFXCOLL_INLINE void*& CPtrList::GetNext(POSITION& rPosition) // return *Position++
  227.     { CNode* pNode = (CNode*) rPosition;
  228.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  229.         rPosition = (POSITION) pNode->pNext;
  230.         return pNode->data; }
  231. _AFXCOLL_INLINE void* CPtrList::GetNext(POSITION& rPosition) const // return *Position++
  232.     { CNode* pNode = (CNode*) rPosition;
  233.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  234.         rPosition = (POSITION) pNode->pNext;
  235.         return pNode->data; }
  236. _AFXCOLL_INLINE void*& CPtrList::GetPrev(POSITION& rPosition) // return *Position--
  237.     { CNode* pNode = (CNode*) rPosition;
  238.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  239.         rPosition = (POSITION) pNode->pPrev;
  240.         return pNode->data; }
  241. _AFXCOLL_INLINE void* CPtrList::GetPrev(POSITION& rPosition) const // return *Position--
  242.     { CNode* pNode = (CNode*) rPosition;
  243.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  244.         rPosition = (POSITION) pNode->pPrev;
  245.         return pNode->data; }
  246. _AFXCOLL_INLINE void*& CPtrList::GetAt(POSITION position)
  247.     { CNode* pNode = (CNode*) position;
  248.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  249.         return pNode->data; }
  250. _AFXCOLL_INLINE void* CPtrList::GetAt(POSITION position) const
  251.     { CNode* pNode = (CNode*) position;
  252.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  253.         return pNode->data; }
  254. _AFXCOLL_INLINE void CPtrList::SetAt(POSITION pos, void* newElement)
  255.     { CNode* pNode = (CNode*) pos;
  256.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  257.         pNode->data = newElement; }
  258.  
  259.  
  260. ////////////////////////////////////////////////////////////////////////////
  261.  
  262. _AFXCOLL_INLINE int CObList::GetCount() const
  263.     { return m_nCount; }
  264. _AFXCOLL_INLINE BOOL CObList::IsEmpty() const
  265.     { return m_nCount == 0; }
  266. _AFXCOLL_INLINE CObject*& CObList::GetHead()
  267.     { ASSERT(m_pNodeHead != NULL);
  268.         return m_pNodeHead->data; }
  269. _AFXCOLL_INLINE CObject* CObList::GetHead() const
  270.     { ASSERT(m_pNodeHead != NULL);
  271.         return m_pNodeHead->data; }
  272. _AFXCOLL_INLINE CObject*& CObList::GetTail()
  273.     { ASSERT(m_pNodeTail != NULL);
  274.         return m_pNodeTail->data; }
  275. _AFXCOLL_INLINE CObject* CObList::GetTail() const
  276.     { ASSERT(m_pNodeTail != NULL);
  277.         return m_pNodeTail->data; }
  278. _AFXCOLL_INLINE POSITION CObList::GetHeadPosition() const
  279.     { return (POSITION) m_pNodeHead; }
  280. _AFXCOLL_INLINE POSITION CObList::GetTailPosition() const
  281.     { return (POSITION) m_pNodeTail; }
  282. _AFXCOLL_INLINE CObject*& CObList::GetNext(POSITION& rPosition) // return *Position++
  283.     { CNode* pNode = (CNode*) rPosition;
  284.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  285.         rPosition = (POSITION) pNode->pNext;
  286.         return pNode->data; }
  287. _AFXCOLL_INLINE CObject* CObList::GetNext(POSITION& rPosition) const // return *Position++
  288.     { CNode* pNode = (CNode*) rPosition;
  289.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  290.         rPosition = (POSITION) pNode->pNext;
  291.         return pNode->data; }
  292. _AFXCOLL_INLINE CObject*& CObList::GetPrev(POSITION& rPosition) // return *Position--
  293.     { CNode* pNode = (CNode*) rPosition;
  294.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  295.         rPosition = (POSITION) pNode->pPrev;
  296.         return pNode->data; }
  297. _AFXCOLL_INLINE CObject* CObList::GetPrev(POSITION& rPosition) const // return *Position--
  298.     { CNode* pNode = (CNode*) rPosition;
  299.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  300.         rPosition = (POSITION) pNode->pPrev;
  301.         return pNode->data; }
  302. _AFXCOLL_INLINE CObject*& CObList::GetAt(POSITION position)
  303.     { CNode* pNode = (CNode*) position;
  304.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  305.         return pNode->data; }
  306. _AFXCOLL_INLINE CObject* CObList::GetAt(POSITION position) const
  307.     { CNode* pNode = (CNode*) position;
  308.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  309.         return pNode->data; }
  310. _AFXCOLL_INLINE void CObList::SetAt(POSITION pos, CObject* newElement)
  311.     { CNode* pNode = (CNode*) pos;
  312.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  313.         pNode->data = newElement; }
  314.  
  315.  
  316. ////////////////////////////////////////////////////////////////////////////
  317.  
  318. _AFXCOLL_INLINE int CStringList::GetCount() const
  319.     { return m_nCount; }
  320. _AFXCOLL_INLINE BOOL CStringList::IsEmpty() const
  321.     { return m_nCount == 0; }
  322. _AFXCOLL_INLINE CString& CStringList::GetHead()
  323.     { ASSERT(m_pNodeHead != NULL);
  324.         return m_pNodeHead->data; }
  325. _AFXCOLL_INLINE CString CStringList::GetHead() const
  326.     { ASSERT(m_pNodeHead != NULL);
  327.         return m_pNodeHead->data; }
  328. _AFXCOLL_INLINE CString& CStringList::GetTail()
  329.     { ASSERT(m_pNodeTail != NULL);
  330.         return m_pNodeTail->data; }
  331. _AFXCOLL_INLINE CString CStringList::GetTail() const
  332.     { ASSERT(m_pNodeTail != NULL);
  333.         return m_pNodeTail->data; }
  334. _AFXCOLL_INLINE POSITION CStringList::GetHeadPosition() const
  335.     { return (POSITION) m_pNodeHead; }
  336. _AFXCOLL_INLINE POSITION CStringList::GetTailPosition() const
  337.     { return (POSITION) m_pNodeTail; }
  338. _AFXCOLL_INLINE CString& CStringList::GetNext(POSITION& rPosition) // return *Position++
  339.     { CNode* pNode = (CNode*) rPosition;
  340.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  341.         rPosition = (POSITION) pNode->pNext;
  342.         return pNode->data; }
  343. _AFXCOLL_INLINE CString CStringList::GetNext(POSITION& rPosition) const // return *Position++
  344.     { CNode* pNode = (CNode*) rPosition;
  345.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  346.         rPosition = (POSITION) pNode->pNext;
  347.         return pNode->data; }
  348. _AFXCOLL_INLINE CString& CStringList::GetPrev(POSITION& rPosition) // return *Position--
  349.     { CNode* pNode = (CNode*) rPosition;
  350.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  351.         rPosition = (POSITION) pNode->pPrev;
  352.         return pNode->data; }
  353. _AFXCOLL_INLINE CString CStringList::GetPrev(POSITION& rPosition) const // return *Position--
  354.     { CNode* pNode = (CNode*) rPosition;
  355.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  356.         rPosition = (POSITION) pNode->pPrev;
  357.         return pNode->data; }
  358. _AFXCOLL_INLINE CString& CStringList::GetAt(POSITION position)
  359.     { CNode* pNode = (CNode*) position;
  360.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  361.         return pNode->data; }
  362. _AFXCOLL_INLINE CString CStringList::GetAt(POSITION position) const
  363.     { CNode* pNode = (CNode*) position;
  364.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  365.         return pNode->data; }
  366. _AFXCOLL_INLINE void CStringList::SetAt(POSITION pos, const char* newElement)
  367.     { CNode* pNode = (CNode*) pos;
  368.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  369.         pNode->data = newElement; }
  370.  
  371.  
  372. ////////////////////////////////////////////////////////////////////////////
  373.  
  374. _AFXCOLL_INLINE int CMapWordToPtr::GetCount() const
  375.     { return m_nCount; }
  376. _AFXCOLL_INLINE BOOL CMapWordToPtr::IsEmpty() const
  377.     { return m_nCount == 0; }
  378. _AFXCOLL_INLINE void CMapWordToPtr::SetAt(WORD key, void* newValue)
  379.     { (*this)[key] = newValue; }
  380. _AFXCOLL_INLINE POSITION CMapWordToPtr::GetStartPosition() const
  381.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  382. _AFXCOLL_INLINE UINT CMapWordToPtr::GetHashTableSize() const
  383.     { return m_nHashTableSize; }
  384.  
  385.  
  386. ////////////////////////////////////////////////////////////////////////////
  387.  
  388. _AFXCOLL_INLINE int CMapPtrToWord::GetCount() const
  389.     { return m_nCount; }
  390. _AFXCOLL_INLINE BOOL CMapPtrToWord::IsEmpty() const
  391.     { return m_nCount == 0; }
  392. _AFXCOLL_INLINE void CMapPtrToWord::SetAt(void* key, WORD newValue)
  393.     { (*this)[key] = newValue; }
  394. _AFXCOLL_INLINE POSITION CMapPtrToWord::GetStartPosition() const
  395.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  396. _AFXCOLL_INLINE UINT CMapPtrToWord::GetHashTableSize() const
  397.     { return m_nHashTableSize; }
  398.  
  399.  
  400. ////////////////////////////////////////////////////////////////////////////
  401.  
  402. _AFXCOLL_INLINE int CMapPtrToPtr::GetCount() const
  403.     { return m_nCount; }
  404. _AFXCOLL_INLINE BOOL CMapPtrToPtr::IsEmpty() const
  405.     { return m_nCount == 0; }
  406. _AFXCOLL_INLINE void CMapPtrToPtr::SetAt(void* key, void* newValue)
  407.     { (*this)[key] = newValue; }
  408. _AFXCOLL_INLINE POSITION CMapPtrToPtr::GetStartPosition() const
  409.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  410. _AFXCOLL_INLINE UINT CMapPtrToPtr::GetHashTableSize() const
  411.     { return m_nHashTableSize; }
  412.  
  413.  
  414. ////////////////////////////////////////////////////////////////////////////
  415.  
  416. _AFXCOLL_INLINE int CMapWordToOb::GetCount() const
  417.     { return m_nCount; }
  418. _AFXCOLL_INLINE BOOL CMapWordToOb::IsEmpty() const
  419.     { return m_nCount == 0; }
  420. _AFXCOLL_INLINE void CMapWordToOb::SetAt(WORD key, CObject* newValue)
  421.     { (*this)[key] = newValue; }
  422. _AFXCOLL_INLINE POSITION CMapWordToOb::GetStartPosition() const
  423.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  424. _AFXCOLL_INLINE UINT CMapWordToOb::GetHashTableSize() const
  425.     { return m_nHashTableSize; }
  426.  
  427.  
  428. ////////////////////////////////////////////////////////////////////////////
  429. _AFXCOLL_INLINE int CMapStringToPtr::GetCount() const
  430.     { return m_nCount; }
  431. _AFXCOLL_INLINE BOOL CMapStringToPtr::IsEmpty() const
  432.     { return m_nCount == 0; }
  433. _AFXCOLL_INLINE void CMapStringToPtr::SetAt(const char* key, void* newValue)
  434.     { (*this)[key] = newValue; }
  435. _AFXCOLL_INLINE POSITION CMapStringToPtr::GetStartPosition() const
  436.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  437. _AFXCOLL_INLINE UINT CMapStringToPtr::GetHashTableSize() const
  438.     { return m_nHashTableSize; }
  439.  
  440.  
  441. ////////////////////////////////////////////////////////////////////////////
  442. _AFXCOLL_INLINE int CMapStringToOb::GetCount() const
  443.     { return m_nCount; }
  444. _AFXCOLL_INLINE BOOL CMapStringToOb::IsEmpty() const
  445.     { return m_nCount == 0; }
  446. _AFXCOLL_INLINE void CMapStringToOb::SetAt(const char* key, CObject* newValue)
  447.     { (*this)[key] = newValue; }
  448. _AFXCOLL_INLINE POSITION CMapStringToOb::GetStartPosition() const
  449.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  450. _AFXCOLL_INLINE UINT CMapStringToOb::GetHashTableSize() const
  451.     { return m_nHashTableSize; }
  452.  
  453.  
  454. ////////////////////////////////////////////////////////////////////////////
  455. _AFXCOLL_INLINE int CMapStringToString::GetCount() const
  456.     { return m_nCount; }
  457. _AFXCOLL_INLINE BOOL CMapStringToString::IsEmpty() const
  458.     { return m_nCount == 0; }
  459. _AFXCOLL_INLINE void CMapStringToString::SetAt(const char* key, const char* newValue)
  460.     { (*this)[key] = newValue; }
  461. _AFXCOLL_INLINE POSITION CMapStringToString::GetStartPosition() const
  462.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  463. _AFXCOLL_INLINE UINT CMapStringToString::GetHashTableSize() const
  464.     { return m_nHashTableSize; }
  465.  
  466. /////////////////////////////////////////////////////////////////////////////
  467.  
  468. #endif //_AFXCOLL_INLINE
  469.