src/Collections/structs.cc

   1 #include "mymemory.h"
   2 #include "orderpair.h"
   3 #include "tableentry.h"
   4 #include "ordernode.h"
   5 #include "orderedge.h"
   6 #include "ordergraph.h"
   7 #include "orderelement.h"
   8 #include "structs.h"
   9 #include "decomposeorderresolver.h"
  10
  11 unsigned int table_entry_hash_function(TableEntry *This) {
  12         unsigned int h = 0;
  13         for (uint i = 0; i < This->inputSize; i++) {
  14                 h += This->inputs[i];
  15                 h *= 31;
  16         }
  17         return h;
  18 }
  19
  20 bool table_entry_equals(TableEntry *key1, TableEntry *key2) {
  21         if (key1->inputSize != key2->inputSize)
  22                 return false;
  23         for (uint i = 0; i < key1->inputSize; i++)
  24                 if (key1->inputs[i] != key2->inputs[i])
  25                         return false;
  26         return true;
  27 }
  28
  29 unsigned int order_node_hash_function(OrderNode *This) {
  30         return (uint) This->id;
  31 }
  32
  33 bool order_node_equals(OrderNode *key1, OrderNode *key2) {
  34         return key1->id == key2->id;
  35 }
  36
  37 unsigned int order_edge_hash_function(OrderEdge *This) {
  38         return (uint) (((uintptr_t)This->sink) ^ ((uintptr_t)This->source << 4));
  39 }
  40
  41 bool order_edge_equals(OrderEdge *key1, OrderEdge *key2) {
  42         return key1->sink == key2->sink && key1->source == key2->source;
  43 }
  44
  45 unsigned int order_element_hash_function(OrderElement *This) {
  46         return This->getHash();
  47 }
  48
  49 bool order_element_equals(OrderElement *key1, OrderElement *key2) {
  50         return key1->equals(key2);
  51 }
  52
  53 unsigned int order_pair_hash_function(OrderPair *This) {
  54         return (uint) (This->first << 2) ^ This->second;
  55 }
  56
  57 bool order_pair_equals(OrderPair *key1, OrderPair *key2) {
  58         return key1->first == key2->first && key1->second == key2->second;
  59 }
  60
  61 unsigned int doredge_hash_function(DOREdge *key) {
  62         return (uint) (key->newfirst << 2) ^ key->newsecond;
  63 }
  64
  65 bool doredge_equals(DOREdge *key1, DOREdge *key2) {
  66         return key1->newfirst == key2->newfirst &&
  67                                  key1->newsecond == key2->newsecond;
  68 }