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