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

Refactoring to make parsing expressions consistent across PDDL domains and problems.

Browse Source
This commit is contained in:
Patrick Lühne
2016-06-07 13:26:19 +02:00
parent d5fa00a4a4
commit b612122180
32 changed files with 458 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -21,7 +21,7 @@ namespace pddl
class Action
{
public:
static Action &parseDeclaration(Context &context);
static void parseDeclaration(Context &context, Domain &domain);
public:
const std::string &name() const;

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

@@ -5,11 +5,6 @@
#include <unordered_map>
#include <vector>
#include <plasp/pddl/Action.h>
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/Constant.h>
#include <plasp/pddl/expressions/PredicateDeclaration.h>
#include <plasp/pddl/expressions/PrimitiveType.h>
#include <plasp/utils/Logger.h>
namespace plasp
@@ -33,17 +28,6 @@ class Context
utils::Parser &parser;
utils::Logger logger;
expressions::PrimitiveTypes primitiveTypes;
//std::unordered_map<std::string, expressions::PrimitiveType *> primitiveTypesHashMap;
expressions::Constants constants;
//std::unordered_map<std::string, expressions::Constant *> constantsHashMap;
expressions::PredicateDeclarations predicateDeclarations;
//std::unordered_map<expressions::PredicateHashMapKey, expressions::Predicate *> predicatesHashMap;
std::vector<std::unique_ptr<Action>> actions;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

2
include/plasp/pddl/Description.h
View File

@@ -33,6 +33,8 @@ class Description
void parseContent();
void parseSection();
void checkConsistency();
utils::Parser m_parser;
Context m_context;

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

@@ -1,8 +1,12 @@
#ifndef __PLASP__PDDL__DOMAIN_H
#define __PLASP__PDDL__DOMAIN_H
#include <plasp/pddl/Action.h>
#include <plasp/pddl/Context.h>
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/Constant.h>
#include <plasp/pddl/expressions/PredicateDeclaration.h>
#include <plasp/pddl/expressions/PrimitiveType.h>
#include <plasp/pddl/Requirement.h>
namespace plasp
@@ -19,19 +23,32 @@ namespace pddl
class Domain
{
public:
static Domain fromPDDL(Context &context);
public:
const std::string &name() const;
const Requirements &requirements() const;
const expressions::PrimitiveTypes &types() const;
const expressions::Constants &constants() const;
const expressions::PredicateDeclarations &predicates() const;
const std::vector<std::unique_ptr<Action>> &actions() const;
private:
Domain(Context &context);
public:
void readPDDL();
bool isDeclared() const;
const std::string &name() const;
const Requirements &requirements() const;
expressions::PrimitiveTypes &types();
const expressions::PrimitiveTypes &types() const;
expressions::Constants &constants();
const expressions::Constants &constants() const;
expressions::PredicateDeclarations &predicates();
const expressions::PredicateDeclarations &predicates() const;
std::vector<std::unique_ptr<Action>> &actions();
const std::vector<std::unique_ptr<Action>> &actions() const;
void checkConsistency();
private:
void parseSection();
void parseRequirementSection();
@@ -46,12 +63,15 @@ class Domain
void parseActionSection();
void checkConsistency();
Context &m_context;
bool m_isDeclared;
std::string m_name;
Requirements m_requirements;
expressions::PrimitiveTypes m_primitiveTypes;
expressions::Constants m_constants;
expressions::PredicateDeclarations m_predicateDeclarations;
std::vector<std::unique_ptr<Action>> m_actions;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

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

@@ -17,7 +17,10 @@ namespace pddl
////////////////////////////////////////////////////////////////////////////////////////////////////
class Context;
class Domain;
class ExpressionContext;
class ExpressionVisitor;
class Problem;
class Expression;
using ExpressionPointer = std::unique_ptr<Expression>;
@@ -77,10 +80,11 @@ class Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parsePreconditionExpression(Context &context,
const expressions::Variables &parameters);
ExpressionPointer parseExpression(Context &context, const expressions::Variables &parameters);
ExpressionContext &expressionContext);
ExpressionPointer parseExpression(Context &context, ExpressionContext &expressionContext);
ExpressionPointer parseEffectExpression(Context &context, const expressions::Variables &parameters);
ExpressionPointer parseEffectExpression(Context &context,
ExpressionContext &expressionContext);
////////////////////////////////////////////////////////////////////////////////////////////////////

46
include/plasp/pddl/ExpressionContext.h Normal file
View File

@@ -0,0 +1,46 @@
#ifndef __PLASP__PDDL__EXPRESSION_CONTEXT_H
#define __PLASP__PDDL__EXPRESSION_CONTEXT_H
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/Requirement.h>
namespace plasp
{
namespace pddl
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ExpressionContext
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class ExpressionContext
{
public:
ExpressionContext(Domain &domain, expressions::Variables &parameters)
: domain(domain),
problem(nullptr),
parameters(parameters)
{
}
ExpressionContext(Domain &domain, Problem *problem, expressions::Variables &parameters)
: domain(domain),
problem{problem},
parameters(parameters)
{
}
Domain &domain;
Problem *problem;
expressions::Variables &parameters;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
#endif

22
include/plasp/pddl/Problem.h
View File

@@ -19,15 +19,25 @@ namespace pddl
class Problem
{
public:
static Problem fromPDDL(Context &context);
Problem(Context &context, Domain &domain);
void readPDDL();
bool isDeclared() const;
Domain &domain();
const Domain &domain() const;
public:
const std::string &name() const;
const Requirements &requirements() const;
private:
Problem(Context &context);
expressions::Constants &objects();
const expressions::Constants &objects() const;
void checkConsistency();
private:
void parseSection();
void parseRequirementSection();
@@ -36,9 +46,9 @@ class Problem
void parseObjectSection();
void checkConsistency();
Context &m_context;
Domain &m_domain;
bool m_isDeclared;
std::string m_name;
Requirements m_requirements;

6
include/plasp/pddl/expressions/And.h
View File

@@ -20,7 +20,7 @@ class And: public NAry
{
public:
template<typename ExpressionParser>
static AndPointer parse(Context &context, const Variables &parameters,
static AndPointer parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression);
public:
@@ -33,12 +33,12 @@ class And: public NAry
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
AndPointer And::parse(Context &context, const Variables &parameters,
AndPointer And::parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression)
{
auto expression = std::make_unique<And>(And());
expression->NAry::parse(context, parameters, parseExpression);
expression->NAry::parse(context, expressionContext, parseExpression);
if (expression->arguments().empty())
throw ConsistencyException("\"and\" expressions should not be empty");

10
include/plasp/pddl/expressions/Binary.h
View File

@@ -27,7 +27,8 @@ class Binary: public Expression
protected:
template<typename ExpressionParser>
void parse(Context &context, const Variables &parameters, ExpressionParser parseExpression);
void parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression);
private:
ExpressionPointer m_leftArgument;
@@ -37,12 +38,13 @@ class Binary: public Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
void Binary::parse(Context &context, const Variables &parameters, ExpressionParser parseExpression)
void Binary::parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression)
{
// Assume that expression identifier (imply, exists, etc.) is already parsed
// Parse arguments of the expression
m_leftArgument = parseExpression(context, parameters);
m_rightArgument = parseExpression(context, parameters);
m_leftArgument = parseExpression(context, expressionContext);
m_rightArgument = parseExpression(context, expressionContext);
}
////////////////////////////////////////////////////////////////////////////////////////////////////

11
include/plasp/pddl/expressions/Constant.h
View File

@@ -22,10 +22,10 @@ namespace expressions
class Constant: public Expression
{
public:
static ConstantPointer parseDeclaration(Context &context);
static void parseTypedDeclaration(Context &context, Constants &constants);
static void parseTypedDeclaration(Context &context, Domain &domain);
static void parseTypedDeclaration(Context &context, Problem &problem);
static Constant *parseExisting(Context &context);
static Constant *parseAndFind(Context &context, const ExpressionContext &expressionContext);
// TODO: method for lazy creation if not existing
@@ -38,6 +38,11 @@ class Constant: public Expression
bool isDeclared() const;
private:
static ConstantPointer parseDeclaration(Context &context);
static void parseTypedDeclaration(Context &context, Domain &domain, Constants &constants);
static Constant *parseAndFind(const std::string &constantName, const Constants &constants);
Constant();
void setDirty(bool isDirty = true);

6
include/plasp/pddl/expressions/Either.h
View File

@@ -20,7 +20,7 @@ class Either: public NAry
{
public:
template<typename ExpressionParser>
static EitherPointer parse(Context &context, const Variables &parameters,
static EitherPointer parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression);
public:
@@ -33,12 +33,12 @@ class Either: public NAry
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
EitherPointer Either::parse(Context &context, const Variables &parameters,
EitherPointer Either::parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression)
{
auto expression = std::make_unique<Either>(Either());
expression->NAry::parse(context, parameters, parseExpression);
expression->NAry::parse(context, expressionContext, parseExpression);
if (expression->arguments().empty())
throw ConsistencyException("\"and\" expressions should not be empty");

4
include/plasp/pddl/expressions/Imply.h
View File

@@ -20,7 +20,7 @@ class Imply: public Binary
{
public:
template<typename ExpressionParser>
static ImplyPointer parse(Context &context, const Variables &parameters,
static ImplyPointer parse(Context &context, ExpressionContext &parameters,
ExpressionParser parseExpression);
public:
@@ -33,7 +33,7 @@ class Imply: public Binary
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
ImplyPointer Imply::parse(Context &context, const Variables &parameters,
ImplyPointer Imply::parse(Context &context, ExpressionContext &parameters,
ExpressionParser parseExpression)
{
auto expression = std::make_unique<Imply>(Imply());

6
include/plasp/pddl/expressions/NAry.h
View File

@@ -26,7 +26,7 @@ class NAry: public Expression
protected:
template<typename ExpressionParser>
void parse(Context &context, const Variables &parameters, ExpressionParser parseExpression);
void parse(Context &context, ExpressionContext &expressionContext, ExpressionParser parseExpression);
private:
Expressions m_arguments;
@@ -35,7 +35,7 @@ class NAry: public Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
void NAry::parse(Context &context, const Variables &parameters, ExpressionParser parseExpression)
void NAry::parse(Context &context, ExpressionContext &expressionContext, ExpressionParser parseExpression)
{
context.parser.skipWhiteSpace();
@@ -43,7 +43,7 @@ void NAry::parse(Context &context, const Variables &parameters, ExpressionParser
// Parse arguments of the expression
while (context.parser.currentCharacter() != ')')
{
m_arguments.emplace_back(parseExpression(context, parameters));
m_arguments.emplace_back(parseExpression(context, expressionContext));
context.parser.skipWhiteSpace();
}

6
include/plasp/pddl/expressions/Not.h
View File

@@ -21,7 +21,7 @@ class Not: public Expression
{
public:
template<typename ExpressionParser>
static NotPointer parse(Context &context, const Variables &parameters,
static NotPointer parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression);
public:
@@ -38,7 +38,7 @@ class Not: public Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
NotPointer Not::parse(Context &context, const Variables &parameters,
NotPointer Not::parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression)
{
auto expression = std::make_unique<Not>(Not());
@@ -46,7 +46,7 @@ NotPointer Not::parse(Context &context, const Variables &parameters,
context.parser.skipWhiteSpace();
// Parse argument
expression->m_argument = parseExpression(context, parameters);
expression->m_argument = parseExpression(context, expressionContext);
return expression;
}

7
include/plasp/pddl/expressions/Or.h
View File

@@ -20,7 +20,7 @@ class Or: public NAry
{
public:
template<typename ExpressionParser>
static OrPointer parse(Context &context, const Variables &parameters,
static OrPointer parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression);
public:
@@ -33,11 +33,12 @@ class Or: public NAry
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
OrPointer Or::parse(Context &context, const Variables &parameters, ExpressionParser parseExpression)
OrPointer Or::parse(Context &context, ExpressionContext &expressionContext,
ExpressionParser parseExpression)
{
auto expression = std::make_unique<Or>(Or());
expression->NAry::parse(context, parameters, parseExpression);
expression->NAry::parse(context, expressionContext, parseExpression);
if (expression->arguments().empty())
throw ConsistencyException("\"or\" expressions should not be empty");

2
include/plasp/pddl/expressions/Predicate.h
View File

@@ -20,7 +20,7 @@ class Predicate: public Expression
{
public:
static PredicatePointer parse(std::string name, Context &context,
const Variables &parameters);
ExpressionContext &expressionContext);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;

4
include/plasp/pddl/expressions/PredicateDeclaration.h
View File

@@ -19,7 +19,7 @@ namespace expressions
class PredicateDeclaration: public Expression
{
public:
static void parse(Context &context);
static void parse(Context &context, Domain &domain);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -37,7 +37,7 @@ class PredicateDeclaration: public Expression
bool m_isDeclared;
std::string m_name;
Variables m_arguments;
Variables m_parameters;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

14
include/plasp/pddl/expressions/PrimitiveType.h
View File

@@ -22,12 +22,15 @@ namespace expressions
class PrimitiveType: public Expression
{
public:
static PrimitiveType *parseDeclaration(Context &context);
static void parseTypedDeclaration(Context &context);
static void parseDeclaration(Context &context, Domain &domain);
static void parseTypedDeclaration(Context &context, Domain &domain);
static PrimitiveType *parseExisting(Context &context);
static PrimitiveType *parseAndFindOrCreate(Context &context, Domain &domain);
public:
PrimitiveType();
PrimitiveType(std::string name);
void accept(ExpressionVisitor &expressionVisitor) const override;
const std::string &name() const;
@@ -36,11 +39,6 @@ class PrimitiveType: public Expression
bool isDeclared() const;
private:
static PrimitiveType *create(std::string name, Context &context);
private:
PrimitiveType();
void setDirty(bool isDirty = true);
bool isDirty() const;

3
include/plasp/pddl/expressions/Type.h
View File

@@ -16,7 +16,8 @@ namespace expressions
//
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parseExistingPrimitiveType(Context &context, const Variables &parameters);
ExpressionPointer parseExistingPrimitiveType(Context &context,
ExpressionContext &expressionContext);
////////////////////////////////////////////////////////////////////////////////////////////////////

9
include/plasp/pddl/expressions/Variable.h
View File

@@ -19,11 +19,9 @@ namespace expressions
class Variable: public Expression
{
public:
static VariablePointer parseDeclaration(Context &context);
static void parseTypedDeclaration(Context &context, ExpressionContext &expressionContext);
static void parseTypedDeclaration(Context &context, Variables &parameters);
static const Variable *parseExisting(Context &context, const Variables &variables);
static const Variable *parseAndFind(Context &context, const ExpressionContext &expressionContext);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -36,6 +34,9 @@ class Variable: public Expression
void setType(const Expression *type);
private:
static void parseDeclaration(Context &context, Variables &parameters);
private:
Variable();