include/Util.h

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.com   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #ifndef UTIL_H
  17 #define UTIL_H
  18 #include<ErrorType.h>
  19 #include<Debug.h>
  20 class ListNode
  21 {
  22     public:
  23     void *element;
  24     ListNode *next;
  25
  26 };
  27
  28 class ListIterator
  29 {
  30     ListNode *iter;
  31     ListNode *start;
  32     ListIterator();
  33     public:
  34
  35     ListIterator(ListNode *head) { iter = head; start = head; }
  36
  37     bool hasElement()
  38     {
  39         if (iter == NULL) return false; else return true;
  40     }
  41
  42     void reset()
  43     {
  44         iter = start;
  45     }
  46     //isRemove ->the node needs to deleted after returning
  47     void* nextElement(bool isRemove = false)
  48     {
  49         if (iter == NULL) return NULL;
  50         ListNode *node = iter;
  51         iter = iter ->next;
  52         return node->element;
  53     }
  54 };
  55
  56
  57 class List
  58 {
  59     ListNode *head;
  60     public:
  61     List() { head = NULL;}
  62
  63     DbRetVal append(void *elem)
  64     {
  65         ListNode *newNode = new ListNode();
  66         newNode->element = elem;
  67         newNode->next = NULL;
  68         //If this is the first node, set it as head
  69         if (NULL == head) { head = newNode; return OK; }
  70
  71         ListNode *iter = head;
  72         while (NULL != iter->next) iter = iter->next;
  73         iter->next = newNode;
  74         return OK;
  75     }
  76     //Warning:Try to avoid using this method while using the iterator.The behavior
  77     //is undefined. Instead set flag isRemove to yes and call nextElement of iterator.
  78     DbRetVal remove(void *elem)
  79     {
  80         if (NULL == head)
  81         {
  82             printError(ErrNotExists, "There are no elements in the list. Empty list");
  83             return ErrNotExists;
  84         }
  85         ListNode *iter = head, *prev = head;
  86         while (iter->next != NULL)
  87         {
  88             if (elem == iter->element)
  89             {
  90                 prev->next = iter->next;
  91                 delete iter;
  92             }
  93             prev = iter;
  94             iter = iter->next;
  95         }
  96         if( iter == head) // there is only one node in the list
  97         {
  98             if (elem == iter->element)
  99             {
 100                 delete head;
 101                 head = NULL;
 102                 return OK;
 103             }
 104
 105         }
 106         if( prev == head) // there are only two node in the list
 107         {
 108             if (elem == iter->element)
 109             {
 110                 head->next = NULL;
 111                 delete iter;
 112                 return OK;
 113             }
 114         }
 115         printError(ErrNotFound, "There are no elements in the list");
 116         return ErrNotFound;
 117     }
 118
 119     ListIterator getIterator()
 120     {
 121         ListIterator iter(head);
 122         return iter;
 123     }
 124     void reset()
 125     {
 126         if (NULL == head) return;
 127         ListNode *iter = head, *prevIter = head;
 128         while (iter->next != NULL)
 129         {
 130             prevIter = iter;
 131             iter = iter->next;
 132             delete prevIter;
 133
 134         }
 135         delete iter;
 136         head = NULL;
 137         return;
 138     }
 139     int size()
 140     {
 141         int count =1;
 142         if (NULL == head) return 0;
 143         ListNode *iter = head;
 144         while (iter->next != NULL)
 145         {
 146             count++;
 147             iter = iter->next;
 148         }
 149         return count;
 150     }
 151
 152 };
 153 #endif