Decomposition nodes now have reference to parent.

Gringo/Clasp now also gets parent bag as input.

Author: bbliem

src/Decomposition.cpp

@@ -21,10 +21,10 @@ along with D-FLAT.  If not, see <http://www.gnu.org/licenses/>.
 #include "Decomposition.h"
 #include "SolverFactory.h"
 
-Decomposition::Decomposition(Node&& leaf, const SolverFactory& solverFactory)
-	: DirectedAcyclicGraph(std::move(leaf))
+Decomposition::Decomposition(Node&& node, const SolverFactory& solverFactory)
+	: DirectedAcyclicGraph(std::move(node))
 	, solverFactory(solverFactory)
-	, root(false)
+	, parent(nullptr)
 	, postJoinNode(false)
 {
 }
@@ -44,14 +44,9 @@ bool Decomposition::isJoinNode() const
 	});
 }
 
-void Decomposition::setRoot(bool root)
-{
-	this->root = root;
-}
-
 bool Decomposition::isRoot() const
 {
-	return root;
+	return parent == nullptr;
 }
 
 void Decomposition::setPostJoinNode(bool postJoinNode)
@@ -64,6 +59,16 @@ bool Decomposition::isPostJoinNode() const
 	return postJoinNode;
 }
 
+const Decomposition* Decomposition::getParent() const
+{
+	return parent;
+}
+
+void Decomposition::setParent(const Decomposition* parent)
+{
+	this->parent = parent;
+}
+
 int Decomposition::getWidth() const
 {
 	int width = node.getBag().size() - 1;

src/Decomposition.h

@@ -43,11 +43,7 @@ class Decomposition : public DirectedAcyclicGraph<DecompositionNode, std::vector
 	// Returns true if the node is a join node, i.e., has at least two children and all children have equal bags
 	bool isJoinNode() const;
 
-	// Mark this node to be the root.
-	// Only do this if this is not a child of any node.
-	void setRoot(bool root = true);
-
-	// Returns true if setRoot(true) has been called.
+	// Returns true if setParent() has not been called (with non-null argument)
 	bool isRoot() const;
 
 	// Mark this node to be a node added for post-processing join nodes.
@@ -56,6 +52,9 @@ class Decomposition : public DirectedAcyclicGraph<DecompositionNode, std::vector
 	// Returns true if setPostJoinNode(true) has been called.
 	bool isPostJoinNode() const;
 
+	const Decomposition* getParent() const;
+	void setParent(const Decomposition*);
+
 	// Traverses the decomposition and returns its width
 	int getWidth() const;
 
@@ -67,6 +66,6 @@ class Decomposition : public DirectedAcyclicGraph<DecompositionNode, std::vector
 
 	const SolverFactory& solverFactory;
 	std::unique_ptr<Solver> solver;
-	bool root;
+	const Decomposition* parent;
 	bool postJoinNode;
 };

src/asp_utils.cpp

@@ -46,6 +46,13 @@ void declareDecomposition(const Decomposition& decomposition, std::ostream& out)
 
 	if(decomposition.isRoot())
 		out << "final." << std::endl;
+	else {
+		assert(decomposition.getParent() != nullptr);
+		const Decomposition& parent = *decomposition.getParent();
+		out << "parentNode(" << parent.getNode().getGlobalId() << ")." << std::endl;
+		for(const auto& v : parent.getNode().getBag())
+			out << "bag(" << parent.getNode().getGlobalId() << ',' << v << ")." << std::endl;
+	}
 
 	if(decomposition.isPostJoinNode())
 		out << "postJoin." << std::endl;

src/decomposer/Dummy.cpp

@@ -39,7 +39,6 @@ DecompositionPtr Dummy::decompose(const Instance& instance) const
 			vertices.insert(arguments.begin(), arguments.end());
 
 	DecompositionPtr result(new Decomposition(vertices, app.getSolverFactory()));
-	result->setRoot();
 	return result;
 }
 

src/decomposer/GraphMl.cpp

@@ -61,6 +61,7 @@ namespace {
 			DecompositionNode::Bag bag = decomposition.getNode().getBag();
 			bag.erase(bag.begin());
 			DecompositionPtr child(new Decomposition(bag, app.getSolverFactory()));
+			child->setParent(&decomposition);
 			decomposition.addChild(std::move(child));
 		}
 
@@ -74,6 +75,7 @@ namespace {
 			DecompositionNode::Bag bag = oldRoot->getNode().getBag();
 			bag.erase(bag.begin());
 			DecompositionPtr newNode(new Decomposition(bag, app.getSolverFactory()));
+			oldRoot->setParent(newNode.get());
 			newNode->addChild(std::move(oldRoot));
 			return addEmptyRoot(std::move(newNode), app);
 		}
@@ -140,6 +142,7 @@ DecompositionPtr GraphMl::decompose(const Instance& instance) const
 			const DecompositionPtr to = nodes.top();
 			nodes.pop();
 			const DecompositionPtr& from = nodes.top();
+			to->setParent(from.get());
 			from->addChild(std::move(to));
 		}
 		else
@@ -155,7 +158,6 @@ DecompositionPtr GraphMl::decompose(const Instance& instance) const
 	if(optAddEmptyRoot.isUsed())
 		root = addEmptyRoot(std::move(root), app);
 
-	root->setRoot();
 	return root;
 }
 

src/decomposer/TreeDecomposer.cpp

@@ -147,6 +147,7 @@ namespace {
 				Decomposition* parentOrPostJoinNode = parent.get();
 
 				DecompositionPtr child{new Decomposition{childBag, app.getSolverFactory()}};
+				child->setParent(parentOrPostJoinNode);
 				parentOrPostJoinNode->addChild(child);
 				stack.push({htdChild, child});
 			}
@@ -275,7 +276,6 @@ DecompositionPtr TreeDecomposer::decompose(const Instance& instance) const
 
 	// Transform htd's tree decomposition into our format
 	DecompositionPtr result = transformTd(*decomposition, graph, app);
-	result->setRoot();
 	return result;
 }
 

test/Decomposition.cpp

@@ -72,10 +72,12 @@ TEST_F(DecompositionTest, IdentifiesJoinNodes)
 		EXPECT_FALSE(child->isJoinNode());
 }
 
-TEST_F(DecompositionTest, IsNotRootByDefault)
+TEST_F(DecompositionTest, SetsParent)
 {
 	Decomposition d = {DecompositionNode{{}}, solverFactory};
-	EXPECT_FALSE(d.isRoot());
-	d.setRoot();
-	EXPECT_TRUE(d.isRoot());
+	EXPECT_EQ(nullptr, d.getParent());
+	DecompositionPtr c{new Decomposition{DecompositionNode{{}}, solverFactory}};
+	c->setParent(&d);
+	d.addChild(std::move(c));
+	EXPECT_EQ(&d, (*d.getChildren().begin())->getParent());
 }