src/Collections/structs.c

   1 #include "structs.h"
   2 #include "mymemory.h"
   3 #include "orderpair.h"
   4 #include "tableentry.h"
   5 #include "ordernode.h"
   6 #include "orderedge.h"
   7 #include "ordergraph.h"
   8
   9 VectorImpl(Table, Table *, 4);
  10 VectorImpl(Set, Set *, 4);
  11 VectorImpl(Boolean, Boolean *, 4);
  12 VectorImpl(Function, Function *, 4);
  13 VectorImpl(Predicate, Predicate *, 4);
  14 VectorImpl(Element, Element *, 4);
  15 VectorImpl(Order, Order *, 4);
  16 VectorImpl(TableEntry, TableEntry *, 4);
  17 VectorImpl(ASTNode, ASTNode *, 4);
  18 VectorImpl(Int, uint64_t, 4);
  19 VectorImpl(OrderNode, OrderNode*, 4);
  20 VectorImpl(OrderGraph, OrderGraph*, 4);
  21
  22 inline unsigned int Ptr_hash_function(void * hash) {
  23         return (unsigned int)((int64)hash >> 4);
  24 }
  25
  26 inline bool Ptr_equals(void * key1, void * key2) {
  27         return key1 == key2;
  28 }
  29
  30 static inline unsigned int order_pair_hash_Function(OrderPair* This){
  31         return (uint) (This->first << 2) ^ This->second;
  32 }
  33
  34 static inline unsigned int order_pair_equals(OrderPair* key1, OrderPair* key2){
  35         return key1->first== key2->first && key1->second == key2->second;
  36 }
  37
  38 static inline unsigned int table_entry_hash_Function(TableEntry* This){
  39         unsigned int h = 0;
  40         for(uint i=0; i<This->inputSize; i++){
  41                 h += This->inputs[i];
  42                 h *= 31;
  43         }
  44         return h;
  45 }
  46
  47 static inline bool table_entry_equals(TableEntry* key1, TableEntry* key2){
  48         if(key1->inputSize != key2->inputSize)
  49                 return false;
  50         for(uint i=0; i<key1->inputSize; i++)
  51                 if(key1->inputs[i]!=key2->inputs[i])
  52                         return false;
  53         return true;
  54 }
  55
  56 static inline unsigned int order_node_hash_Function(OrderNode* This){
  57         return (uint) This->id;
  58
  59 }
  60
  61 static inline bool order_node_equals(OrderNode* key1, OrderNode* key2){
  62         return key1->id == key2->id;
  63 }
  64
  65 static inline unsigned int order_edge_hash_Function(OrderEdge* This){
  66         return (uint) (( (uintptr_t)This->sink)^((uintptr_t)This->source << 4) );
  67 }
  68
  69 static inline bool order_edge_equals(OrderEdge* key1, OrderEdge* key2){
  70         return key1->sink == key2->sink && key1->source == key2->source;
  71 }
  72
  73 static inline unsigned int node_info_hash_function(OrderNode * hash) {
  74         return (uint)((intptr_t)hash >> 4);
  75 }
  76
  77 static inline bool node_info_equals(OrderNode * key1, OrderNode * key2) {
  78         return key1 == key2;
  79 }
  80
  81 HashTableImpl(OrderPair, OrderPair *, OrderPair *, order_pair_hash_Function, order_pair_equals, ourfree);
  82 HashTableImpl(NodeInfo, OrderNode *, NodeInfo *, node_info_hash_function, node_info_equals, ourfree);
  83
  84 HashSetImpl(TableEntry, TableEntry*, table_entry_hash_Function, table_entry_equals);
  85 HashSetImpl(OrderNode, OrderNode*, order_node_hash_Function, order_node_equals);
  86 HashSetImpl(OrderEdge, OrderEdge*, order_edge_hash_Function, order_edge_equals);
  87