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     public:
  33     ListIterator(){}
  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, bool err=true)
  98     {
  99         if (NULL == head)
 100         {
 101             if (err)
 102                printError(ErrNotExists, "There are no elements in the list. Empty list");
 103             return ErrNotExists;
 104         }
 105         ListNode *iter = head, *prev = head;
 106         while (iter != NULL)
 107         {
 108             if (elem == iter->element)
 109             {
 110                 if (iter == head) { head = iter->next; delete iter; return OK;}
 111                 prev->next = iter->next;
 112                 delete iter;
 113                 totalElements--;
 114                 return OK;
 115             }
 116             prev = iter;
 117             iter = iter->next;
 118         }
 119         if (err)
 120             printError(ErrNotFound, "There are no elements in the list");
 121         return ErrNotFound;
 122     }
 123
 124     //index start with one, such that 1->first element in list
 125     void* get(int index)
 126     {
 127         ListNode *localIter = head;
 128         if (localIter == NULL) return NULL;
 129         for (int i=0; i <index -1; i++) {
 130            localIter = localIter->next;
 131            if (localIter == NULL) break;
 132         }
 133         return localIter->element;
 134     }
 135
 136
 137     bool exists(void *elem)
 138     {
 139         ListNode *iter = head;
 140         while (iter != NULL)
 141         {
 142             if (elem == iter->element)
 143             {
 144                 return true;
 145             }
 146             iter = iter->next;
 147         }
 148         return false;
 149     }
 150
 151     ListIterator getIterator()
 152     {
 153         ListIterator iter(head);
 154         return iter;
 155     }
 156     void reset()
 157     {
 158         if (NULL == head) return;
 159         ListNode *iter = head, *prevIter = head;
 160         while (iter->next != NULL)
 161         {
 162             prevIter = iter;
 163             iter = iter->next;
 164             delete prevIter;
 165
 166         }
 167         delete iter;
 168         head = NULL;
 169         totalElements = 0;
 170         return;
 171     }
 172     int size()
 173     {
 174         return totalElements;
 175     }
 176
 177 };
 178 class UniqueID
 179 {
 180    int startID;
 181    Mutex mutex;
 182    public:
 183    UniqueID() { startID = 1; mutex.init(); }
 184
 185
 186    void setID(int id)
 187    {
 188         startID = id;mutex.init();
 189    }
 190
 191
 192    int getID()
 193    {
 194       //TODO::change mutex to atomic increment instruction
 195       if (mutex.getLock(-1, false) != 0) return 0;
 196       startID++;
 197       mutex.releaseLock(-1, false);
 198       return startID;
 199    }
 200 };
 201
 202 #endif