patrick/plasp
Archived
1
0
Fork 0
Code Issues 12 Releases 8 Activity

Refactored expressions to inherit from base class.

Browse Source
This commit is contained in:
Patrick Lühne 2016-06-02 16:28:08 +02:00
parent 97ab22461c
commit a07019801c
7 changed files with 75 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/plasp/pddl/Action.h
View File

@ -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;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

3
include/plasp/pddl/Context.h
View File

@ -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;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

3
include/plasp/pddl/Domain.h
View File

@ -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;

18
include/plasp/pddl/Expression.h
View File

@ -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);
////////////////////////////////////////////////////////////////////////////////////////////////////

49
src/plasp/pddl/Action.cpp
View File

@ -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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}

20
src/plasp/pddl/Domain.cpp
View File

@ -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

7
src/plasp/pddl/Expression.cpp
View File

@ -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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////