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

Started refactoring Variables as expressions.

Browse Source
This commit is contained in:
Patrick Lühne
2016-06-03 13:20:52 +02:00
parent 36e28994ee
commit d334b4150b
12 changed files with 295 additions and 38 deletions
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 <plasp/pddl/Expression.h>
#include <plasp/pddl/Variable.h>
#include <plasp/pddl/expressions/VariableExpression.h>
#include <plasp/utils/Parser.h>
namespace plasp
@@ -26,7 +26,7 @@ class Action
public:
const std::string &name() const;
const Variables &parameters() const;
const expressions::VariableExpressions &parameters() const;
const Expression &precondition() const;
const Expression &effect() const;
@@ -35,7 +35,7 @@ class Action
std::string m_name;
Variables m_parameters;
expressions::VariableExpressions m_parameters;
std::unique_ptr<Expression> m_precondition;
std::unique_ptr<Expression> m_effect;
};

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

@@ -22,6 +22,29 @@ namespace pddl
class Context;
class ExpressionVisitor;
class Expression;
using ExpressionPointer = std::unique_ptr<Expression>;
using Expressions = std::vector<ExpressionPointer>;
namespace expressions
{
class AndExpression;
using AndExpressionPointer = std::unique_ptr<AndExpression>;
class NotExpression;
using NotExpressionPointer = std::unique_ptr<NotExpression>;
class OrExpression;
using OrExpressionPointer = std::unique_ptr<OrExpression>;
class PredicateExpression;
using PredicateExpressionPointer = std::unique_ptr<PredicateExpression>;
class VariableExpression;
using VariableExpressionPointer = std::unique_ptr<VariableExpression>;
using VariableExpressions = std::vector<VariableExpressionPointer>;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
class Expression
@@ -32,10 +55,13 @@ class Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
std::unique_ptr<Expression> parsePreconditionExpression(utils::Parser &parser, Context &context, const Variables &parameters);
std::unique_ptr<Expression> parseExpression(utils::Parser &parser, Context &context, const Variables &parameters);
ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters);
ExpressionPointer parseExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters);
std::unique_ptr<Expression> parseEffectExpression(utils::Parser &parser, Context &context, const Variables &parameters);
ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters);
////////////////////////////////////////////////////////////////////////////////////////////////////

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

@@ -20,7 +20,8 @@ class AndExpression: public NAryExpression
{
public:
template<typename ExpressionParser>
static std::unique_ptr<AndExpression> parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression);
static AndExpressionPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -32,7 +33,8 @@ class AndExpression: public NAryExpression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
std::unique_ptr<AndExpression> AndExpression::parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression)
AndExpressionPointer AndExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
{
auto expression = std::make_unique<AndExpression>(AndExpression());

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

@@ -7,6 +7,7 @@
#include <plasp/pddl/ConsistencyException.h>
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/VariableExpression.h>
#include <plasp/utils/Parser.h>
namespace plasp
@@ -25,20 +26,22 @@ namespace expressions
class NAryExpression: public Expression
{
public:
const std::vector<std::unique_ptr<Expression>> &arguments() const;
const Expressions &arguments() const;
protected:
template<typename ExpressionParser>
void parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression);
void parse(utils::Parser &parser, Context &context, const VariableExpressions &parameters,
ExpressionParser parseExpression);
private:
std::vector<std::unique_ptr<Expression>> m_arguments;
Expressions m_arguments;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
void NAryExpression::parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression)
void NAryExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
{
parser.skipWhiteSpace();

8
include/plasp/pddl/expressions/NotExpression.h
View File

@@ -21,7 +21,8 @@ class NotExpression: public Expression
{
public:
template<typename ExpressionParser>
static std::unique_ptr<NotExpression> parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression);
static NotExpressionPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -31,13 +32,14 @@ class NotExpression: public Expression
private:
NotExpression() = default;
std::unique_ptr<Expression> m_argument;
ExpressionPointer m_argument;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
std::unique_ptr<NotExpression> NotExpression::parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression)
NotExpressionPointer NotExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
{
auto expression = std::make_unique<NotExpression>(NotExpression());

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

@@ -20,7 +20,8 @@ class OrExpression: public NAryExpression
{
public:
template<typename ExpressionParser>
static std::unique_ptr<OrExpression> parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression);
static OrExpressionPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -32,7 +33,8 @@ class OrExpression: public NAryExpression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
std::unique_ptr<OrExpression> OrExpression::parse(utils::Parser &parser, Context &context, const Variables &parameters, ExpressionParser parseExpression)
OrExpressionPointer OrExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
{
auto expression = std::make_unique<OrExpression>(OrExpression());

8
include/plasp/pddl/expressions/PredicateExpression.h
View File

@@ -3,6 +3,7 @@
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/Predicate.h>
#include <plasp/pddl/expressions/VariableExpression.h>
namespace plasp
{
@@ -20,16 +21,19 @@ namespace expressions
class PredicateExpression: public Expression
{
public:
static std::unique_ptr<PredicateExpression> parse(std::string name, utils::Parser &parser, Context &context, const Variables &parameters);
static PredicateExpressionPointer parse(std::string name, utils::Parser &parser,
Context &context, const VariableExpressions &parameters);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
const std::vector<const VariableExpression *> &arguments() const;
private:
PredicateExpression() = default;
std::string m_name;
Variables m_arguments;
std::vector<const VariableExpression *> m_arguments;
};
////////////////////////////////////////////////////////////////////////////////////////////////////

56
include/plasp/pddl/expressions/VariableExpression.h Normal file
View File

@@ -0,0 +1,56 @@
#ifndef __PLASP__PDDL__EXPRESSION__VARIABLE_EXPRESSION_H
#define __PLASP__PDDL__EXPRESSION__VARIABLE_EXPRESSION_H
#include <plasp/pddl/Expression.h>
namespace plasp
{
namespace pddl
{
namespace expressions
{
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// VariableExpression
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class VariableExpression: public Expression
{
public:
static VariableExpressionPointer parseDeclaration(utils::Parser &parser);
static void parseTypedDeclaration(utils::Parser &parser, Context &context,
VariableExpressions &variableExpressions);
static const VariableExpression *parse(utils::Parser &parser,
const VariableExpressions &variableExpressions);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
const std::string &name() const;
TypePtr type() const;
void setDirty(bool isDirty = true);
bool isDirty() const;
void setType(TypePtr type);
private:
VariableExpression();
bool m_isDirty;
std::string m_name;
TypePtr m_type;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
}
}
}
#endif