Zak Engine v1.1.0: Fichero Fuente List.h

00001 #ifndef _LIST_H_
00002 #define _LIST_H_
00003 
00004 #include <windows.h>
00005 #include <memory.h>
00006 #include "ZakEngine/defines.h"
00007 #include "ZakEngine/Node.h" 
00008 
00009 
00010 namespace zak {
00011 
00012 template <class LIST_TYPE>
00013 
00018 class List 
00019 {
00020         // Get Previous Node of a certain Node
00021         Node<LIST_TYPE> *Previous(Node<LIST_TYPE> *pNode) 
00022         {
00023                 if (pNode) {
00024                         if (pNode->GetPreviousNode() != NULL)
00025                                 return (m_pActualNode = pNode->GetPreviousNode());
00026                         else
00027                                 return NULL;
00028                 } else
00029                         return NULL;
00030         }
00031 
00032         // Move to the next node
00033         Node<LIST_TYPE> *Next(Node<LIST_TYPE> *pNode) 
00034         {
00035                 if (pNode) {
00036                         if (pNode->GetNextNode() != NULL)
00037                                 return (m_pActualNode = pNode->GetNextNode());
00038                         else
00039                                 return NULL;
00040                 } else
00041                         return NULL;
00042         }
00043 
00044 public:
00045 
00049         void MoveToFirst(void)
00050         {
00051                 m_pActualNode = m_pFirstNode;
00052         }
00053 
00057         void MoveToLast(void)
00058         {
00059                 m_pActualNode = m_pLastNode;
00060         }
00061 
00066         bool MoveToNext(void) 
00067         {
00068                 if (m_pActualNode = Next(m_pActualNode))
00069                         return true;
00070                 else
00071                         return false;
00072         }
00073 
00078         bool MoveToPrevious(void) 
00079         {
00080                 if (m_pActualNode = Previous(m_pActualNode))
00081                         return true;
00082                 else
00083                         return false;
00084         }
00085 
00093         bool SearchForElement(const LIST_TYPE &Element)
00094         {
00095                 Node<LIST_TYPE> *pNode = m_pFirstNode;
00096                 while (pNode != NULL) {
00097                         if (pNode->GetElement() == Element) {
00098                                 m_pActualNode = pNode;
00099                                 return true;
00100                         }
00101                         pNode = pNode->GetNextNode();
00102                 }
00103                 return false;
00104         }
00105 
00112         bool InsertCurrent(const LIST_TYPE &Element)
00113         {
00114                 Node<LIST_TYPE> *pNode, *pTmp;
00115 
00116                 pNode = new Node<LIST_TYPE>;
00117                 if (pNode != NULL) { 
00118                         if (m_pActualNode != NULL) {
00119                                 pNode->SetNextNode(m_pActualNode->GetNextNode());
00120                                 pNode->SetPreviousNode(m_pActualNode);
00121                                 pNode->SetElement(Element);
00122                                 pTmp = m_pActualNode->GetNextNode();
00123                                 if (pTmp != NULL) pTmp->SetPreviousNode(pNode);
00124                                 m_pActualNode->SetNextNode(pNode);
00125                                 m_lCount++;
00126                                 return true;
00127                         }
00128                         else {
00129                                 if (InsertFront(Element)) {
00130                                         m_pFirstNode = pNode;
00131                                         return true;
00132                                 }
00133                                 else
00134                                         return false;
00135                         }
00136                 }
00137                 else
00138                         return false;
00139         }
00140 
00145         bool DeleteCurrent(void)
00146         {
00147                 Node<LIST_TYPE> *pNextNode, *pPrevNode;
00148                 if (m_pActualNode != NULL) {
00149                         pNextNode = m_pActualNode->GetNextNode();
00150                         pPrevNode = m_pActualNode->GetPreviousNode();
00151                         if (pNextNode != NULL)
00152                                 pNextNode->SetPreviousNode(pPrevNode);
00153                         else
00154                                 m_pLastNode = pPrevNode;
00155                         if (pPrevNode != NULL)
00156                                 pPrevNode->SetNextNode(pNextNode);
00157                         else
00158                                 m_pFirstNode = pNextNode;
00159                         m_pActualNode->SetNextNode(NULL);
00160                         delete m_pActualNode;
00161                         m_pActualNode = NULL;
00162                         m_lCount--;
00163                         return true;
00164                 }
00165                 return false;
00166         }
00167 
00173         bool InsertFront(const LIST_TYPE &Element)
00174         {
00175                 Node<LIST_TYPE> *pNode;
00176 
00177                 pNode = new Node<LIST_TYPE>;
00178 
00179                 if (pNode != NULL) {
00180                         pNode->SetNextNode(m_pFirstNode);
00181                         pNode->SetElement(Element);
00182                         if (m_pFirstNode != NULL) 
00183                                 m_pFirstNode->SetPreviousNode(pNode);
00184                         
00185                         if (IsEmpty()) m_pLastNode = pNode;
00186                         
00187                         
00188                         m_pFirstNode = pNode;
00189                         m_lCount++;
00190                         return true;
00191                 } 
00192                 else 
00193                         return false;
00194         }
00195 
00201         bool InsertBack (const LIST_TYPE &Element)
00202         {
00203                 Node<LIST_TYPE> *pNode;
00204 
00205                 pNode = new Node<LIST_TYPE>;
00206 
00207                 if (pNode != NULL) {
00208                         pNode->SetNextNode(NULL);
00209                         pNode->SetPreviousNode(m_pLastNode);
00210                         pNode->SetElement(Element);
00211 
00212                         if (IsEmpty()) {
00213                                 m_pFirstNode = pNode;
00214                                 m_pLastNode = pNode;
00215                         } else {
00216                                 m_pLastNode->SetNextNode(pNode);
00217                                 m_pLastNode = pNode;
00218                         }
00219                         
00220                         m_lCount++;
00221                         return true;
00222                 } 
00223                 else
00224                         return false;
00225         }
00226 
00232         bool ExtractFront(LIST_TYPE &Element)
00233         {
00234                 Node<LIST_TYPE> *pNode;
00235 
00236                 if (!IsEmpty()) {
00237                         Element = m_pFirstNode->GetElement();
00238                         pNode = m_pFirstNode;
00239                         m_pFirstNode = m_pFirstNode->GetNextNode();
00240                         
00241                         if (m_pFirstNode)
00242                                 m_pFirstNode->SetPreviousNode(NULL);
00243 
00244                         pNode->SetNextNode(NULL);
00245 
00246                         delete pNode;
00247 
00248                         m_lCount--;
00249 
00250                         if (IsEmpty()){
00251                                 m_pFirstNode = NULL;
00252                                 m_pLastNode = NULL;
00253                         }
00254                         return true;
00255                 } 
00256                 else
00257                         return false;
00258         }
00259 
00265         bool ExtractBack(LIST_TYPE &Element)
00266         {
00267                 Node<LIST_TYPE>  *pNode;
00268 
00269                 if (!IsEmpty()) {
00270                         Element = m_pLastNode->GetElement();
00271 
00272                         pNode = m_pLastNode->GetPreviousNode();
00273 
00274                         if (pNode != NULL)
00275                                 pNode->SetNextNode(NULL);
00276                         
00277                         delete m_pLastNode;
00278 
00279                         m_lCount--;
00280 
00281                         if (IsEmpty()) {
00282                                 m_pFirstNode = NULL;
00283                                 m_pLastNode = NULL;
00284                         } else
00285                                 m_pLastNode = pNode;
00286 
00287                         return true;
00288                 } else
00289                         return false;
00290         }
00291 
00296         long GetCount()
00297         {
00298                 return m_lCount;
00299         }
00300 
00305         bool IsEmpty()
00306         {
00307                 return (GetCount() == 0);
00308         }
00309 
00313         void Clear()
00314         {
00315                 if (m_pFirstNode != NULL) 
00316                         delete m_pFirstNode;
00317                 m_pFirstNode = NULL;
00318                 m_pLastNode = NULL;
00319                 m_lCount = 0;
00320         }
00321 
00322         
00328         bool GetFirst(LIST_TYPE &Element)
00329         {
00330                 if (m_pFirstNode != NULL) {
00331                         Element = m_pFirstNode->GetElement();
00332                         return true;
00333                 } else 
00334                         return false;
00335         }               
00336 
00342         bool GetCurrent(LIST_TYPE &Element)
00343         {
00344                 if (m_pActualNode != NULL) {
00345                         Element = m_pActualNode->GetElement();
00346                         return true;
00347                 }
00348                 else
00349                         return false;
00350         }
00351 
00357         bool GetLast(LIST_TYPE &Element)
00358         {
00359                 if (m_pLastNode != NULL) {
00360                         Element = m_pLastNode->GetElement();
00361                         return true;
00362                 } else 
00363                         return false;
00364         }
00365 
00369         List()
00370         {
00371                 m_lCount = 0;
00372                 m_pFirstNode = NULL;
00373                 m_pLastNode = NULL;
00374         }
00375 
00379         ~List()
00380         {
00381                 if (m_pFirstNode != NULL) 
00382                         delete m_pFirstNode;
00383         }
00384 
00385 private:
00386         Node<LIST_TYPE> *m_pFirstNode;   // pointer lo first
00387         Node<LIST_TYPE> *m_pLastNode;    // pointer to last
00388         Node<LIST_TYPE> *m_pActualNode; // pointer to actual node
00389         long m_lCount;                                   // Node Count
00390 
00391 };
00392 
00393 } // end namespace
00394 
00395 #endif // _LIST_H_