Repair/RepairCompiler/MCC/Runtime/SimpleHash.h

   1 #ifndef SIMPLEHASH_H
   2 #define SIMPLEHASH_H
   3
   4 /* LinkedHashNode *****************************************************/
   5
   6 class LinkedHashNode {
   7
   8 public:
   9     LinkedHashNode *next;
  10     LinkedHashNode *lnext,*lprev;
  11     int data;
  12     int key;
  13
  14
  15     LinkedHashNode(int key, int data, LinkedHashNode *next);
  16     LinkedHashNode();
  17
  18 };
  19
  20 /* SimpleList *********************************************************/
  21
  22 class SimpleList {
  23 private:
  24     LinkedHashNode head;
  25     LinkedHashNode *ptr;
  26 public:
  27     SimpleList();
  28     void add(int data);
  29     int contains(int data);
  30     void reset();
  31     int hasMoreElements();
  32     int nextElement();
  33 };
  34
  35
  36 /* WorkList *********************************************************/
  37 #define WLISTSIZE 4*100
  38
  39 class WorkList {
  40 private:
  41   struct ListNode *head;
  42   struct ListNode *tail;
  43   int headoffset;
  44   int tailoffset;
  45
  46 public:
  47     WorkList();
  48     ~WorkList();
  49     void add(int id, int type, int lvalue, int rvalue);
  50     int hasMoreElements();
  51     int getid();
  52     int gettype();
  53     int getlvalue();
  54     int getrvalue();
  55     void pop();
  56 };
  57
  58 struct ListNode {
  59   int data[WLISTSIZE];
  60   ListNode *next;
  61 };
  62 /* SimpleHash *********************************************************/
  63 class SimpleIterator;
  64
  65 class SimpleHash {
  66 private:
  67     int numelements;
  68     int size;
  69     struct SimpleNode **bucket;
  70     struct ArraySimple *listhead;
  71     struct ArraySimple *listtail;
  72
  73
  74     int numparents;
  75     int numchildren;
  76     SimpleHash* parents[10];
  77     SimpleHash* children[10];
  78     void addChild(SimpleHash* child);
  79 public:
  80     int tailindex;
  81     SimpleHash(int size=100);
  82     ~SimpleHash();
  83     int add(int key, int data);
  84     int remove(int key, int data);
  85     bool contains(int key);
  86     bool contains(int key, int data);
  87     int get(int key, int& data);
  88     int countdata(int data);
  89     void addParent(SimpleHash* parent);
  90     int firstkey();
  91     SimpleIterator* iterator();
  92     void iterator(SimpleIterator & it);
  93     inline int count() {
  94         return numelements;
  95     }
  96     int count(int key);
  97
  98 };
  99
 100 /* SimpleHashExcepion  *************************************************/
 101
 102
 103 /* SimpleIterator *****************************************************/
 104 #define ARRAYSIZE 100
 105
 106 struct SimpleNode {
 107   struct SimpleNode *next;
 108   int data;
 109   int key;
 110   int inuse;
 111 };
 112
 113 struct ArraySimple {
 114   struct SimpleNode nodes[ARRAYSIZE];
 115   struct ArraySimple * nextarray;
 116 };
 117
 118
 119 class SimpleIterator {
 120  public:
 121
 122   struct ArraySimple *cur;
 123   int index;
 124   SimpleHash * table;
 125   inline SimpleIterator() {}
 126
 127   inline SimpleIterator(struct ArraySimple *start, SimpleHash *t) {
 128     cur = start;
 129     table=t;
 130     index=0;
 131   }
 132
 133   inline int hasNext() {
 134     while((index==ARRAYSIZE)||!cur->nodes[index].inuse) {
 135       if (cur->nextarray==0 &&
 136           index==table->tailindex)
 137         return 0;
 138       index++;
 139       if (index==ARRAYSIZE) {
 140         index=0;
 141         cur=cur->nextarray;
 142       }
 143     }
 144     if (cur->nodes[index].inuse)
 145       return 1;
 146     else
 147       return 0;
 148   }
 149
 150   inline int next() {
 151     return cur->nodes[index++].data;
 152   }
 153
 154   inline int key() {
 155     return cur->nodes[index].key;
 156   }
 157 };
 158
 159 /* SimpleHashExcepion  *************************************************/
 160
 161 class SimpleHashException {
 162 public:
 163     SimpleHashException();
 164 };
 165
 166 class RepairHashNode {
 167  public:
 168     RepairHashNode *next;
 169     RepairHashNode *lnext;
 170     int data;
 171     int setrelation;
 172     int lvalue;
 173     int rvalue;
 174     int rule;
 175     RepairHashNode(int setrelation, int rule, int lvalue, int rvalue, int data);
 176 };
 177
 178 class RepairHash {
 179
 180 private:
 181     int numelements;
 182     int size;
 183     RepairHashNode **bucket;
 184     RepairHashNode *nodelist;
 185
 186 public:
 187     RepairHash();
 188     RepairHash(int size);
 189     ~RepairHash();
 190     int addset(int setv, int rule, int value, int data);
 191     int addrelation(int relation, int rule, int lvalue, int rvalue, int data);
 192     bool containsset(int setv, int rule, int value);
 193     bool containsrelation(int relation, int rule, int lvalue, int rvalue);
 194     int getset(int setv, int rule, int value);
 195     int getrelation(int relation, int rule, int lvalue, int rvalue);
 196 };
 197
 198 #endif
 199