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

Shortened Expression class names.

Browse Source
This commit is contained in:
Patrick Lühne 2016-06-03 13:33:05 +02:00
parent d334b4150b
commit 133aa051eb
16 changed files with 142 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -4,7 +4,7 @@
#include <vector> #include <vector>
#include <plasp/pddl/Expression.h> #include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/VariableExpression.h> #include <plasp/pddl/expressions/Variable.h>
#include <plasp/utils/Parser.h> #include <plasp/utils/Parser.h>
namespace plasp namespace plasp
@ -26,7 +26,7 @@ class Action
public: public:
const std::string &name() const; const std::string &name() const;
const expressions::VariableExpressions &parameters() const; const expressions::Variables &parameters() const;
const Expression &precondition() const; const Expression &precondition() const;
const Expression &effect() const; const Expression &effect() const;
@ -35,7 +35,7 @@ class Action
std::string m_name; std::string m_name;
expressions::VariableExpressions m_parameters; expressions::Variables m_parameters;
std::unique_ptr<Expression> m_precondition; std::unique_ptr<Expression> m_precondition;
std::unique_ptr<Expression> m_effect; std::unique_ptr<Expression> m_effect;
}; };

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

@ -28,21 +28,21 @@ using Expressions = std::vector<ExpressionPointer>;
namespace expressions namespace expressions
{ {
class AndExpression; class And;
using AndExpressionPointer = std::unique_ptr<AndExpression>; using AndPointer = std::unique_ptr<And>;
class NotExpression; class Not;
using NotExpressionPointer = std::unique_ptr<NotExpression>; using NotPointer = std::unique_ptr<Not>;
class OrExpression; class Or;
using OrExpressionPointer = std::unique_ptr<OrExpression>; using OrPointer = std::unique_ptr<Or>;
class PredicateExpression; class Predicate;
using PredicateExpressionPointer = std::unique_ptr<PredicateExpression>; using PredicatePointer = std::unique_ptr<Predicate>;
class VariableExpression; class Variable;
using VariableExpressionPointer = std::unique_ptr<VariableExpression>; using VariablePointer = std::unique_ptr<Variable>;
using VariableExpressions = std::vector<VariableExpressionPointer>; using Variables = std::vector<VariablePointer>;
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
@ -56,12 +56,12 @@ class Expression
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &context, ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters); const expressions::Variables &parameters);
ExpressionPointer parseExpression(utils::Parser &parser, Context &context, ExpressionPointer parseExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters); const expressions::Variables &parameters);
ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context, ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters); const expressions::Variables &parameters);
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////

24
include/plasp/pddl/expressions/AndExpression.h → include/plasp/pddl/expressions/And.h
View File

@ -1,7 +1,7 @@
#ifndef __PLASP__PDDL__EXPRESSION__AND_EXPRESSION_H #ifndef __PLASP__PDDL__EXPRESSION__AND_H
#define __PLASP__PDDL__EXPRESSION__AND_EXPRESSION_H #define __PLASP__PDDL__EXPRESSION__AND_H
#include <plasp/pddl/expressions/NAryExpression.h> #include <plasp/pddl/expressions/NAry.h>
namespace plasp namespace plasp
{ {
@ -12,33 +12,33 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// AndExpression // And
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
class AndExpression: public NAryExpression class And: public NAry
{ {
public: public:
template<typename ExpressionParser> template<typename ExpressionParser>
static AndExpressionPointer parse(utils::Parser &parser, Context &context, static AndPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression); const Variables &parameters, ExpressionParser parseExpression);
public: public:
void accept(ExpressionVisitor &expressionVisitor) const override; void accept(ExpressionVisitor &expressionVisitor) const override;
private: private:
AndExpression() = default; And() = default;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser> template<typename ExpressionParser>
AndExpressionPointer AndExpression::parse(utils::Parser &parser, Context &context, AndPointer And::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression) const Variables &parameters, ExpressionParser parseExpression)
{ {
auto expression = std::make_unique<AndExpression>(AndExpression()); auto expression = std::make_unique<And>(And());
expression->NAryExpression::parse(parser, context, parameters, parseExpression); expression->NAry::parse(parser, context, parameters, parseExpression);
if (expression->arguments().empty()) if (expression->arguments().empty())
throw ConsistencyException("\"and\" expressions should not be empty"); throw ConsistencyException("\"and\" expressions should not be empty");

16
include/plasp/pddl/expressions/NAryExpression.h → include/plasp/pddl/expressions/NAry.h
View File

@ -1,5 +1,5 @@
#ifndef __PLASP__PDDL__EXPRESSION__N_ARY_EXPRESSION_H #ifndef __PLASP__PDDL__EXPRESSION__N_ARY_H
#define __PLASP__PDDL__EXPRESSION__N_ARY_EXPRESSION_H #define __PLASP__PDDL__EXPRESSION__N_ARY_H
#include <memory> #include <memory>
#include <string> #include <string>
@ -7,7 +7,7 @@
#include <plasp/pddl/ConsistencyException.h> #include <plasp/pddl/ConsistencyException.h>
#include <plasp/pddl/Expression.h> #include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/VariableExpression.h> #include <plasp/pddl/expressions/Variable.h>
#include <plasp/utils/Parser.h> #include <plasp/utils/Parser.h>
namespace plasp namespace plasp
@ -19,18 +19,18 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// NAryExpression // NAry
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
class NAryExpression: public Expression class NAry: public Expression
{ {
public: public:
const Expressions &arguments() const; const Expressions &arguments() const;
protected: protected:
template<typename ExpressionParser> template<typename ExpressionParser>
void parse(utils::Parser &parser, Context &context, const VariableExpressions &parameters, void parse(utils::Parser &parser, Context &context, const Variables &parameters,
ExpressionParser parseExpression); ExpressionParser parseExpression);
private: private:
@ -40,8 +40,8 @@ class NAryExpression: public Expression
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser> template<typename ExpressionParser>
void NAryExpression::parse(utils::Parser &parser, Context &context, void NAry::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression) const Variables &parameters, ExpressionParser parseExpression)
{ {
parser.skipWhiteSpace(); parser.skipWhiteSpace();

20
include/plasp/pddl/expressions/NotExpression.h → include/plasp/pddl/expressions/Not.h
View File

@ -1,5 +1,5 @@
#ifndef __PLASP__PDDL__EXPRESSION__NOT_EXPRESSION_H #ifndef __PLASP__PDDL__EXPRESSION__NOT_H
#define __PLASP__PDDL__EXPRESSION__NOT_EXPRESSION_H #define __PLASP__PDDL__EXPRESSION__NOT_H
#include <plasp/pddl/Expression.h> #include <plasp/pddl/Expression.h>
#include <plasp/pddl/Predicate.h> #include <plasp/pddl/Predicate.h>
@ -13,16 +13,16 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// NotExpression // Not
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
class NotExpression: public Expression class Not: public Expression
{ {
public: public:
template<typename ExpressionParser> template<typename ExpressionParser>
static NotExpressionPointer parse(utils::Parser &parser, Context &context, static NotPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression); const Variables &parameters, ExpressionParser parseExpression);
public: public:
void accept(ExpressionVisitor &expressionVisitor) const override; void accept(ExpressionVisitor &expressionVisitor) const override;
@ -30,7 +30,7 @@ class NotExpression: public Expression
const Expression &argument(); const Expression &argument();
private: private:
NotExpression() = default; Not() = default;
ExpressionPointer m_argument; ExpressionPointer m_argument;
}; };
@ -38,10 +38,10 @@ class NotExpression: public Expression
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser> template<typename ExpressionParser>
NotExpressionPointer NotExpression::parse(utils::Parser &parser, Context &context, NotPointer Not::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression) const Variables &parameters, ExpressionParser parseExpression)
{ {
auto expression = std::make_unique<NotExpression>(NotExpression()); auto expression = std::make_unique<Not>(Not());
parser.skipWhiteSpace(); parser.skipWhiteSpace();

24
include/plasp/pddl/expressions/OrExpression.h → include/plasp/pddl/expressions/Or.h
View File

@ -1,7 +1,7 @@
#ifndef __PLASP__PDDL__EXPRESSION__OR_EXPRESSION_H #ifndef __PLASP__PDDL__EXPRESSION__OR_H
#define __PLASP__PDDL__EXPRESSION__OR_EXPRESSION_H #define __PLASP__PDDL__EXPRESSION__OR_H
#include <plasp/pddl/expressions/NAryExpression.h> #include <plasp/pddl/expressions/NAry.h>
namespace plasp namespace plasp
{ {
@ -12,33 +12,33 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// OrExpression // Or
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
class OrExpression: public NAryExpression class Or: public NAry
{ {
public: public:
template<typename ExpressionParser> template<typename ExpressionParser>
static OrExpressionPointer parse(utils::Parser &parser, Context &context, static OrPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression); const Variables &parameters, ExpressionParser parseExpression);
public: public:
void accept(ExpressionVisitor &expressionVisitor) const override; void accept(ExpressionVisitor &expressionVisitor) const override;
private: private:
OrExpression() = default; Or() = default;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser> template<typename ExpressionParser>
OrExpressionPointer OrExpression::parse(utils::Parser &parser, Context &context, OrPointer Or::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression) const Variables &parameters, ExpressionParser parseExpression)
{ {
auto expression = std::make_unique<OrExpression>(OrExpression()); auto expression = std::make_unique<Or>(Or());
expression->NAryExpression::parse(parser, context, parameters, parseExpression); expression->NAry::parse(parser, context, parameters, parseExpression);
if (expression->arguments().empty()) if (expression->arguments().empty())
throw ConsistencyException("\"or\" expressions should not be empty"); throw ConsistencyException("\"or\" expressions should not be empty");

20
include/plasp/pddl/expressions/PredicateExpression.h → include/plasp/pddl/expressions/Predicate.h
View File

@ -1,9 +1,9 @@
#ifndef __PLASP__PDDL__EXPRESSION__PREDICATE_EXPRESSION_H #ifndef __PLASP__PDDL__EXPRESSION__PREDICATE_H
#define __PLASP__PDDL__EXPRESSION__PREDICATE_EXPRESSION_H #define __PLASP__PDDL__EXPRESSION__PREDICATE_H
#include <plasp/pddl/Expression.h> #include <plasp/pddl/Expression.h>
#include <plasp/pddl/Predicate.h> #include <plasp/pddl/Predicate.h>
#include <plasp/pddl/expressions/VariableExpression.h> #include <plasp/pddl/expressions/Variable.h>
namespace plasp namespace plasp
{ {
@ -14,26 +14,26 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// PredicateExpression // Predicate
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
class PredicateExpression: public Expression class Predicate: public Expression
{ {
public: public:
static PredicateExpressionPointer parse(std::string name, utils::Parser &parser, static PredicatePointer parse(std::string name, utils::Parser &parser,
Context &context, const VariableExpressions &parameters); Context &context, const Variables &parameters);
public: public:
void accept(ExpressionVisitor &expressionVisitor) const override; void accept(ExpressionVisitor &expressionVisitor) const override;
const std::vector<const VariableExpression *> &arguments() const; const std::vector<const Variable *> &arguments() const;
private: private:
PredicateExpression() = default; Predicate() = default;
std::string m_name; std::string m_name;
std::vector<const VariableExpression *> m_arguments; std::vector<const Variable *> m_arguments;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////

17
include/plasp/pddl/expressions/VariableExpression.h → include/plasp/pddl/expressions/Variable.h
View File

@ -1,5 +1,5 @@
#ifndef __PLASP__PDDL__EXPRESSION__VARIABLE_EXPRESSION_H #ifndef __PLASP__PDDL__EXPRESSION__VARIABLE_H
#define __PLASP__PDDL__EXPRESSION__VARIABLE_EXPRESSION_H #define __PLASP__PDDL__EXPRESSION__VARIABLE_H
#include <plasp/pddl/Expression.h> #include <plasp/pddl/Expression.h>
@ -12,19 +12,18 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// VariableExpression // Variable
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
class VariableExpression: public Expression class Variable: public Expression
{ {
public: public:
static VariableExpressionPointer parseDeclaration(utils::Parser &parser); static VariablePointer parseDeclaration(utils::Parser &parser);
static void parseTypedDeclaration(utils::Parser &parser, Context &context, static void parseTypedDeclaration(utils::Parser &parser, Context &context,
VariableExpressions &variableExpressions); Variables &variables);
static const VariableExpression *parse(utils::Parser &parser, static const Variable *parse(utils::Parser &parser, const Variables &variables);
const VariableExpressions &variableExpressions);
public: public:
void accept(ExpressionVisitor &expressionVisitor) const override; void accept(ExpressionVisitor &expressionVisitor) const override;
@ -38,7 +37,7 @@ class VariableExpression: public Expression
void setType(TypePtr type); void setType(TypePtr type);
private: private:
VariableExpression(); Variable();
bool m_isDirty; bool m_isDirty;

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

@ -37,7 +37,7 @@ Action &Action::parseDeclaration(utils::Parser &parser, Context &context)
// Read parameters // Read parameters
while (parser.currentCharacter() != ')') while (parser.currentCharacter() != ')')
{ {
expressions::VariableExpression::parseTypedDeclaration(parser, context, action->m_parameters); expressions::Variable::parseTypedDeclaration(parser, context, action->m_parameters);
parser.skipWhiteSpace(); parser.skipWhiteSpace();
} }
@ -74,7 +74,7 @@ const std::string &Action::name() const
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
const expressions::VariableExpressions &Action::parameters() const const expressions::Variables &Action::parameters() const
{ {
return m_parameters; return m_parameters;
} }

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

@ -2,10 +2,10 @@
#include <plasp/pddl/Context.h> #include <plasp/pddl/Context.h>
#include <plasp/pddl/Identifier.h> #include <plasp/pddl/Identifier.h>
#include <plasp/pddl/expressions/AndExpression.h> #include <plasp/pddl/expressions/And.h>
#include <plasp/pddl/expressions/NotExpression.h> #include <plasp/pddl/expressions/Not.h>
#include <plasp/pddl/expressions/OrExpression.h> #include <plasp/pddl/expressions/Or.h>
#include <plasp/pddl/expressions/PredicateExpression.h> #include <plasp/pddl/expressions/Predicate.h>
#include <plasp/utils/ParserException.h> #include <plasp/utils/ParserException.h>
namespace plasp namespace plasp
@ -20,11 +20,11 @@ namespace pddl
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parseExpressionContent(const std::string &expressionIdentifier, ExpressionPointer parseExpressionContent(const std::string &expressionIdentifier,
utils::Parser &parser, Context &context, const expressions::VariableExpressions &parameters); utils::Parser &parser, Context &context, const expressions::Variables &parameters);
ExpressionPointer parseEffectBodyExpressionContent(const std::string &expressionIdentifier, ExpressionPointer parseEffectBodyExpressionContent(const std::string &expressionIdentifier,
utils::Parser &parser, Context &context, const expressions::VariableExpressions &parameters); utils::Parser &parser, Context &context, const expressions::Variables &parameters);
ExpressionPointer parsePredicateExpression(utils::Parser &parser, Context &context, ExpressionPointer parsePredicate(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters); const expressions::Variables &parameters);
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
@ -36,7 +36,7 @@ void throwUnsupported(const utils::Parser &parser, const std::string &expression
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &context, ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters) const expressions::Variables &parameters)
{ {
parser.expect<std::string>("("); parser.expect<std::string>("(");
@ -46,7 +46,7 @@ ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &co
if (expressionIdentifier == "and") if (expressionIdentifier == "and")
{ {
expression = expressions::AndExpression::parse(parser, context, parameters, expression = expressions::And::parse(parser, context, parameters,
parsePreconditionExpression); parsePreconditionExpression);
} }
else if (expressionIdentifier == "forall" else if (expressionIdentifier == "forall"
@ -65,7 +65,7 @@ ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &co
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parseExpression(utils::Parser &parser, Context &context, ExpressionPointer parseExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters) const expressions::Variables &parameters)
{ {
parser.expect<std::string>("("); parser.expect<std::string>("(");
@ -81,18 +81,18 @@ ExpressionPointer parseExpression(utils::Parser &parser, Context &context,
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parseExpressionContent(const std::string &expressionIdentifier, ExpressionPointer parseExpressionContent(const std::string &expressionIdentifier,
utils::Parser &parser, Context &context, const expressions::VariableExpressions &parameters) utils::Parser &parser, Context &context, const expressions::Variables &parameters)
{ {
parser.skipWhiteSpace(); parser.skipWhiteSpace();
ExpressionPointer expression; ExpressionPointer expression;
if (expressionIdentifier == "and") if (expressionIdentifier == "and")
expression = expressions::AndExpression::parse(parser, context, parameters, parseExpression); expression = expressions::And::parse(parser, context, parameters, parseExpression);
else if (expressionIdentifier == "or") else if (expressionIdentifier == "or")
expression = expressions::OrExpression::parse(parser, context, parameters, parseExpression); expression = expressions::Or::parse(parser, context, parameters, parseExpression);
else if (expressionIdentifier == "not") else if (expressionIdentifier == "not")
expression = expressions::NotExpression::parse(parser, context, parameters, parseExpression); expression = expressions::Not::parse(parser, context, parameters, parseExpression);
else if (expressionIdentifier == "imply" else if (expressionIdentifier == "imply"
|| expressionIdentifier == "exists" || expressionIdentifier == "exists"
|| expressionIdentifier == "forall" || expressionIdentifier == "forall"
@ -121,7 +121,7 @@ ExpressionPointer parseExpressionContent(const std::string &expressionIdentifier
// If predicate exists, parse it // If predicate exists, parse it
if (match != context.predicates.cend()) if (match != context.predicates.cend())
expression = expressions::PredicateExpression::parse(expressionIdentifier, parser, context, parameters); expression = expressions::Predicate::parse(expressionIdentifier, parser, context, parameters);
else else
throw utils::ParserException(parser.row(), parser.column(), "Expression \"" + expressionIdentifier + "\" not allowed in this context"); throw utils::ParserException(parser.row(), parser.column(), "Expression \"" + expressionIdentifier + "\" not allowed in this context");
} }
@ -132,7 +132,7 @@ ExpressionPointer parseExpressionContent(const std::string &expressionIdentifier
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context, ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters) const expressions::Variables &parameters)
{ {
parser.expect<std::string>("("); parser.expect<std::string>("(");
@ -141,7 +141,7 @@ ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context,
ExpressionPointer expression; ExpressionPointer expression;
if (expressionIdentifier == "and") if (expressionIdentifier == "and")
expression = expressions::AndExpression::parse(parser, context, parameters, parseEffectExpression); expression = expressions::And::parse(parser, context, parameters, parseEffectExpression);
else if (expressionIdentifier == "forall" else if (expressionIdentifier == "forall"
|| expressionIdentifier == "when") || expressionIdentifier == "when")
{ {
@ -158,12 +158,12 @@ ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context,
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parseEffectBodyExpressionContent(const std::string &expressionIdentifier, ExpressionPointer parseEffectBodyExpressionContent(const std::string &expressionIdentifier,
utils::Parser &parser, Context &context, const expressions::VariableExpressions &parameters) utils::Parser &parser, Context &context, const expressions::Variables &parameters)
{ {
ExpressionPointer expression; ExpressionPointer expression;
if (expressionIdentifier == "not") if (expressionIdentifier == "not")
expression = expressions::NotExpression::parse(parser, context, parameters, parsePredicateExpression); expression = expressions::Not::parse(parser, context, parameters, parsePredicate);
else if (expressionIdentifier == "=" else if (expressionIdentifier == "="
|| expressionIdentifier == "assign" || expressionIdentifier == "assign"
|| expressionIdentifier == "scale-up" || expressionIdentifier == "scale-up"
@ -184,7 +184,7 @@ ExpressionPointer parseEffectBodyExpressionContent(const std::string &expression
// If predicate exists, parse it // If predicate exists, parse it
if (match != context.predicates.cend()) if (match != context.predicates.cend())
expression = expressions::PredicateExpression::parse(expressionIdentifier, parser, context, parameters); expression = expressions::Predicate::parse(expressionIdentifier, parser, context, parameters);
else else
throw utils::ParserException(parser.row(), parser.column(), "Expression \"" + expressionIdentifier + "\" not allowed in this context"); throw utils::ParserException(parser.row(), parser.column(), "Expression \"" + expressionIdentifier + "\" not allowed in this context");
} }
@ -194,8 +194,8 @@ ExpressionPointer parseEffectBodyExpressionContent(const std::string &expression
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parsePredicateExpression(utils::Parser &parser, Context &context, ExpressionPointer parsePredicate(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters) const expressions::Variables &parameters)
{ {
parser.expect<std::string>("("); parser.expect<std::string>("(");
@ -214,7 +214,7 @@ ExpressionPointer parsePredicateExpression(utils::Parser &parser, Context &conte
if (match == context.predicates.cend()) if (match == context.predicates.cend())
throw utils::ParserException(parser.row(), parser.column(), "Unknown predicate \"" + predicateName + "\""); throw utils::ParserException(parser.row(), parser.column(), "Unknown predicate \"" + predicateName + "\"");
expression = expressions::PredicateExpression::parse(predicateName, parser, context, parameters); expression = expressions::Predicate::parse(predicateName, parser, context, parameters);
parser.expect<std::string>(")"); parser.expect<std::string>(")");

6
src/plasp/pddl/expressions/OrExpression.cpp → src/plasp/pddl/expressions/And.cpp
View File

@ -1,4 +1,4 @@
#include <plasp/pddl/expressions/OrExpression.h> #include <plasp/pddl/expressions/And.h>
#include <plasp/pddl/ExpressionVisitor.h> #include <plasp/pddl/ExpressionVisitor.h>
@ -11,11 +11,11 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// OrExpression // And
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void OrExpression::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const void And::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const
{ {
expressionVisitor.visit(*this); expressionVisitor.visit(*this);
} }

6
src/plasp/pddl/expressions/NAryExpression.cpp → src/plasp/pddl/expressions/NAry.cpp
View File

@ -1,4 +1,4 @@
#include <plasp/pddl/expressions/NAryExpression.h> #include <plasp/pddl/expressions/NAry.h>
#include <algorithm> #include <algorithm>
@ -15,11 +15,11 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// NAryExpression // NAry
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
const std::vector<std::unique_ptr<Expression>> &NAryExpression::arguments() const const Expressions &NAry::arguments() const
{ {
return m_arguments; return m_arguments;
} }

6
src/plasp/pddl/expressions/AndExpression.cpp → src/plasp/pddl/expressions/Not.cpp
View File

@ -1,4 +1,4 @@
#include <plasp/pddl/expressions/AndExpression.h> #include <plasp/pddl/expressions/Not.h>
#include <plasp/pddl/ExpressionVisitor.h> #include <plasp/pddl/ExpressionVisitor.h>
@ -11,11 +11,11 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// AndExpression // Not
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void AndExpression::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const void Not::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const
{ {
expressionVisitor.visit(*this); expressionVisitor.visit(*this);
} }

6
src/plasp/pddl/expressions/NotExpression.cpp → src/plasp/pddl/expressions/Or.cpp
View File

@ -1,4 +1,4 @@
#include <plasp/pddl/expressions/NotExpression.h> #include <plasp/pddl/expressions/Or.h>
#include <plasp/pddl/ExpressionVisitor.h> #include <plasp/pddl/ExpressionVisitor.h>
@ -11,11 +11,11 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// NotExpression // Or
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void NotExpression::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const void Or::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const
{ {
expressionVisitor.visit(*this); expressionVisitor.visit(*this);
} }

16
src/plasp/pddl/expressions/PredicateExpression.cpp → src/plasp/pddl/expressions/Predicate.cpp
View File

@ -1,4 +1,4 @@
#include <plasp/pddl/expressions/PredicateExpression.h> #include <plasp/pddl/expressions/Predicate.h>
#include <plasp/pddl/ExpressionVisitor.h> #include <plasp/pddl/ExpressionVisitor.h>
@ -11,14 +11,14 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// PredicateExpression // Predicate
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
PredicateExpressionPointer PredicateExpression::parse(std::string name, utils::Parser &parser, PredicatePointer Predicate::parse(std::string name, utils::Parser &parser,
Context &context, const VariableExpressions &parameters) Context &context, const Variables &parameters)
{ {
auto expression = std::make_unique<PredicateExpression>(PredicateExpression()); auto expression = std::make_unique<Predicate>(Predicate());
expression->m_name = name; expression->m_name = name;
@ -26,7 +26,7 @@ PredicateExpressionPointer PredicateExpression::parse(std::string name, utils::P
// Parse arguments // Parse arguments
while (parser.currentCharacter() != ')') while (parser.currentCharacter() != ')')
expression->m_arguments.emplace_back(VariableExpression::parse(parser, parameters)); expression->m_arguments.emplace_back(Variable::parse(parser, parameters));
// TODO: check that signature matches one of the declared ones // TODO: check that signature matches one of the declared ones
@ -35,14 +35,14 @@ PredicateExpressionPointer PredicateExpression::parse(std::string name, utils::P
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void PredicateExpression::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const void Predicate::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const
{ {
expressionVisitor.visit(*this); expressionVisitor.visit(*this);
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
const std::vector<const VariableExpression *> &PredicateExpression::arguments() const const std::vector<const Variable *> &Predicate::arguments() const
{ {
return m_arguments; return m_arguments;
} }

40
src/plasp/pddl/expressions/VariableExpression.cpp → src/plasp/pddl/expressions/Variable.cpp
View File

@ -1,4 +1,4 @@
#include <plasp/pddl/expressions/VariableExpression.h> #include <plasp/pddl/expressions/Variable.h>
#include <algorithm> #include <algorithm>
@ -16,24 +16,24 @@ namespace expressions
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// VariableExpression // Variable
// //
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
VariableExpression::VariableExpression() Variable::Variable()
: m_isDirty{false} : m_isDirty{false}
{ {
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
VariableExpressionPointer VariableExpression::parseDeclaration(utils::Parser &parser) VariablePointer Variable::parseDeclaration(utils::Parser &parser)
{ {
parser.skipWhiteSpace(); parser.skipWhiteSpace();
parser.expect<std::string>("?"); parser.expect<std::string>("?");
auto variable = std::make_unique<VariableExpression>(VariableExpression()); auto variable = std::make_unique<Variable>(Variable());
variable->m_name = parser.parseIdentifier(isIdentifier); variable->m_name = parser.parseIdentifier(isIdentifier);
variable->setDirty(); variable->setDirty();
@ -43,11 +43,10 @@ VariableExpressionPointer VariableExpression::parseDeclaration(utils::Parser &pa
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void VariableExpression::parseTypedDeclaration(utils::Parser &parser, Context &context, void Variable::parseTypedDeclaration(utils::Parser &parser, Context &context, Variables &variables)
VariableExpressions &variableExpressions)
{ {
// Parse and store variable itself // Parse and store variable itself
variableExpressions.emplace_back(parseDeclaration(parser)); variables.emplace_back(parseDeclaration(parser));
parser.skipWhiteSpace(); parser.skipWhiteSpace();
@ -59,7 +58,7 @@ void VariableExpression::parseTypedDeclaration(utils::Parser &parser, Context &c
const auto type = parseType(parser, context); const auto type = parseType(parser, context);
// Set the argument type for all previously flagged arguments // Set the argument type for all previously flagged arguments
std::for_each(variableExpressions.begin(), variableExpressions.end(), std::for_each(variables.begin(), variables.end(),
[&](auto &variable) [&](auto &variable)
{ {
if (!variable->isDirty()) if (!variable->isDirty())
@ -72,8 +71,7 @@ void VariableExpression::parseTypedDeclaration(utils::Parser &parser, Context &c
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
const VariableExpression *VariableExpression::parse(utils::Parser &parser, const Variable *Variable::parse(utils::Parser &parser, const Variables &variables)
const VariableExpressions &variableExpressions)
{ {
parser.skipWhiteSpace(); parser.skipWhiteSpace();
@ -81,13 +79,13 @@ const VariableExpression *VariableExpression::parse(utils::Parser &parser,
const auto variableName = parser.parseIdentifier(isIdentifier); const auto variableName = parser.parseIdentifier(isIdentifier);
const auto match = std::find_if(variableExpressions.cbegin(), variableExpressions.cend(), const auto match = std::find_if(variables.cbegin(), variables.cend(),
[&](const auto &variableExpression) [&](const auto &variable)
{ {
return variableExpression->name() == variableName; return variable->name() == variableName;
}); });
if (match == variableExpressions.cend()) if (match == variables.cend())
throw utils::ParserException(parser.row(), parser.column(), "Variable \"" + variableName + "\" used but never declared"); throw utils::ParserException(parser.row(), parser.column(), "Variable \"" + variableName + "\" used but never declared");
return match->get(); return match->get();
@ -95,42 +93,42 @@ const VariableExpression *VariableExpression::parse(utils::Parser &parser,
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void VariableExpression::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const void Variable::accept(plasp::pddl::ExpressionVisitor &expressionVisitor) const
{ {
expressionVisitor.visit(*this); expressionVisitor.visit(*this);
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
const std::string &VariableExpression::name() const const std::string &Variable::name() const
{ {
return m_name; return m_name;
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
TypePtr VariableExpression::type() const TypePtr Variable::type() const
{ {
return m_type; return m_type;
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void VariableExpression::setDirty(bool isDirty) void Variable::setDirty(bool isDirty)
{ {
m_isDirty = isDirty; m_isDirty = isDirty;
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
bool VariableExpression::isDirty() const bool Variable::isDirty() const
{ {
return m_isDirty; return m_isDirty;
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
void VariableExpression::setType(TypePtr type) void Variable::setType(TypePtr type)
{ {
m_type = type; m_type = type;
} }