gameserv/list.h

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