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 reset();
  50     void add(int id, int type, int lvalue, int rvalue);
  51     int hasMoreElements();
  52     int getid();
  53     int gettype();
  54     int getlvalue();
  55     int getrvalue();
  56     void pop();
  57 };
  58
  59 struct ListNode {
  60   int data[WLISTSIZE];
  61   ListNode *next;
  62 };
  63 /* SimpleHash *********************************************************/
  64 class SimpleIterator;
  65
  66 class SimpleHash {
  67 private:
  68     int numelements;
  69     int size;
  70     struct SimpleNode **bucket;
  71     struct ArraySimple *listhead;
  72     struct ArraySimple *listtail;
  73
  74
  75     int numparents;
  76     int numchildren;
  77     SimpleHash* parents[10];
  78     SimpleHash* children[10];
  79     void addChild(SimpleHash* child);
  80 public:
  81     int tailindex;
  82     SimpleHash(int size=100);
  83     ~SimpleHash();
  84     int add(int key, int data);
  85     int remove(int key, int data);
  86     bool contains(int key);
  87     bool contains(int key, int data);
  88     int get(int key, int& data);
  89     int countdata(int data);
  90     void addParent(SimpleHash* parent);
  91     int firstkey();
  92     SimpleIterator* iterator();
  93     void iterator(SimpleIterator & it);
  94     inline int count() {
  95         return numelements;
  96     }
  97     int count(int key);
  98
  99 };
 100
 101 /* SimpleHashExcepion  *************************************************/
 102
 103
 104 /* SimpleIterator *****************************************************/
 105 #define ARRAYSIZE 100
 106
 107 struct SimpleNode {
 108   struct SimpleNode *next;
 109   int data;
 110   int key;
 111   int inuse;
 112 };
 113
 114 struct ArraySimple {
 115   struct SimpleNode nodes[ARRAYSIZE];
 116   struct ArraySimple * nextarray;
 117 };
 118
 119
 120 class SimpleIterator {
 121  public:
 122
 123   struct ArraySimple *cur, *tail;
 124   int index,tailindex;
 125   //  SimpleHash * table;
 126   inline SimpleIterator() {}
 127
 128   inline SimpleIterator(struct ArraySimple *start, struct ArraySimple *tl, int tlindex/*, SimpleHash *t*/) {
 129     cur = start;
 130     //    table=t;
 131     index=0;
 132     tailindex=tlindex;
 133     tail=tl;
 134   }
 135
 136   inline int hasNext() {
 137     if (cur==tail &&
 138         index==tailindex)
 139       return 0;
 140     while((index==ARRAYSIZE)||!cur->nodes[index].inuse) {
 141       if (index==ARRAYSIZE) {
 142         index=0;
 143         cur=cur->nextarray;
 144       } else
 145         index++;
 146     }
 147     if (cur->nodes[index].inuse)
 148       return 1;
 149     else
 150       return 0;
 151   }
 152
 153   inline int next() {
 154     return cur->nodes[index++].data;
 155   }
 156
 157   inline int key() {
 158     return cur->nodes[index].key;
 159   }
 160 };
 161
 162 /* SimpleHashExcepion  *************************************************/
 163
 164 class SimpleHashException {
 165 public:
 166     SimpleHashException();
 167 };
 168
 169 class RepairHashNode {
 170  public:
 171     RepairHashNode *next;
 172     RepairHashNode *lnext;
 173     int data;
 174     int data2;
 175     int setrelation;
 176     int lvalue;
 177     int rvalue;
 178     int rule;
 179     int ismodify;
 180     RepairHashNode(int setrelation, int rule, int lvalue, int rvalue, int data, int data2,int ismodify);
 181 };
 182
 183 class RepairHash {
 184
 185 private:
 186     int numelements;
 187     int size;
 188     RepairHashNode **bucket;
 189     RepairHashNode *nodelist;
 190
 191 public:
 192     RepairHash();
 193     RepairHash(int size);
 194     ~RepairHash();
 195     int addset(int setv, int rule, int value, int data);
 196     int addrelation(int relation, int rule, int lvalue, int rvalue, int data);
 197     int addrelation(int relation, int rule, int lvalue, int rvalue, int data, int data2);
 198     bool containsset(int setv, int rule, int value);
 199     bool containsrelation(int relation, int rule, int lvalue, int rvalue);
 200     int getset(int setv, int rule, int value);
 201     int getrelation(int relation, int rule, int lvalue, int rvalue);
 202     int getrelation2(int relation, int rule, int lvalue, int rvalue);
 203     int ismodify(int relation, int rule, int lvalue, int rvalue);
 204 };
 205
 206 #endif
 207