include/Util.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *    Copyright (C) Lakshya Solutions Ltd. All rights reserved.            *
   4  *                                                                         *
   5  ***************************************************************************/
   6
   7 #ifndef UTIL_H
   8 #define UTIL_H
   9 #include<ErrorType.h>
  10 #include<Debug.h>
  11 enum UniqueIDType {
  12     STMT_ID=0,
  13     TXN_ID
  14 };
  15
  16 enum HashFuncType {
  17     HASH_INT=0,
  18     HASH_BINARY,
  19 };
  20
  21 class DllExport Util
  22 {
  23     public:
  24     static unsigned int hashBinary(char *strVal, int length);
  25     static unsigned int hashString(char *strVal);
  26     static void trimEnd(char *name)
  27     {
  28         while(*name!='\0')
  29         {
  30             if(*name == ' ') { *name='\0'; break;}
  31             name++;
  32         }
  33     }
  34     static void trimRight(char *name)
  35     {
  36         int len = strlen(name);
  37         while(name[len-1] == ' ' && len != 0 )
  38         {
  39              len--;
  40         }
  41         name[len]='\0';
  42     }
  43     static void str_tolower(char *s)
  44     {
  45         while(*s)
  46         {
  47            *s=tolower(*s);
  48            s++;
  49         }
  50     }
  51     static void str_toupper(char *s)
  52     {
  53         while(*s)
  54         {
  55            *s=toupper(*s);
  56            s++;
  57         }
  58     }
  59     static bool isIdentifier(char *name)
  60     {
  61         char *p = name;
  62         if (!isalpha(*p)) return false;
  63         while (*p != '\0') {
  64            if (*p == '_') { p++; continue; }
  65            if (!isalnum(*p)) return false;
  66            p++;
  67         }
  68         return true;
  69     }
  70     inline static void changeWildcardChar(char *src)
  71     {
  72         char *c = (char *)src;
  73         while (*c != '\0') {
  74             if (*c == '_') *c = '?';
  75             else if(*c == '%') *c = '*';
  76             c++;
  77         }
  78         return;
  79     }
  80     inline static void itoa(int n, char s[])
  81     {
  82        int i, sign, j, k ;
  83        if ((sign = n) < 0)  n = -n;
  84        i = 0;
  85        do {
  86           s[i++] = n % 10 + '0';
  87        } while ((n /= 10) > 0);
  88        if (sign < 0)
  89           s[i++] = '-';
  90        s[i] = '\0';
  91        char c;
  92        for (k = 0, j = i-1; k<j; k++, j--) {
  93           c = s[k];
  94           s[k] = s[j];
  95           s[j] = c;
  96        }
  97     }
  98 };
  99
 100 class ListNode
 101 {
 102     public:
 103     void *element;
 104     ListNode *next;
 105
 106 };
 107
 108 class DllExport ListIterator
 109 {
 110     ListNode *iter;
 111     ListNode *start;
 112     public:
 113     ListIterator(){}
 114
 115     ListIterator(ListNode *head) { iter = head; start = head; }
 116
 117     bool hasElement()
 118     {
 119         if (iter == NULL) return false; else return true;
 120     }
 121
 122     void reset()
 123     {
 124         iter = start;
 125     }
 126     //isRemove ->the node needs to deleted after returning
 127     void* nextElement(bool isRemove = false)
 128     {
 129         if (iter == NULL) return NULL;
 130         ListNode *node = iter;
 131         iter = iter ->next;
 132         return node->element;
 133     }
 134     void* nextElementInQueue()
 135     {
 136         ListNode *node = iter;
 137         if(iter->next) {
 138             iter = iter ->next;
 139             return node->element;
 140         } else return NULL;
 141     }
 142     void *getCurrentListNode(){ return iter; }
 143     //index start with one, such that 1->first element in list
 144     void* getElement(int index)
 145     {
 146         ListNode *localIter = start;
 147         if (localIter == NULL) return NULL;
 148         for (int i=0; i <index; i++) {
 149            localIter = localIter->next;
 150            if (localIter == NULL) break;
 151         }
 152         return localIter->element;
 153     }
 154 };
 155
 156 class Identifier
 157 {
 158     public:
 159     char name[IDENTIFIER_LENGTH];
 160 };
 161
 162 class DllExport List
 163 {
 164     ListNode *head;
 165     int totalElements;
 166     public:
 167     List() { head = NULL; totalElements = 0;}
 168     List(ListNode *hd) { head = hd; } //Use only for free in metadata
 169     DbRetVal append(void *elem)
 170     {
 171         ListNode *newNode = new ListNode();
 172         newNode->element = elem;
 173         newNode->next = NULL;
 174         totalElements++;
 175         //If this is the first node, set it as head
 176         if (NULL == head) { head = newNode; return OK; }
 177
 178         ListNode *iter = head;
 179         while (NULL != iter->next) iter = iter->next;
 180         iter->next = newNode;
 181         return OK;
 182     }
 183     //Warning:Try to avoid using this method while using the iterator.The behavior
 184     //is undefined. Instead set flag isRemove to yes and call nextElement of iterator.
 185     DbRetVal remove(void *elem, bool err=true)
 186     {
 187         if (NULL == head)
 188         {
 189             if (err)
 190                printError(ErrNotExists, "There are no elements in the list. Empty list");
 191             return ErrNotExists;
 192         }
 193         ListNode *iter = head, *prev = head;
 194         while (iter != NULL)
 195         {
 196             if (elem == iter->element)
 197             {
 198                 if (iter == head) {
 199                     head = iter->next;
 200                     delete iter;
 201                     totalElements--;
 202                     return OK;
 203                 }
 204                 prev->next = iter->next;
 205                 delete iter;
 206                 totalElements--;
 207                 return OK;
 208             }
 209             prev = iter;
 210             iter = iter->next;
 211         }
 212         if (err)
 213             printError(ErrNotFound, "There are no elements in the list");
 214         return ErrNotFound;
 215     }
 216
 217     //index start with one, such that 1->first element in list
 218     void* get(int index)
 219     {
 220         ListNode *localIter = head;
 221         if (localIter == NULL) return NULL;
 222         for (int i=0; i <index -1; i++) {
 223            localIter = localIter->next;
 224            if (localIter == NULL) break;
 225         }
 226         return localIter->element;
 227     }
 228
 229
 230     bool exists(void *elem)
 231     {
 232         ListNode *iter = head;
 233         while (iter != NULL)
 234         {
 235             if (elem == iter->element)
 236             {
 237                 return true;
 238             }
 239             iter = iter->next;
 240         }
 241         return false;
 242     }
 243
 244     ListIterator getIterator()
 245     {
 246         ListIterator iter(head);
 247         return iter;
 248     }
 249     void reset()
 250     {
 251         if (NULL == head) return;
 252         ListNode *iter = head, *prevIter = head;
 253         while (iter->next != NULL)
 254         {
 255             prevIter = iter;
 256             iter = iter->next;
 257             delete prevIter;
 258
 259         }
 260         delete iter;
 261         head = NULL;
 262         totalElements = 0;
 263         return;
 264     }
 265     void init() { head = NULL; totalElements=0;}
 266
 267     DbRetVal addAtMiddle(void *elem, void *prevIter)
 268     {
 269         ListNode *newNode = new ListNode();
 270         newNode->element = elem;
 271         totalElements++;
 272         newNode->next =((ListNode *)prevIter)->next;
 273         ((ListNode *)prevIter)->next = newNode;
 274         return OK;
 275     }
 276     DbRetVal addAtBegin(void *elem)
 277     {
 278         ListNode *newNode = new ListNode();
 279         newNode->element = elem;
 280         totalElements++;
 281         newNode->next = head;
 282         head = newNode;
 283         return OK;
 284     }
 285     int size()
 286     {
 287         return totalElements;
 288     }
 289
 290 };
 291 #define MAX_UNIQUE_ID 10
 292 class DllExport GlobalUniqueID
 293 {
 294    void *ptr;
 295    public:
 296    GlobalUniqueID() { ptr = NULL; }
 297    DbRetVal create();
 298    DbRetVal open();
 299    DbRetVal close() { os::shm_detach(ptr); ptr = NULL; return OK; }
 300    DbRetVal destroy();
 301    int getID(UniqueIDType type);
 302 };
 303
 304 class DllExport UniqueID
 305 {
 306    int startID;
 307    Mutex mutex;
 308    public:
 309    UniqueID() { startID = 1; mutex.init(); }
 310
 311
 312    void setID(int id)
 313    {
 314         startID = id;mutex.init();
 315    }
 316
 317
 318    int getID()
 319    {
 320       //TODO::change mutex to atomic increment instruction
 321       if (mutex.getLock(-1, false) != 0) return 0;
 322       startID++;
 323       mutex.releaseLock(-1, false);
 324       return startID;
 325    }
 326 };
 327
 328 #endif