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     //index start with one, such that 1->first element in list
  56     void* getElement(int index)
  57     {
  58         ListNode *localIter = start;
  59         if (localIter == NULL) return NULL;
  60         for (int i=0; i <index; i++) {
  61            localIter = localIter->next;
  62            if (localIter == NULL) break;
  63         }
  64         return localIter->element;
  65     }
  66 };
  67
  68 class Identifier
  69 {
  70     public:
  71     char name[IDENTIFIER_LENGTH];
  72 };
  73
  74 class List
  75 {
  76     ListNode *head;
  77     int totalElements;
  78     public:
  79     List() { head = NULL; totalElements = 0;}
  80
  81     DbRetVal append(void *elem)
  82     {
  83         ListNode *newNode = new ListNode();
  84         newNode->element = elem;
  85         newNode->next = NULL;
  86         totalElements++;
  87         //If this is the first node, set it as head
  88         if (NULL == head) { head = newNode; return OK; }
  89
  90         ListNode *iter = head;
  91         while (NULL != iter->next) iter = iter->next;
  92         iter->next = newNode;
  93         return OK;
  94     }
  95     //Warning:Try to avoid using this method while using the iterator.The behavior
  96     //is undefined. Instead set flag isRemove to yes and call nextElement of iterator.
  97     DbRetVal remove(void *elem)
  98     {
  99         if (NULL == head)
 100         {
 101             printError(ErrNotExists, "There are no elements in the list. Empty list");
 102             return ErrNotExists;
 103         }
 104         ListNode *iter = head, *prev = head;
 105         while (iter != NULL)
 106         {
 107             if (elem == iter->element)
 108             {
 109                 prev->next = iter->next;
 110                 delete iter;
 111                 totalElements--;
 112                 if (iter == head) { head = NULL; return OK;}
 113                 return OK;
 114             }
 115             prev = iter;
 116             iter = iter->next;
 117         }
 118         printError(ErrNotFound, "There are no elements in the list");
 119         return ErrNotFound;
 120     }
 121
 122     //index start with one, such that 1->first element in list
 123     void* get(int index)
 124     {
 125         ListNode *localIter = head;
 126         if (localIter == NULL) return NULL;
 127         for (int i=0; i <index -1; i++) {
 128            localIter = localIter->next;
 129            if (localIter == NULL) break;
 130         }
 131         return localIter->element;
 132     }
 133
 134
 135     bool exists(void *elem)
 136     {
 137         ListNode *iter = head;
 138         while (iter != NULL)
 139         {
 140             if (elem == iter->element)
 141             {
 142                 return true;
 143             }
 144             iter = iter->next;
 145         }
 146         return false;
 147     }
 148
 149     ListIterator getIterator()
 150     {
 151         ListIterator iter(head);
 152         return iter;
 153     }
 154     void reset()
 155     {
 156         if (NULL == head) return;
 157         ListNode *iter = head, *prevIter = head;
 158         while (iter->next != NULL)
 159         {
 160             prevIter = iter;
 161             iter = iter->next;
 162             delete prevIter;
 163
 164         }
 165         delete iter;
 166         head = NULL;
 167         totalElements = 0;
 168         return;
 169     }
 170     int size()
 171     {
 172         return totalElements;
 173     }
 174
 175 };
 176 class UniqueID
 177 {
 178    int startID;
 179    Mutex mutex;
 180    public:
 181    UniqueID() { startID = 1; mutex.init(); }
 182    int getID()
 183    {
 184       if (mutex.getLock(-1, false) != 0) return 0;
 185       startID++;
 186       mutex.releaseLock(-1, false);
 187       return startID;
 188    }
 189 };
 190
 191 #endif