Implemented preconditions for derived predicates.

include/plasp/pddl/expressions/DerivedPredicate.h

@@ -26,6 +26,10 @@ class DerivedPredicate: public ExpressionCRTP<DerivedPredicate>
 		// TODO: consider implementing parsing functions for compatibility with older PDDL versions
 
 	public:
+		explicit DerivedPredicate(size_t id);
+
+		size_t id() const;
+
 		void setPreconditions(std::vector<Expressions> &&preconditions);
 		const std::vector<Expressions> &preconditions() const;
 
@@ -38,6 +42,8 @@ class DerivedPredicate: public ExpressionCRTP<DerivedPredicate>
 	private:
 		void collectParameters();
 
+		size_t m_id;
+
 		// The arguments are interpreted as a disjunction of conjunctions
 		std::vector<Expressions> m_preconditions;
 

include/plasp/pddl/expressions/Quantified.h

@@ -197,7 +197,7 @@ inline ExpressionPointer QuantifiedCRTP<Derived>::simplified()
 template<class Derived>
 inline ExpressionPointer QuantifiedCRTP<Derived>::decomposed(DerivedPredicates &derivedPredicates)
 {
-	derivedPredicates.emplace_back(new DerivedPredicate());
+	derivedPredicates.emplace_back(new DerivedPredicate(derivedPredicates.size()));
 	auto &derivedPredicate = derivedPredicates.back();
 
 	m_argument = m_argument->decomposed(derivedPredicates);

include/plasp/pddl/translation/Precondition.h

@@ -0,0 +1,75 @@
+#ifndef __PLASP__PDDL__TRANSLATION__PRECONDITION_H
+#define __PLASP__PDDL__TRANSLATION__PRECONDITION_H
+
+#include <plasp/output/Formatting.h>
+#include <plasp/pddl/Description.h>
+#include <plasp/pddl/translation/Primitives.h>
+
+namespace plasp
+{
+namespace pddl
+{
+namespace translation
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Precondition
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class PrintObjectName>
+void translatePreconditionDisjunction(output::ColorStream &outputStream, const std::string &objectType, PrintObjectName printObjectName, const std::vector<Expressions> &preconditionDisjunction);
+template<class PrintObjectName>
+void translatePreconditionConjunction(output::ColorStream &outputStream, const std::string &objectType, PrintObjectName printObjectName, size_t disjunctionID, const Expressions &preconditionConjunction);
+template<class PrintObjectName>
+void translatePrecondition(output::ColorStream &outputStream, const std::string &objectType, PrintObjectName printObjectName, size_t disjunctionID, const Expression &precondition);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class PrintObjectName>
+inline void translatePreconditionDisjunction(output::ColorStream &outputStream, const std::string &objectType, PrintObjectName printObjectName, const std::vector<Expressions> &preconditionDisjunction)
+{
+	for (size_t i = 0; i < preconditionDisjunction.size(); i++)
+		translatePreconditionConjunction(outputStream, objectType, printObjectName, i, preconditionDisjunction[i]);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class PrintObjectName>
+inline void translatePreconditionConjunction(output::ColorStream &outputStream, const std::string &objectType, PrintObjectName printObjectName, size_t disjunctionID, const Expressions &preconditionConjunction)
+{
+	for (size_t i = 0; i < preconditionConjunction.size(); i++)
+		translatePrecondition(outputStream, objectType, printObjectName, disjunctionID, *preconditionConjunction[i]);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class PrintObjectName>
+inline void translatePrecondition(output::ColorStream &outputStream, const std::string &objectType, PrintObjectName printObjectName, size_t disjunctionID, const Expression &precondition)
+{
+	outputStream << std::endl << output::Function("precondition") << "(";
+
+	printObjectName(outputStream);
+
+	outputStream
+		<< ", " << output::Keyword("disjunct")
+		<< "(" << output::Number<decltype(disjunctionID)>(disjunctionID)
+		<< "), ";
+
+	translateLiteral(outputStream, precondition);
+
+	outputStream << ") :- " << output::Function(objectType.c_str()) << "(";
+
+	printObjectName(outputStream);
+
+	outputStream << ").";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+}
+}
+
+#endif

include/plasp/pddl/translation/Primitives.h

@@ -0,0 +1,117 @@
+#ifndef __PLASP__PDDL__TRANSLATION__PRIMITIVES_H
+#define __PLASP__PDDL__TRANSLATION__PRIMITIVES_H
+
+#include <plasp/output/Formatting.h>
+#include <plasp/output/TranslatorException.h>
+#include <plasp/pddl/Description.h>
+#include <plasp/pddl/expressions/Not.h>
+#include <plasp/pddl/expressions/Predicate.h>
+
+namespace plasp
+{
+namespace pddl
+{
+namespace translation
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Primitives
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void translatePredicate(output::ColorStream &outputStream, const expressions::Predicate &predicate);
+void translateLiteral(output::ColorStream &outputStream, const Expression &literal);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline void translatePredicate(output::ColorStream &outputStream, const expressions::Predicate &predicate)
+{
+	const auto &arguments = predicate.arguments();
+
+	if (arguments.empty())
+	{
+		outputStream << output::String(predicate.name().c_str());
+
+		return;
+	}
+
+	outputStream << "(" << output::String(predicate.name().c_str());
+
+	for (const auto &argument : arguments)
+	{
+		outputStream << ", ";
+
+		if (argument->is<expressions::Constant>())
+		{
+			const auto &constant = argument->as<expressions::Constant>();
+
+			outputStream << output::Keyword("constant") << "(" << output::String(constant.name().c_str()) << ")";
+		}
+		else if (argument->is<expressions::Variable>())
+		{
+			const auto &variable = argument->as<expressions::Variable>();
+
+			outputStream << output::Variable(variable.name().c_str());
+		}
+		else
+			throw output::TranslatorException("only variables and constants supported in predicates currently");
+	}
+
+	outputStream << ")";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline void translateLiteral(output::ColorStream &outputStream, const Expression &literal)
+{
+	// Translate single predicate
+	if (literal.is<expressions::Predicate>())
+	{
+		const auto &predicate = literal.as<expressions::Predicate>();
+
+		outputStream << output::Keyword("variable") << "(";
+		translation::translatePredicate(outputStream, predicate);
+		outputStream << "), " << output::Keyword("value") << "(";
+		translation::translatePredicate(outputStream, predicate);
+		outputStream << ", " << output::Boolean("true") << ")";
+	}
+	// Assuming that "not" expression may only contain a predicate
+	else if (literal.is<expressions::Not>())
+	{
+		const auto &notExpression = literal.as<expressions::Not>();
+
+		if (notExpression.argument()->expressionType() != Expression::Type::Predicate)
+			throw output::TranslatorException("only negations of primitive predicates supported as literals currently");
+
+		const auto &predicate = notExpression.argument()->as<expressions::Predicate>();
+
+		outputStream << output::Keyword("variable") << "(";
+		translation::translatePredicate(outputStream, predicate);
+		outputStream << "), " << output::Keyword("value") << "(";
+		translation::translatePredicate(outputStream, predicate);
+		outputStream << ", " << output::Boolean("false") << ")";
+	}
+	else if (literal.is<expressions::DerivedPredicate>())
+	{
+		const auto &derivedPredicate = literal.as<expressions::DerivedPredicate>();
+
+		/*m_outputStream << output::Keyword("variable") << "(";
+		translation::translatePredicate(predicate);
+		m_outputStream << "), " << output::Keyword("value") << "(";
+		translation::translatePredicate(predicate);
+		m_outputStream << ", " << output::Boolean("true") << ")";*/
+
+		outputStream << "(derived predicate)";
+	}
+	else
+		throw output::TranslatorException("only primitive predicates and their negations supported as literals currently");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+}
+}
+
+#endif