src/Encoders/ordergraph.c

   1 #include "ordergraph.h"
   2 #include "ordernode.h"
   3 #include "boolean.h"
   4 #include "orderedge.h"
   5
   6 OrderGraph* allocOrderGraph(){
   7         OrderGraph* This = (OrderGraph*) ourmalloc(sizeof(OrderGraph));
   8         This->nodes = allocHashSetOrderNode(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
   9         return This;
  10 }
  11
  12 void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, Boolean* constr){
  13         switch(constr->polarity){
  14                 case P_BOTHTRUEFALSE:
  15                 case P_TRUE:{
  16                         OrderEdge* _1to2 = getOrderEdgeFromOrderGraph(graph, constr, node1, node2);
  17                         addNewOutgoingEdge(node1, _1to2);
  18                         addNewIncomingEdge(node2, _1to2);
  19                         if(constr->polarity == P_TRUE)
  20                                 break;
  21                 }
  22                 case P_FALSE:{
  23                         OrderEdge* _2to1 = getOrderEdgeFromOrderGraph(graph, constr, node2, node1);
  24                         addNewOutgoingEdge(node2, _2to1);
  25                         addNewIncomingEdge(node1, _2to1);
  26                         break;
  27                 }
  28                 default:
  29                         ASSERT(0);
  30
  31         }
  32 }
  33
  34 OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id, Order* order){
  35         OrderNode* node = allocOrderNode(id, order);
  36         OrderNode* tmp = getHashSetOrderNode(graph->nodes, node);
  37         if( tmp!= NULL){
  38                 deleteOrderNode(node);
  39                 node= tmp;
  40         } else {
  41                 addHashSetOrderNode(graph->nodes, node);
  42         }
  43         return node;
  44 }
  45
  46 OrderEdge* getOrderEdgeFromOrderGraph(OrderGraph* graph, Boolean* order, OrderNode* begin, OrderNode* end){
  47         OrderEdge* edge = allocOrderEdge(order, begin, end);
  48         OrderEdge* tmp = getHashSetOrderEdge(graph->edges, edge);
  49         if(tmp!= NULL){
  50                 deleteOrderEdge(edge);
  51                 edge = tmp;
  52         } else {
  53                 addHashSetOrderEdge(graph->edges, edge);
  54         }
  55         return edge;
  56 }
  57
  58 void addOrderConstraintToOrderGraph(OrderGraph* graph, Boolean* constr){
  59         BooleanOrder* bOrder = (BooleanOrder*) constr;
  60         OrderNode* from = getOrderNodeFromOrderGraph(graph, bOrder->first, bOrder->order);
  61         OrderNode* to = getOrderNodeFromOrderGraph(graph, bOrder->second, bOrder->order);
  62         addOrderEdge(graph, from, to, constr);
  63
  64 }
  65
  66
  67 void deleteOrderGraph(OrderGraph* graph){
  68         HSIteratorOrderNode* iterator = iteratorOrderNode(graph->nodes);
  69         while(hasNextOrderNode(iterator)){
  70                 OrderNode* node = nextOrderNode(iterator);
  71                 deleteOrderNode(node);
  72         }
  73         deleteIterOrderNode(iterator);
  74
  75         HSIteratorOrderEdge* eiterator = iteratorOrderEdge(graph->edges);
  76         while(hasNextOrderEdge(eiterator)){
  77                 OrderEdge* edge = nextOrderEdge(eiterator);
  78                 deleteOrderEdge(edge);
  79         }
  80         deleteIterOrderEdge(eiterator);
  81         ourfree(graph);
  82 }