home *** CD-ROM | disk | FTP | other *** search
/ NEXT Generation 27 / NEXT27.iso / pc / demos / emperor / dx3.exe / SDK / SAMPLES / DSSHOW3D / DBLIST.CPP next >
C/C++ Source or Header  |  1996-08-28  |  5KB  |  235 lines
  1. #include <windows.h>
  2. #include "debug.h"
  3.  
  4. template<class T>
  5. DbLinkedList<T>::DbLinkedList()
  6. {
  7.     m_pTail = m_pHead = m_pCurrent = NULL;
  8. }
  9.  
  10.  
  11. template<class T>
  12. DbLinkedList<T>::DbLinkedList( T emptyElt )
  13. {
  14.     m_pTail = m_pHead = m_pCurrent = NULL;
  15.     m_emptyT = emptyElt;
  16. }
  17.  
  18.  
  19. template<class T>
  20. DbLinkedList<T>::~DbLinkedList()
  21. {
  22.     Clear();
  23. }
  24.  
  25.  
  26. template<class T>
  27. void DbLinkedList<T>::Clear( void )
  28. {
  29.     DblNode<T>  *pTemp;
  30.  
  31.     while( m_nElementCount )
  32.     {
  33.     pTemp = m_pHead->pNext;
  34.     delete m_pHead;
  35.     m_pHead = pTemp;
  36.     m_nElementCount--;
  37.     }
  38.  
  39.     m_pHead = m_pTail = m_pCurrent = NULL;
  40. }
  41.  
  42.  
  43. template<class T>
  44. void DbLinkedList<T>::Remove( T val )
  45. {
  46.     DblNode<T>  *pTemp = m_pHead;
  47.  
  48.     while( pTemp )
  49.     {
  50.     if( pTemp->value == val )
  51.     {
  52.         if( pTemp->pNext )
  53.             pTemp->pNext->pPrev = pTemp->pPrev;
  54.         if( pTemp->pPrev )
  55.             pTemp->pPrev->pNext = pTemp->pNext;
  56.         if( m_pHead == pTemp )
  57.             m_pHead = pTemp->pNext;
  58.         if( m_pTail == pTemp )
  59.             m_pTail = pTemp->pPrev;
  60.  
  61.         delete pTemp;
  62.  
  63.         m_nElementCount--;
  64.         pTemp = NULL;
  65.         return;
  66.     }
  67.  
  68.     pTemp = pTemp->pNext;
  69.     }
  70. }
  71.  
  72. template<class T>
  73. void DbLinkedList<T>::RemoveCurrent()
  74. {
  75.     if( m_pCurrent )
  76.     {
  77.     ASSERT( m_nElementCount > 0 );
  78.     
  79.     if( m_pCurrent->pNext )
  80.         m_pCurrent->pNext->pPrev = m_pCurrent->pPrev;
  81.     if( m_pCurrent->pPrev )
  82.         m_pCurrent->pPrev->pNext = m_pCurrent->pNext;
  83.     if( m_pHead == m_pCurrent )
  84.         m_pHead = m_pCurrent->pNext;
  85.     if( m_pTail == m_pCurrent )
  86.         m_pTail = m_pCurrent->pPrev;
  87.  
  88.     delete m_pCurrent;
  89.  
  90.     m_nElementCount--;
  91.     m_pCurrent = NULL;
  92.     }
  93. }
  94.  
  95. template<class T>
  96. T DbLinkedList<T>::GetCurrent()
  97. {
  98.     if( m_pCurrent )
  99.     {
  100.     ASSERT( m_nElementCount > 0 );
  101.     
  102.     return m_pCurrent->value;
  103.     }
  104.     return m_emptyT;
  105. }
  106.  
  107. // TRUE == success, FALSE == failure
  108. template<class T>
  109. BOOL DbLinkedList<T>::InsertAfterCurrent( T val )
  110. {
  111.     DbNode<T> *pTemp = new DbNode<T>;
  112.  
  113.     if( NULL == pTemp )
  114.     return FALSE;
  115.  
  116.     if( NULL == m_pCurrent )
  117.     {
  118.     AssertValid();
  119.     if( NULL != m_pHead )
  120.        {
  121.         pTemp->value = val;
  122.         pTemp->pPrev = m_pHead;
  123.         pTemp->pNext = m_pHead->pNext;
  124.         if( m_pHead->pNext )
  125.             m_pHead->pNext->pPrev = pTemp;
  126.         if( m_pTail == m_pHead )
  127.             m_pTail = pTemp;
  128.        }
  129.     } else {
  130.     pTemp->value = val;
  131.     pTemp->pPrev = m_pCurrent;
  132.     pTemp->pNext = m_pCurrent->pNext;
  133.     if( m_pCurrent->pNext )
  134.         m_pCurrent->pNext->pPrev = pTemp;
  135.     // If we were pointing at the tail, we are no longer pointing
  136.     // at it because we put a new element after the current one.
  137.     if( m_pTail == m_pCurrent )
  138.         m_pTail = pTemp;
  139.     }
  140.  
  141.     return TRUE;
  142. }
  143.  
  144.  
  145. // TRUE == success, FALSE == failure
  146. template<class T>
  147. BOOL DbLinkedList<T>::InsertBeforeCurrent( T val )
  148. {
  149.     DbNode<T> *pTemp = new DbNode<T>;
  150.  
  151.     if( NULL == pTemp )
  152.     return FALSE;
  153.  
  154.     if( NULL == m_pCurrent )
  155.     {
  156.     AssertValid();
  157.     if( NULL != m_pHead )
  158.        {
  159.         pTemp->value = val;
  160.         pTemp->pPrev = m_pHead;
  161.         pTemp->pNext = m_pHead->pNext;
  162.         if( m_pHead->pNext )
  163.             m_pHead->pNext->pPrev = pTemp;
  164.         if( m_pTail == m_pHead )
  165.             m_pTail = pTemp;
  166.        }
  167.     } else {
  168.     pTemp->value = val;
  169.     pTemp->pPrev = m_pCurrent;
  170.     pTemp->pNext = m_pCurrent->pNext;
  171.     if( m_pCurrent->pNext )
  172.         m_pCurrent->pNext->pPrev = pTemp;
  173.     // If we were pointing at the tail, we are no longer pointing
  174.     // at it because we put a new element after the current one.
  175.     if( m_pTail == m_pCurrent )
  176.         m_pTail = pTemp;
  177.     }
  178.  
  179.     return TRUE;
  180. }
  181.  
  182.  
  183. template<class T>
  184. void DbLinkedList<T>::Append( T val )
  185. {
  186.     DblNode<T> *pNode = new DblNode<T>;
  187.  
  188.     if( NULL == pNode )
  189.     return;
  190.  
  191.     AssertValid();
  192.     
  193.     pNode->value = val;
  194.     pNode->pNext = NULL;
  195.     pNode->pPrev = m_pTail;
  196.  
  197.     if( m_pTail )
  198.     m_pTail->pNext = pNode;
  199.     if( !m_pHead )
  200.     m_pHead = pNode;
  201.     m_pTail = pNode;
  202.     m_nElementCount++;
  203.  
  204.     // If there were no elements in the list, the m_pCurrent will be NULL
  205.     if( NULL == m_pCurrent )
  206.     {
  207.     ASSERT( m_nElementCount == 1 );
  208.     m_pCurrent = m_pHead;
  209.     }
  210. }
  211.  
  212.  
  213. // Do some assertions that determine whether or not this object is in a valid
  214. // state.  If it's not, one of these will fire.
  215. template<class T>
  216. void DbLinkedList<T>::AssertValid( void )
  217. {
  218.     if( m_nElementCount )
  219.     {
  220.     // If there are elements, then both these pointers should point
  221.     // at a legitimate DbNode object, or the list is corrupted
  222.     ASSERT( NULL != m_pHead );
  223.     ASSERT( NULL != m_pTail );
  224.     ASSERT( NULL != m_pCurrent );
  225.     }
  226.     else
  227.     {
  228.     ASSERT( NULL == m_pHead );
  229.     ASSERT( NULL == m_pTail );
  230.     ASSERT( NULL == m_pCurrent );
  231.     }
  232. }
  233.  
  234.  
  235.