gameserv/list.h

   1 #ifndef LIST_H
   2 #define LIST_H
   3
   4 #include <iostream.h>
   5 #include <cassert>
   6 #include "listnode.h"
   7 #include "aClient.h"
   8 #include "extern.h"
   9
  10 template <class T>
  11 class List {
  12     public:
  13         List();         //constructor
  14         ~List();        //deconstructor
  15         void insertAtFront( const T & );
  16         void insertAtBack( T *&);
  17         bool removeFromFront( T & );
  18         bool removeFromBack( T & );
  19         bool remove( T * );
  20         bool isEmpty() const;
  21         void print() const;
  22         ListNode < T > *Find( T * );
  23         ListNode < T > *First() { return firstPtr; };
  24         ListNode < T > *Last() { return lastPtr; };
  25     private:
  26         ListNode < T > *firstPtr;
  27         ListNode < T > *lastPtr;
  28
  29         ListNode < T > *getNewNode ( const T &  );
  30 };
  31
  32 template <class T>
  33 List<T>::List() : firstPtr (0), lastPtr (0) {}
  34
  35 template <class T>
  36 List<T>::~List()
  37 {
  38     if (!isEmpty())
  39     {
  40         #ifdef DEBUGMODE
  41             log("Destroying Nodes");
  42         #endif
  43
  44         ListNode<T> *currentPtr = firstPtr, *tempPtr;
  45
  46         while (currentPtr)
  47         {
  48             tempPtr = currentPtr;
  49             currentPtr = currentPtr->Next();
  50
  51             #ifdef DEBUGMODE
  52                 log("Deleting Memory address: %s", tempPtr->getData());
  53             #endif
  54
  55                 delete tempPtr;
  56         }
  57         #ifdef DEBUGMODE
  58             log("All Nodes destroyed");
  59         #endif
  60     }
  61 }
  62
  63 template<class T>
  64 void List<T>::insertAtFront( const T &value )
  65 {
  66     ListNode<T> *newPtr = getNewNode ( value );
  67
  68
  69     if (isEmpty())
  70         firstPtr = lastPtr = newPtr;
  71     else
  72     {
  73         newPtr->Next = firstPtr;
  74         firstPtr->prev = newPtr;
  75         firstPtr = newPtr;
  76     }
  77 }
  78
  79 template<class T>
  80 void List<T>::insertAtBack(T *&value )
  81 {
  82     ListNode<T> *newPtr = getNewNode(*value);
  83
  84     if (isEmpty())
  85     {
  86         firstPtr = lastPtr = newPtr;
  87     }
  88     else
  89     {
  90         newPtr->prev = lastPtr;
  91         lastPtr->next = newPtr;
  92         lastPtr = newPtr;
  93     }
  94 }
  95
  96
  97 template <class T>
  98 bool List<T>::removeFromFront( T &value )
  99 {
 100     if ( isEmpty())
 101         return false;
 102     else
 103     {
 104         ListNode<T> *tempPtr = firstPtr;
 105
 106         if ( firstPtr == lastPtr )
 107             firstPtr = lastPtr = 0;
 108         else
 109             firstPtr = firstPtr->next;
 110
 111         value = tempPtr->getData();
 112         delete tempPtr;
 113         return true;
 114     }
 115 }
 116
 117 template <class T>
 118 bool List<T>::removeFromBack( T &value )
 119 {
 120     if ( isEmpty() )
 121         return false;
 122     else
 123     {
 124         ListNode<T> *tempPtr = lastPtr;
 125
 126         if ( firstPtr == lastPtr )
 127             lastPtr = firstPtr = 0;
 128         else
 129             lastPtr = lastPtr->prev;
 130
 131         value = tempPtr->getData();
 132         delete tempPtr;
 133         return true;
 134
 135     }
 136 }
 137
 138 template <class T>
 139 bool List<T>::isEmpty() const
 140    { return firstPtr == 0 && lastPtr == 0; }
 141
 142 template <class T>
 143 ListNode<T> *List<T>::getNewNode( const T &value)
 144 {
 145     ListNode<T> *ptr = new ListNode<T>(value);
 146
 147     assert( ptr != 0);
 148
 149     return ptr;
 150 }
 151 template<class T>
 152 ListNode<T> *List<T>::Find( T *value )
 153 {
 154     if (isEmpty()) {return NULL;}
 155
 156     ListNode<T> *currentPtr;
 157     currentPtr = firstPtr;
 158     while (currentPtr)
 159     {
 160         if (currentPtr->getData() == value)
 161             return currentPtr;
 162         currentPtr = currentPtr->Next();
 163     }
 164     return NULL;
 165 }
 166
 167 #ifdef DEBUGMODE
 168 template <class T>
 169 void List<T>::print() const
 170 {
 171     if (isEmpty())
 172     {
 173         cout << "Empty list" << endl;
 174         return;
 175     }
 176
 177     ListNode<T> *currentPtr;
 178     currentPtr = firstPtr;
 179     while (currentPtr)
 180     {
 181         cout << "aClient: " << *currentPtr->getData() << flush;
 182
 183         if (currentPtr->getData()->stats)
 184             cout << "  Player Name: " << currentPtr->getData()->stats->name
 185                  << "   Password: " << currentPtr->getData()->stats->password << flush;
 186         cout << endl;
 187         currentPtr = currentPtr->next;
 188     }
 189
 190 }
 191 #endif
 192
 193 template <class T>
 194 bool List<T>::remove(T *remPtr)
 195 {
 196     ListNode<T> *newPtr = firstPtr;
 197     T *testPtr;
 198
 199     if (isEmpty())
 200         return false;
 201
 202     while (newPtr)
 203     {
 204         testPtr = newPtr->getData();
 205         if (testPtr == remPtr)
 206         {
 207             if (firstPtr == lastPtr)
 208             {
 209                 #ifdef DEBUGMODE
 210                     log("One Element. Deleting it");
 211                 #endif
 212                 firstPtr = lastPtr = NULL;
 213                 delete newPtr;
 214                 return true;
 215             }
 216             else if (newPtr != lastPtr && newPtr != firstPtr)
 217             {
 218                 #ifdef DEBUGMODE
 219                     log("Many elements, this one is in the middle. Deleting it, linking front to back, and back to front.");
 220                 #endif
 221                 newPtr->prev->next = newPtr->next;
 222                 newPtr->next->prev = newPtr->prev;
 223                 delete newPtr;
 224                 return true;
 225             }
 226             else if (newPtr == lastPtr)
 227             {
 228                 #ifdef DEBUGMODE
 229                     log("This was the last element. Deleting it, and pointing the tail to its previous element.");
 230                 #endif
 231                 lastPtr = newPtr->prev;
 232                 lastPtr->next = 0;
 233                 delete newPtr;
 234                 return true;
 235             }
 236             else if (newPtr == firstPtr)
 237             {
 238                 #ifdef DEBUGMODE
 239                     log("This was the first element. Deleting it, and pointing the head to its next element.");
 240                 #endif
 241                 firstPtr = newPtr->next;
 242                 firstPtr->prev = 0;
 243                 delete newPtr;
 244                 return true;
 245             }
 246         }
 247         newPtr = newPtr->next;
 248     }
 249     return false;
 250 }
 251 #endif