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