Refactored expressions to inherit from base class.

include/plasp/pddl/Action.h

@@ -3,6 +3,7 @@
 
 #include <vector>
 
+#include <plasp/pddl/Expression.h>
 #include <plasp/pddl/Variable.h>
 #include <plasp/utils/Parser.h>
 
@@ -25,14 +26,18 @@ class Action
 	public:
 		const std::string &name() const;
 
+		const Variables &parameters() const;
+		const Expression &precondition() const;
+		const Expression &effect() const;
+
 	private:
 		Action(std::string name);
 
-		void parsePrecondition(utils::Parser &parser, Context &context);
-
 		std::string m_name;
 
-		std::vector<Variable> m_parameters;
+		Variables m_parameters;
+		std::unique_ptr<Expression> m_precondition;
+		std::unique_ptr<Expression> m_effect;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/plasp/pddl/Context.h

@@ -5,6 +5,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include <plasp/pddl/Action.h>
 #include <plasp/pddl/Constant.h>
 #include <plasp/pddl/Predicate.h>
 #include <plasp/pddl/Type.h>
@@ -33,6 +34,8 @@ class Context
 
 		std::vector<std::unique_ptr<Predicate>> predicates;
 		std::unordered_map<PredicateHashMapKey, Predicate *> predicatesHashMap;
+
+		std::vector<std::unique_ptr<Action>> actions;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/plasp/pddl/Domain.h

@@ -31,6 +31,7 @@ class Domain
 		const std::vector<std::unique_ptr<PrimitiveType>> &types() const;
 		const std::vector<std::unique_ptr<Constant>> &constants() const;
 		const std::vector<std::unique_ptr<Predicate>> &predicates() const;
+		const std::vector<std::unique_ptr<Action>> &actions() const;
 
 	private:
 		Domain(Context &context);
@@ -47,6 +48,8 @@ class Domain
 
 		void parsePredicateSection(utils::Parser &parser);
 
+		void parseActionSection(utils::Parser &parser);
+
 		void checkConsistency();
 
 		Context &m_context;

include/plasp/pddl/Expression.h

@@ -1,6 +1,8 @@
 #ifndef __PLASP__PDDL__EXPRESSION_H
 #define __PLASP__PDDL__EXPRESSION_H
 
+#include <memory>
+
 #include <boost/variant.hpp>
 
 #include <plasp/utils/Parser.h>
@@ -17,17 +19,19 @@ namespace pddl
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 class Context;
-
-namespace expression
-{
-	class And;
-}
+class ExpressionVisitor;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-using ExpressionPtr = boost::variant<void *>;
+class Expression
+{
+	public:
+		virtual void accept(ExpressionVisitor &expressionVisitor) const = 0;
+};
 
-ExpressionPtr parsePreconditionExpression(utils::Parser &parser, Context &context);
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+std::unique_ptr<Expression> parsePreconditionExpression(utils::Parser &parser, Context &context);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 

src/plasp/pddl/Action.cpp

@@ -31,25 +31,29 @@ Action &Action::parseDeclaration(utils::Parser &parser, Context &context)
 
 	parser.expect<std::string>(":parameters");
 
-	parser.skipWhiteSpace();
+	parser.expect<std::string>("(");
 
 	// Read parameters
-	while (parser.currentCharacter() != ':')
+	while (parser.currentCharacter() != ')')
 	{
 		Variable::parseTyped(parser, context, action->m_parameters);
 
 		parser.skipWhiteSpace();
 	}
 
+	parser.expect<std::string>(")");
+
 	// Parse preconditions and effects
-	while (parser.currentCharacter() == ')')
+	while (parser.currentCharacter() != ')')
 	{
 		parser.expect<std::string>(":");
 
 		const auto sectionIdentifier = parser.parseIdentifier(isIdentifier);
 
 		if (sectionIdentifier == "precondition")
-			action->parsePrecondition(parser, context);
+			action->m_precondition = parsePreconditionExpression(parser, context);
+		//else if (sectionIdentifier == "effect")
+		//	action->m_effect = parseEffectExpression(parser, context);
 	}
 
 	parser.expect<std::string>(")");
@@ -62,25 +66,6 @@ Action &Action::parseDeclaration(utils::Parser &parser, Context &context)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Action::parsePrecondition(utils::Parser &parser, Context &context)
-{
-	parser.skipWhiteSpace();
-
-	// Check for empty precondition
-	if (parser.currentCharacter() == '(')
-	{
-		// Leave the preconditions empty and return
-		parser.expect<std::string>("()");
-		parser.expect<std::string>(")");
-
-		return;
-	}
-
-	parser.expect<std::string>")");
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
 const std::string &Action::name() const
 {
 	return m_name;
@@ -95,5 +80,23 @@ const Variables &Action::parameters() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+const Expression &Action::precondition() const
+{
+	BOOST_ASSERT(m_precondition);
+
+	return *m_precondition;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const Expression &Action::effect() const
+{
+	BOOST_ASSERT(m_effect);
+
+	return *m_effect;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }

src/plasp/pddl/Domain.cpp

@@ -88,6 +88,13 @@ const std::vector<std::unique_ptr<Predicate>> &Domain::predicates() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+const std::vector<std::unique_ptr<Action>> &Domain::actions() const
+{
+	return m_context.actions;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void Domain::parseSection(utils::Parser &parser)
 {
 	parser.expect<std::string>("(:");
@@ -131,7 +138,7 @@ void Domain::parseSection(utils::Parser &parser)
 	else if (sectionIdentifier == "constraints")
 		skipSection();
 	else if (sectionIdentifier == "action")
-		skipSection();
+		parseActionSection(parser);
 	else if (sectionIdentifier == "durative-action")
 		skipSection();
 	else if (sectionIdentifier == "derived")
@@ -273,6 +280,17 @@ void Domain::parsePredicateSection(utils::Parser &parser)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void Domain::parseActionSection(utils::Parser &parser)
+{
+	parser.skipWhiteSpace();
+
+	Action::parseDeclaration(parser, m_context);
+
+	parser.expect<std::string>(")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void Domain::checkConsistency()
 {
 	// Verify that typing requirement is correctly declared if used

src/plasp/pddl/Expression.cpp

@@ -2,6 +2,7 @@
 
 #include <plasp/pddl/Context.h>
 #include <plasp/pddl/Identifier.h>
+#include <plasp/pddl/expressions/NAryExpression.h>
 #include <plasp/utils/ParserException.h>
 
 namespace plasp
@@ -15,7 +16,7 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPtr parsePreconditionExpression(utils::Parser &parser, Context &context)
+std::unique_ptr<Expression> parsePreconditionExpression(utils::Parser &parser, Context &context)
 {
 	parser.skipWhiteSpace();
 
@@ -23,7 +24,7 @@ ExpressionPtr parsePreconditionExpression(utils::Parser &parser, Context &contex
 
 	const auto expressionIdentifier = parser.parseIdentifier(isIdentifier);
 
-	ExpressionPtr expression;
+	std::unique_ptr<Expression> expression;
 
 	throw utils::ParserException(parser.row(), parser.column(), "Expression of type \"" + expressionIdentifier + "\" not allowed in preference declaration");
 
@@ -31,6 +32,8 @@ ExpressionPtr parsePreconditionExpression(utils::Parser &parser, Context &contex
 	//	expression = NAry
 
 	parser.expect<std::string>(")");
+
+	return std::move(expression);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////