Added debug printing function to facilitate testing expression normalization.

include/plasp/pddl/Expression.h

@@ -1,6 +1,8 @@
 #ifndef __PLASP__PDDL__EXPRESSION_H
 #define __PLASP__PDDL__EXPRESSION_H
 
+#include <iosfwd>
+
 #include <boost/intrusive_ptr.hpp>
 
 #include <plasp/utils/Parser.h>
@@ -110,6 +112,8 @@ class Expression
 		virtual ExpressionPointer normalized();
 		ExpressionPointer negated();
 
+		virtual void print(std::ostream &ostream) const = 0;
+
 	private:
 		friend void intrusive_ptr_add_ref(Expression *expression);
 		friend void intrusive_ptr_release(Expression *expression);

include/plasp/pddl/expressions/At.h

@@ -39,6 +39,8 @@ class At: public ExpressionCRTP<At>
 
 		ExpressionPointer normalized() override;
 
+		void print(std::ostream &ostream) const override;
+
 	protected:
 		size_t m_timePoint;
 

include/plasp/pddl/expressions/Binary.h

@@ -33,6 +33,8 @@ class Binary: public ExpressionCRTP<Derived>
 
 		ExpressionPointer normalized() override;
 
+		void print(std::ostream &ostream) const override;
+
 	protected:
 		std::array<ExpressionPointer, 2> m_arguments;
 };
@@ -102,6 +104,23 @@ inline ExpressionPointer Binary<Derived>::normalized()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+template<class Derived>
+inline void Binary<Derived>::print(std::ostream &ostream) const
+{
+	ostream << "(" << Derived::Identifier;
+
+	std::for_each(m_arguments.begin(), m_arguments.end(),
+		[&](auto &argument)
+		{
+			ostream << " ";
+			argument->print(ostream);
+		});
+
+	ostream << ")";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

include/plasp/pddl/expressions/Constant.h

@@ -35,6 +35,8 @@ class Constant: public ExpressionCRTP<Constant>
 		const std::string &name() const;
 		PrimitiveTypePointer type() const;
 
+		void print(std::ostream &ostream) const override;
+
 	private:
 		static ConstantPointer parseDeclaration(Context &context);
 		static void parseTypedDeclaration(Context &context, Domain &domain, Constants &constants);

include/plasp/pddl/expressions/Dummy.h

@@ -21,12 +21,13 @@ class Dummy: public ExpressionCRTP<Dummy>
 	public:
 		static const Expression::Type ExpressionType = Expression::Type::Dummy;
 
-		bool isNormalized() const;
+	public:
+		Dummy(std::string name);
 
-		ExpressionPointer normalized() override;
+		void print(std::ostream &ostream) const override;
 
 	private:
-		bool m_isNormalized = false;
+		std::string m_name;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/plasp/pddl/expressions/NAry.h

@@ -35,6 +35,8 @@ class NAry: public ExpressionCRTP<Derived>
 
 		ExpressionPointer normalized() override;
 
+		void print(std::ostream &ostream) const override;
+
 	protected:
 		Expressions m_arguments;
 };
@@ -132,6 +134,23 @@ inline ExpressionPointer NAry<Derived>::normalized()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+template<class Derived>
+inline void NAry<Derived>::print(std::ostream &ostream) const
+{
+	ostream << "(" << Derived::Identifier;
+
+	std::for_each(m_arguments.begin(), m_arguments.end(),
+		[&](auto &argument)
+		{
+			ostream << " ";
+			argument->print(ostream);
+		});
+
+	ostream << ")";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

include/plasp/pddl/expressions/Not.h

@@ -34,6 +34,8 @@ class Not: public ExpressionCRTP<Not>
 
 		ExpressionPointer normalized() override;
 
+		void print(std::ostream &ostream) const override;
+
 	protected:
 		ExpressionPointer m_argument;
 };

include/plasp/pddl/expressions/Predicate.h

@@ -30,6 +30,8 @@ class Predicate: public ExpressionCRTP<Predicate>
 
 		bool isDeclared() const;
 
+		void print(std::ostream &ostream) const override;
+
 	private:
 		Predicate();
 

include/plasp/pddl/expressions/PredicateDeclaration.h

@@ -31,6 +31,8 @@ class PredicateDeclaration: public ExpressionCRTP<PredicateDeclaration>
 
 		void normalizeParameterNames();
 
+		void print(std::ostream &ostream) const override;
+
 	private:
 		PredicateDeclaration();
 

include/plasp/pddl/expressions/PrimitiveType.h

@@ -35,6 +35,8 @@ class PrimitiveType: public ExpressionCRTP<PrimitiveType>
 		const std::string &name() const;
 		const PrimitiveTypes &parentTypes() const;
 
+		void print(std::ostream &ostream) const override;
+
 	private:
 		void setDirty(bool isDirty = true);
 		bool isDirty() const;

include/plasp/pddl/expressions/Unsupported.h

@@ -27,6 +27,8 @@ class Unsupported: public ExpressionCRTP<Unsupported>
 	public:
 		const std::string &type() const;
 
+		void print(std::ostream &ostream) const override;
+
 	private:
 		std::string m_type;
 };

include/plasp/pddl/expressions/Variable.h

@@ -37,6 +37,8 @@ class Variable: public ExpressionCRTP<Variable>
 		void setDirty(bool isDirty = true);
 		bool isDirty() const;
 
+		void print(std::ostream &ostream) const override;
+
 	private:
 		static void parseDeclaration(Context &context, Variables &parameters);
 

src/plasp/pddl/expressions/And.cpp

@@ -1,5 +1,8 @@
 #include <plasp/pddl/expressions/And.h>
 
+#include <algorithm>
+#include <iostream>
+
 namespace plasp
 {
 namespace pddl

src/plasp/pddl/expressions/At.cpp

@@ -45,6 +45,17 @@ ExpressionPointer At::normalized()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void At::print(std::ostream &ostream) const
+{
+	ostream << "(at " << m_timePoint << " ";
+
+	m_argument->print(ostream);
+
+	ostream << ")";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/Constant.cpp

@@ -239,6 +239,13 @@ PrimitiveTypePointer Constant::type() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void Constant::print(std::ostream &ostream) const
+{
+	ostream << "(" << m_name << ")";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/Dummy.cpp

@@ -15,18 +15,16 @@ namespace expressions
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool Dummy::isNormalized() const
+Dummy::Dummy(std::string name)
+:	m_name{name}
 {
-	return m_isNormalized;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer Dummy::normalized()
+void Dummy::print(std::ostream &ostream) const
 {
-	m_isNormalized = true;
+	ostream << "(" << m_name << ")";
-
-	return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

src/plasp/pddl/expressions/Not.cpp

@@ -84,6 +84,17 @@ ExpressionPointer Not::normalized()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void Not::print(std::ostream &ostream) const
+{
+	ostream << "(not ";
+
+	m_argument->print(ostream);
+
+	ostream << ")";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/Predicate.cpp

@@ -170,6 +170,14 @@ const Expressions &Predicate::arguments() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void Predicate::print(std::ostream &ostream) const
+{
+	// TODO: implement correctly
+	ostream << "(<predicate>)";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/PredicateDeclaration.cpp

@@ -87,6 +87,14 @@ void PredicateDeclaration::normalizeParameterNames()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void PredicateDeclaration::print(std::ostream &ostream) const
+{
+	// TODO: implement correctly
+	ostream << "(<predicate declaration>)";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/PrimitiveType.cpp

@@ -169,6 +169,14 @@ const PrimitiveTypes &PrimitiveType::parentTypes() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void PrimitiveType::print(std::ostream &ostream) const
+{
+	// TODO: implement correctly
+	ostream << "(<primitive type" << m_name << ">)";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/Unsupported.cpp

@@ -41,6 +41,14 @@ const std::string &Unsupported::type() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void Unsupported::print(std::ostream &ostream) const
+{
+	// TODO: implement correctly
+	ostream << "(<unsupported expression “" << m_type << "”>)";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/Variable.cpp

@@ -203,6 +203,14 @@ bool Variable::isDirty() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void Variable::print(std::ostream &ostream) const
+{
+	// TODO: implement correctly
+	ostream << "(<variable " << m_name << ">)";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

tests/TestPDDLNormalization.cpp

@@ -13,28 +13,14 @@ using namespace plasp::pddl;
 TEST(PDDLNormalizationTests, Implication)
 {
 	auto i = expressions::ImplyPointer(new expressions::Imply);
-	auto d1 = expressions::DummyPointer(new expressions::Dummy);
-	const auto d1p = d1.get();
-	auto d2 = expressions::DummyPointer(new expressions::Dummy);
-	const auto d2p = d2.get();
 
-	i->setArgument(0, d1);
+	i->setArgument(0, new expressions::Dummy("a"));
-	i->setArgument(1, d2);
+	i->setArgument(1, new expressions::Dummy("b"));
 
-	auto normalized = i->normalized();
+	std::stringstream output;
+	i->normalized()->print(output);
 
-	ASSERT_EQ(normalized->expressionType(), Expression::Type::Or);
+	ASSERT_EQ(output.str(), "(or (not (a)) (b))");
-
-	const auto &o = dynamic_cast<expressions::Or &>(*normalized);
-
-	ASSERT_EQ(o.arguments()[0]->expressionType(), Expression::Type::Not);
-
-	const auto &n = dynamic_cast<const expressions::Not &>(*o.arguments()[0]);
-
-	ASSERT_EQ(n.argument(), d1p);
-	ASSERT_EQ(o.arguments()[1], d2p);
-	ASSERT_TRUE(d1p->isNormalized());
-	ASSERT_TRUE(d2p->isNormalized());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -43,57 +29,32 @@ TEST(PDDLNormalizationTests, DoubleNegation)
 {
 	auto n1 = expressions::NotPointer(new expressions::Not);
 	auto n2 = expressions::NotPointer(new expressions::Not);
-	auto d = expressions::DummyPointer(new expressions::Dummy);
-	const auto dp = d.get();
 
-	n2->setArgument(std::move(d));
+	n2->setArgument(new expressions::Dummy("a"));
-	n1->setArgument(std::move(n2));
+	n1->setArgument(n2);
 
-	auto normalized = n1->normalized();
+	std::stringstream output;
+	n1->normalized()->print(output);
 
-	ASSERT_EQ(normalized.get(), dp);
+	ASSERT_EQ(output.str(), "(a)");
-	ASSERT_TRUE(dp->isNormalized());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 TEST(PDDLNormalizationTests, DeMorganNegativeConjunction)
 {
-	auto d1 = expressions::DummyPointer(new expressions::Dummy);
-	const auto d1p = d1.get();
-	auto d2 = expressions::DummyPointer(new expressions::Dummy);
-	const auto d2p = d2.get();
-	auto d3 = expressions::DummyPointer(new expressions::Dummy);
-	const auto d3p = d3.get();
-
 	auto a = expressions::AndPointer(new expressions::And);
-	a->addArgument(d1);
+	a->addArgument(new expressions::Dummy("a"));
-	a->addArgument(d2);
+	a->addArgument(new expressions::Dummy("b"));
-	a->addArgument(d3);
+	a->addArgument(new expressions::Dummy("c"));
 
 	auto n = expressions::NotPointer(new expressions::Not);
 	n->setArgument(a);
 
-	auto normalized = n->normalized();
+	std::stringstream output;
+	n->normalized()->print(output);
 
-	ASSERT_EQ(normalized->expressionType(), Expression::Type::Or);
+	ASSERT_EQ(output.str(), "(or (not (a)) (not (b)) (not (c)))");
-
-	const auto &o = dynamic_cast<expressions::Or &>(*normalized);
-
-	ASSERT_EQ(o.arguments()[0]->expressionType(), Expression::Type::Not);
-	ASSERT_EQ(o.arguments()[1]->expressionType(), Expression::Type::Not);
-	ASSERT_EQ(o.arguments()[2]->expressionType(), Expression::Type::Not);
-
-	const auto &n1 = dynamic_cast<expressions::Not &>(*o.arguments()[0]);
-	const auto &n2 = dynamic_cast<expressions::Not &>(*o.arguments()[1]);
-	const auto &n3 = dynamic_cast<expressions::Not &>(*o.arguments()[2]);
-
-	ASSERT_EQ(n1.argument().get(), d1p);
-	ASSERT_EQ(n2.argument().get(), d2p);
-	ASSERT_EQ(n3.argument().get(), d3p);
-	ASSERT_TRUE(d1p->isNormalized());
-	ASSERT_TRUE(d2p->isNormalized());
-	ASSERT_TRUE(d3p->isNormalized());
 }
 
 
@@ -101,39 +62,39 @@ TEST(PDDLNormalizationTests, DeMorganNegativeConjunction)
 
 TEST(PDDLNormalizationTests, DeMorganNegativeDisjunction)
 {
-	auto d1 = expressions::DummyPointer(new expressions::Dummy);
+	auto a = expressions::OrPointer(new expressions::Or);
-	const auto d1p = d1.get();
+	a->addArgument(new expressions::Dummy("a"));
-	auto d2 = expressions::DummyPointer(new expressions::Dummy);
+	a->addArgument(new expressions::Dummy("b"));
-	const auto d2p = d2.get();
+	a->addArgument(new expressions::Dummy("c"));
-	auto d3 = expressions::DummyPointer(new expressions::Dummy);
-	const auto d3p = d3.get();
-
-	auto o = expressions::OrPointer(new expressions::Or);
-	o->addArgument(d1);
-	o->addArgument(d2);
-	o->addArgument(d3);
 
 	auto n = expressions::NotPointer(new expressions::Not);
-	n->setArgument(o);
+	n->setArgument(a);
 
-	auto normalized = n->normalized();
+	std::stringstream output;
+	n->normalized()->print(output);
 
-	ASSERT_EQ(normalized->expressionType(), Expression::Type::And);
+	ASSERT_EQ(output.str(), "(and (not (a)) (not (b)) (not (c)))");
-
+}
-	const auto &a = dynamic_cast<expressions::And &>(*normalized);
+
-
+////////////////////////////////////////////////////////////////////////////////////////////////////
-	ASSERT_EQ(a.arguments()[0]->expressionType(), Expression::Type::Not);
+
-	ASSERT_EQ(a.arguments()[1]->expressionType(), Expression::Type::Not);
+TEST(PDDLNormalizationTests, DoubleNegationInner)
-	ASSERT_EQ(a.arguments()[2]->expressionType(), Expression::Type::Not);
+{
-
+	auto n1 = expressions::NotPointer(new expressions::Not);
-	const auto &n1 = dynamic_cast<expressions::Not &>(*a.arguments()[0]);
+	auto n2 = expressions::NotPointer(new expressions::Not);
-	const auto &n2 = dynamic_cast<expressions::Not &>(*a.arguments()[1]);
+	auto n3 = expressions::NotPointer(new expressions::Not);
-	const auto &n3 = dynamic_cast<expressions::Not &>(*a.arguments()[2]);
+	auto a = expressions::AndPointer(new expressions::And);
-
+
-	ASSERT_EQ(n1.argument().get(), d1p);
+	a->addArgument(new expressions::Dummy("a"));
-	ASSERT_EQ(n2.argument().get(), d2p);
+	a->addArgument(new expressions::Dummy("b"));
-	ASSERT_EQ(n3.argument().get(), d3p);
+	a->addArgument(new expressions::Dummy("c"));
-	ASSERT_TRUE(d1p->isNormalized());
+
-	ASSERT_TRUE(d2p->isNormalized());
+	n3->setArgument(a);
-	ASSERT_TRUE(d3p->isNormalized());
+	n2->setArgument(n3);
+	n1->setArgument(n2);
+
+	std::stringstream output;
+	n1->normalized()->print(output);
+
+	ASSERT_EQ(output.str(), "(or (not (a)) (not (b)) (not (c)))");
 }