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