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, *tail;
 123   int index,tailindex;
 124   //  SimpleHash * table;
 125   inline SimpleIterator() {}
 126
 127   inline SimpleIterator(struct ArraySimple *start, struct ArraySimple *tl, int tlindex/*, SimpleHash *t*/) {
 128     cur = start;
 129     //    table=t;
 130     index=0;
 131     tailindex=tlindex;
 132     tail=tl;
 133   }
 134
 135   inline int hasNext() {
 136     if (cur==tail &&
 137         index==tailindex)
 138       return 0;
 139     while((index==ARRAYSIZE)||!cur->nodes[index].inuse) {
 140       if (index==ARRAYSIZE) {
 141         index=0;
 142         cur=cur->nextarray;
 143       } else
 144         index++;
 145     }
 146     if (cur->nodes[index].inuse)
 147       return 1;
 148     else
 149       return 0;
 150   }
 151
 152   inline int next() {
 153     return cur->nodes[index++].data;
 154   }
 155
 156   inline int key() {
 157     return cur->nodes[index].key;
 158   }
 159 };
 160
 161 /* SimpleHashExcepion  *************************************************/
 162
 163 class SimpleHashException {
 164 public:
 165     SimpleHashException();
 166 };
 167
 168 class RepairHashNode {
 169  public:
 170     RepairHashNode *next;
 171     RepairHashNode *lnext;
 172     int data;
 173     int data2;
 174     int setrelation;
 175     int lvalue;
 176     int rvalue;
 177     int rule;
 178     RepairHashNode(int setrelation, int rule, int lvalue, int rvalue, int data, int data2);
 179 };
 180
 181 class RepairHash {
 182
 183 private:
 184     int numelements;
 185     int size;
 186     RepairHashNode **bucket;
 187     RepairHashNode *nodelist;
 188
 189 public:
 190     RepairHash();
 191     RepairHash(int size);
 192     ~RepairHash();
 193     int addset(int setv, int rule, int value, int data);
 194     int addrelation(int relation, int rule, int lvalue, int rvalue, int data);
 195     int addrelation(int relation, int rule, int lvalue, int rvalue, int data, int data2);
 196     bool containsset(int setv, int rule, int value);
 197     bool containsrelation(int relation, int rule, int lvalue, int rvalue);
 198     int getset(int setv, int rule, int value);
 199     int getrelation(int relation, int rule, int lvalue, int rvalue);
 200     int getrelation2(int relation, int rule, int lvalue, int rvalue);
 201 };
 202
 203 #endif
 204