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 "options.h"
   9
  10 using std::cout;
  11 using std::endl;
  12 using std::flush;
  13
  14 template <class T>
  15 class List {
  16     public:
  17         List();         //constructor
  18         ~List();        //deconstructor
  19         T *insertAtFront( const T & );
  20         T *insertAtBack( T *&);
  21         T *random(); // Returns a random element in the list
  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         int elements; // Number of elements in the list
  37     private:
  38         ListNode < T > *firstPtr;
  39         ListNode < T > *lastPtr;
  40
  41         ListNode < T > *getNewNode ( const T &  );
  42         ListNode < T > *getNewNode ( T &  );
  43 };
  44
  45 template <class T>
  46 List<T>::List() : firstPtr (0), lastPtr (0) {elements = 0;}
  47
  48 template <class T>
  49 void List<T>::deleteNodes()
  50 {
  51     if (isEmpty())
  52         return;
  53     ListNode<T> *it = firstPtr, *tempPtr;
  54     while (it)
  55     {
  56         tempPtr = it;
  57         it = it->Next();
  58         delete tempPtr;
  59     }
  60     firstPtr = NULL;
  61     lastPtr = NULL;
  62     elements = 0;
  63 }
  64
  65 template <class T>
  66 List<T>::~List()
  67 {
  68     deleteNodes();
  69 }
  70
  71 template<class T>
  72 T *List<T>::random()
  73 {
  74     if (isEmpty())
  75         return NULL;
  76
  77     int num = rand() % elements;
  78     ListNode<T> *it = firstPtr;
  79     for (int x = 0; x < num; x++)
  80     {
  81         it = it->Next();
  82     }
  83     return it->getData();
  84 }
  85
  86 template<class T>
  87 T *List<T>::insertAtFront( const T &value )
  88 {
  89     ListNode<T> *newPtr = getNewNode ( value );
  90
  91
  92     if (isEmpty())
  93         firstPtr = lastPtr = newPtr;
  94     else
  95     {
  96         newPtr->Next = firstPtr;
  97         firstPtr->prev = newPtr;
  98         firstPtr = newPtr;
  99     }
 100     elements++;
 101     return firstPtr->getData();
 102 }
 103
 104 template<class T>
 105 T *List<T>::insertAtBack(T *&value )
 106 {
 107     ListNode<T> *newPtr = getNewNode(*value);
 108
 109     if (isEmpty())
 110     {
 111         firstPtr = lastPtr = newPtr;
 112     }
 113     else
 114     {
 115         newPtr->prev = lastPtr;
 116         lastPtr->next = newPtr;
 117         lastPtr = newPtr;
 118     }
 119     elements++;
 120     return lastPtr->getData();
 121 }
 122
 123 template<class T>
 124 ListNode<T> *List<T>::insertAtBack_RLN(T *&value )
 125 {
 126     ListNode<T> *newPtr = getNewNode(*value);
 127
 128     if (isEmpty())
 129     {
 130         firstPtr = lastPtr = newPtr;
 131     }
 132     else
 133     {
 134         newPtr->prev = lastPtr;
 135         lastPtr->next = newPtr;
 136         lastPtr = newPtr;
 137     }
 138     elements++;
 139     return lastPtr;
 140 }
 141
 142
 143 template <class T>
 144 bool List<T>::removeFromFront( T &value )
 145 {
 146     if ( isEmpty())
 147         return false;
 148     else
 149     {
 150         ListNode<T> *tempPtr = firstPtr;
 151
 152         if ( firstPtr == lastPtr )
 153             firstPtr = lastPtr = 0;
 154         else
 155             firstPtr = firstPtr->next;
 156
 157         value = tempPtr->getData();
 158         delete tempPtr;
 159         elements--;
 160         return true;
 161     }
 162 }
 163
 164 template <class T>
 165 bool List<T>::removeFromBack( T &value )
 166 {
 167     if ( isEmpty() )
 168         return false;
 169     else
 170     {
 171         ListNode<T> *tempPtr = lastPtr;
 172
 173         if ( firstPtr == lastPtr )
 174             lastPtr = firstPtr = 0;
 175         else
 176             lastPtr = lastPtr->prev;
 177
 178         value = tempPtr->getData();
 179         delete tempPtr;
 180         elements--;
 181         return true;
 182     }
 183 }
 184
 185 template <class T>
 186 bool List<T>::isEmpty() const
 187    { return firstPtr == 0 && lastPtr == 0; }
 188
 189 template <class T>
 190 ListNode<T> *List<T>::getNewNode( const T &value)
 191 {
 192     ListNode<T> *ptr = new ListNode<T>(value);
 193
 194     assert( ptr != 0);
 195
 196     return ptr;
 197 }
 198
 199 template <class T>
 200 ListNode<T> *List<T>::getNewNode( T &value)
 201 {
 202     ListNode<T> *ptr = new ListNode<T>(value);
 203
 204     assert( ptr != 0);
 205
 206     return ptr;
 207 }
 208
 209 template<class T>
 210 ListNode<T> *List<T>::Find( T *value )
 211 {
 212     if (isEmpty()) {return NULL;}
 213
 214     ListNode<T> *currentPtr;
 215     currentPtr = firstPtr;
 216     while (currentPtr)
 217     {
 218         cout << currentPtr->getData() << endl << value << endl;
 219         if (currentPtr->getData() == value)
 220             return currentPtr;
 221         currentPtr = currentPtr->Next();
 222     }
 223     return NULL;
 224 }
 225
 226 #ifdef DEBUGMODE
 227 template <class T>
 228 void List<T>::print() const
 229 {
 230     if (isEmpty())
 231     {
 232         cout << "Empty list" << endl;
 233         return;
 234     }
 235
 236     ListNode<T> *currentPtr;
 237     currentPtr = firstPtr;
 238     while (currentPtr)
 239     {
 240         /*
 241         cout << "aClient: " << *currentPtr->getData() << flush;
 242
 243         if (currentPtr->getData()->stats)
 244             cout << "  Player Name: " << currentPtr->getData()->stats->name
 245                  << "   Password: " << currentPtr->getData()->stats->password << flush;
 246         cout << endl;
 247         */
 248         /*
 249         cout << currentPtr->getData()->getString() << endl;
 250         currentPtr = currentPtr->next;
 251         */
 252         T *dat;
 253         dat = currentPtr->getData();
 254         log("name: %s", dat->name);
 255         log("weapon: %s", dat->weapon);
 256         log("death: %s", dat->death);
 257         log("strength: %d", dat->strength);
 258         log("exp: %ld", dat->exp);
 259         log("gold: %ld", dat->gold);
 260         log("maxhp: %d", dat->maxhp);
 261         log("hp: %d", dat->hp);
 262         currentPtr = currentPtr->next;
 263     }
 264 }
 265 #endif
 266
 267 template <class T>
 268 bool List<T>::del(T *remPtr)
 269 {
 270     ListNode<T> *removed = remove( remPtr );
 271     if (removed != NULL)
 272     {
 273         delete removed;
 274         return true;
 275     }
 276     return false;
 277 }
 278
 279 template <class T>
 280 ListNode<T> *List<T>::remove(T *remPtr)
 281 {
 282     ListNode<T> *newPtr = firstPtr;
 283     T *testPtr;
 284
 285     if (isEmpty())
 286         return false;
 287
 288     while (newPtr)
 289     {
 290         testPtr = newPtr->getData();
 291         if (testPtr == remPtr)
 292         {
 293             if (firstPtr == lastPtr)
 294             {
 295                 #ifdef DEBUGMODE
 296                     log("One Element. Deleting it");
 297                 #endif
 298                 firstPtr = lastPtr = NULL;
 299                 return newPtr;
 300             }
 301             else if (newPtr != lastPtr && newPtr != firstPtr)
 302             {
 303                 #ifdef DEBUGMODE
 304                     log("Many elements, this one is in the middle. Deleting it, linking front to back, and back to front.");
 305                 #endif
 306                 newPtr->prev->next = newPtr->next;
 307                 newPtr->next->prev = newPtr->prev;
 308                 return newPtr;
 309             }
 310             else if (newPtr == lastPtr)
 311             {
 312                 #ifdef DEBUGMODE
 313                     log("This was the last element. Deleting it, and pointing the tail to its previous element.");
 314                 #endif
 315                 lastPtr = newPtr->prev;
 316                 lastPtr->next = 0;
 317                 return newPtr;
 318             }
 319             else if (newPtr == firstPtr)
 320             {
 321                 #ifdef DEBUGMODE
 322                     log("This was the first element. Deleting it, and pointing the head to its next element.");
 323                 #endif
 324                 firstPtr = newPtr->next;
 325                 firstPtr->prev = 0;
 326                 return newPtr;
 327             }
 328             elements--;
 329         }
 330         newPtr = newPtr->next;
 331     }
 332     return NULL;
 333 }
 334 #endif