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