encapsulate order fields

[satune.git] / src / ASTAnalyses / Order / ordergraph.cc

diff --git a/src/ASTAnalyses/Order/ordergraph.cc b/src/ASTAnalyses/Order/ordergraph.cc
index a2e52f807d2db417b436eb9a1d728daf9d96f3f5..57d0db8c756fc5f28a8333f7b83e61cbcb6e59be 100644 (file)
--- a/src/ASTAnalyses/Order/ordergraph.cc
+++ b/src/ASTAnalyses/Order/ordergraph.cc
@@ -12,10 +12,10 @@ OrderGraph::OrderGraph(Order *_order) :
 OrderGraph *buildOrderGraph(Order *order) {
        ASSERT(order->graph == NULL);
        OrderGraph *orderGraph = new OrderGraph(order);
-       order->graph = orderGraph;
-       uint constrSize = order->constraints.getSize();
+       Vector<BooleanOrder *> *constraints = order->getConstraints();
+       uint constrSize = constraints->getSize();
        for (uint j = 0; j < constrSize; j++) {
-               orderGraph->addOrderConstraintToOrderGraph(order->constraints.get(j));
+               orderGraph->addOrderConstraintToOrderGraph(constraints->get(j));
        }
        return orderGraph;
 }
@@ -24,9 +24,10 @@ OrderGraph *buildOrderGraph(Order *order) {
 OrderGraph *buildMustOrderGraph(Order *order) {
        ASSERT(order->graph == NULL);
        OrderGraph *orderGraph = new OrderGraph(order);
-       uint constrSize = order->constraints.getSize();
+       Vector<BooleanOrder *> *constraints = order->getConstraints();
+       uint constrSize = constraints->getSize();
        for (uint j = 0; j < constrSize; j++) {
-               orderGraph->addMustOrderConstraintToOrderGraph(order->constraints.get(j));
+               orderGraph->addMustOrderConstraintToOrderGraph(constraints->get(j));
        }
        return orderGraph;
 }
@@ -71,6 +72,16 @@ void OrderGraph::addOrderEdge(OrderNode *node1, OrderNode *node2, BooleanOrder *
        }
 }
 
+void OrderGraph::addEdge(uint64_t first, uint64_t second) {
+       OrderNode *node1 = getOrderNodeFromOrderGraph(first);
+       OrderNode *node2 = getOrderNodeFromOrderGraph(second);
+       OrderEdge *_1to2 = getOrderEdgeFromOrderGraph(node1, node2);
+       _1to2->polPos = true;
+       _1to2->mustPos = true;
+       node1->addNewOutgoingEdge(_1to2);
+       node2->addNewIncomingEdge(_1to2);
+}
+
 void OrderGraph::addMustOrderEdge(OrderNode *node1, OrderNode *node2, BooleanOrder *constr) {
        BooleanValue mustval = constr->boolVal;
        switch (mustval) {
@@ -108,20 +119,19 @@ void OrderGraph::addMustOrderEdge(OrderNode *node1, OrderNode *node2, BooleanOrd
 
 OrderNode *OrderGraph::getOrderNodeFromOrderGraph(uint64_t id) {
        OrderNode *node = new OrderNode(id);
-       OrderNode *tmp = nodes.get(node);
+       OrderNode *tmp = (OrderNode *)nodes.get(node);
        if ( tmp != NULL) {
                delete node;
                node = tmp;
        } else {
                nodes.add(node);
-               allNodes.push(node);
        }
        return node;
 }
 
 OrderNode *OrderGraph::lookupOrderNodeFromOrderGraph(uint64_t id) {
-       OrderNode node(id);
-       OrderNode *tmp = nodes.get(&node);
+       OrderNodeKey node(id);
+       OrderNode *tmp = (OrderNode *)nodes.get(&node);
        return tmp;
 }
 
@@ -162,16 +172,8 @@ void OrderGraph::addMustOrderConstraintToOrderGraph(BooleanOrder *bOrder) {
 }
 
 OrderGraph::~OrderGraph() {
-       uint size=allNodes.getSize();
-       for(uint i=0;i<size;i++)
-               delete allNodes.get(i);
-
-       SetIteratorOrderEdge *eiterator = edges.iterator();
-       while (eiterator->hasNext()) {
-               OrderEdge *edge = eiterator->next();
-               delete edge;
-       }
-       delete eiterator;
+       nodes.resetAndDelete();
+       edges.resetAndDelete();
 }
 
 bool OrderGraph::isTherePath(OrderNode *source, OrderNode *destination) {
@@ -225,8 +227,8 @@ bool OrderGraph::isTherePathVisit(HashsetOrderNode &visited, OrderNode *current,
 void OrderGraph::DFS(Vector<OrderNode *> *finishNodes) {
        SetIteratorOrderNode *iterator = getNodes();
        while (iterator->hasNext()) {
-               OrderNode *node = iterator->next();
-               if (node->status == NOTVISITED) {
+               OrderNode *node = (OrderNode *)iterator->next();
+               if (node->status == NOTVISITED && !node->removed) {
                        node->status = VISITED;
                        DFSNodeVisit(node, finishNodes, false, false, 0);
                        node->status = FINISHED;
@@ -239,8 +241,8 @@ void OrderGraph::DFS(Vector<OrderNode *> *finishNodes) {
 void OrderGraph::DFSMust(Vector<OrderNode *> *finishNodes) {
        SetIteratorOrderNode *iterator = getNodes();
        while (iterator->hasNext()) {
-               OrderNode *node = iterator->next();
-               if (node->status == NOTVISITED) {
+               OrderNode *node = (OrderNode *)iterator->next();
+               if (node->status == NOTVISITED && !node->removed) {
                        node->status = VISITED;
                        DFSNodeVisit(node, finishNodes, false, true, 0);
                        node->status = FINISHED;
@@ -294,7 +296,7 @@ void OrderGraph::DFSNodeVisit(OrderNode *node, Vector<OrderNode *> *finishNodes,
 void OrderGraph::resetNodeInfoStatusSCC() {
        SetIteratorOrderNode *iterator = getNodes();
        while (iterator->hasNext()) {
-               iterator->next()->status = NOTVISITED;
+               ((OrderNode *)iterator->next())->status = NOTVISITED;
        }
        delete iterator;
 }