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
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/expressions/VariableExpression.h>
#include <plasp/pddl/expressions/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
@@ -26,7 +26,7 @@ class Action
public:
const std::string &name() const;
const expressions::VariableExpressions &parameters() const;
const expressions::Variables &parameters() const;
const Expression &precondition() const;
const Expression &effect() const;
@@ -35,7 +35,7 @@ class Action
std::string m_name;
expressions::VariableExpressions m_parameters;
expressions::Variables m_parameters;
std::unique_ptr<Expression> m_precondition;
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
{
class AndExpression;
using AndExpressionPointer = std::unique_ptr<AndExpression>;
class And;
using AndPointer = std::unique_ptr<And>;
class NotExpression;
using NotExpressionPointer = std::unique_ptr<NotExpression>;
class Not;
using NotPointer = std::unique_ptr<Not>;
class OrExpression;
using OrExpressionPointer = std::unique_ptr<OrExpression>;
class Or;
using OrPointer = std::unique_ptr<Or>;
class PredicateExpression;
using PredicateExpressionPointer = std::unique_ptr<PredicateExpression>;
class Predicate;
using PredicatePointer = std::unique_ptr<Predicate>;
class VariableExpression;
using VariableExpressionPointer = std::unique_ptr<VariableExpression>;
using VariableExpressions = std::vector<VariableExpressionPointer>;
class Variable;
using VariablePointer = std::unique_ptr<Variable>;
using Variables = std::vector<VariablePointer>;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -56,12 +56,12 @@ class Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters);
const expressions::Variables &parameters);
ExpressionPointer parseExpression(utils::Parser &parser, Context &context,
const expressions::VariableExpressions &parameters);
const expressions::Variables &parameters);
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
#define __PLASP__PDDL__EXPRESSION__AND_EXPRESSION_H
#ifndef __PLASP__PDDL__EXPRESSION__AND_H
#define __PLASP__PDDL__EXPRESSION__AND_H
#include <plasp/pddl/expressions/NAryExpression.h>
#include <plasp/pddl/expressions/NAry.h>
namespace plasp
{
@@ -12,33 +12,33 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// AndExpression
// And
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class AndExpression: public NAryExpression
class And: public NAry
{
public:
template<typename ExpressionParser>
static AndExpressionPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression);
static AndPointer parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
private:
AndExpression() = default;
And() = default;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
AndExpressionPointer AndExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
AndPointer And::parse(utils::Parser &parser, Context &context,
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())
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
#define __PLASP__PDDL__EXPRESSION__N_ARY_EXPRESSION_H
#ifndef __PLASP__PDDL__EXPRESSION__N_ARY_H
#define __PLASP__PDDL__EXPRESSION__N_ARY_H
#include <memory>
#include <string>
@@ -7,7 +7,7 @@
#include <plasp/pddl/ConsistencyException.h>
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/VariableExpression.h>
#include <plasp/pddl/expressions/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
@@ -19,18 +19,18 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// NAryExpression
// NAry
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class NAryExpression: public Expression
class NAry: public Expression
{
public:
const Expressions &arguments() const;
protected:
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);
private:
@@ -40,8 +40,8 @@ class NAryExpression: public Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
void NAryExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
void NAry::parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression)
{
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
#define __PLASP__PDDL__EXPRESSION__NOT_EXPRESSION_H
#ifndef __PLASP__PDDL__EXPRESSION__NOT_H
#define __PLASP__PDDL__EXPRESSION__NOT_H
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/Predicate.h>
@@ -13,16 +13,16 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// NotExpression
// Not
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class NotExpression: public Expression
class Not: public Expression
{
public:
template<typename ExpressionParser>
static NotExpressionPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression);
static NotPointer parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -30,7 +30,7 @@ class NotExpression: public Expression
const Expression &argument();
private:
NotExpression() = default;
Not() = default;
ExpressionPointer m_argument;
};
@@ -38,10 +38,10 @@ class NotExpression: public Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
NotExpressionPointer NotExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
NotPointer Not::parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression)
{
auto expression = std::make_unique<NotExpression>(NotExpression());
auto expression = std::make_unique<Not>(Not());
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
#define __PLASP__PDDL__EXPRESSION__OR_EXPRESSION_H
#ifndef __PLASP__PDDL__EXPRESSION__OR_H
#define __PLASP__PDDL__EXPRESSION__OR_H
#include <plasp/pddl/expressions/NAryExpression.h>
#include <plasp/pddl/expressions/NAry.h>
namespace plasp
{
@@ -12,33 +12,33 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// OrExpression
// Or
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class OrExpression: public NAryExpression
class Or: public NAry
{
public:
template<typename ExpressionParser>
static OrExpressionPointer parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression);
static OrPointer parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
private:
OrExpression() = default;
Or() = default;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
OrExpressionPointer OrExpression::parse(utils::Parser &parser, Context &context,
const VariableExpressions &parameters, ExpressionParser parseExpression)
OrPointer Or::parse(utils::Parser &parser, Context &context,
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())
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
#define __PLASP__PDDL__EXPRESSION__PREDICATE_EXPRESSION_H
#ifndef __PLASP__PDDL__EXPRESSION__PREDICATE_H
#define __PLASP__PDDL__EXPRESSION__PREDICATE_H
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/Predicate.h>
#include <plasp/pddl/expressions/VariableExpression.h>
#include <plasp/pddl/expressions/Variable.h>
namespace plasp
{
@@ -14,26 +14,26 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// PredicateExpression
// Predicate
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class PredicateExpression: public Expression
class Predicate: public Expression
{
public:
static PredicateExpressionPointer parse(std::string name, utils::Parser &parser,
Context &context, const VariableExpressions &parameters);
static PredicatePointer parse(std::string name, utils::Parser &parser,
Context &context, const Variables &parameters);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
const std::vector<const VariableExpression *> &arguments() const;
const std::vector<const Variable *> &arguments() const;
private:
PredicateExpression() = default;
Predicate() = default;
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
#define __PLASP__PDDL__EXPRESSION__VARIABLE_EXPRESSION_H
#ifndef __PLASP__PDDL__EXPRESSION__VARIABLE_H
#define __PLASP__PDDL__EXPRESSION__VARIABLE_H
#include <plasp/pddl/Expression.h>
@@ -12,19 +12,18 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// VariableExpression
// Variable
//
////////////////////////////////////////////////////////////////////////////////////////////////////
class VariableExpression: public Expression
class Variable: public Expression
{
public:
static VariableExpressionPointer parseDeclaration(utils::Parser &parser);
static VariablePointer parseDeclaration(utils::Parser &parser);
static void parseTypedDeclaration(utils::Parser &parser, Context &context,
VariableExpressions &variableExpressions);
Variables &variables);
static const VariableExpression *parse(utils::Parser &parser,
const VariableExpressions &variableExpressions);
static const Variable *parse(utils::Parser &parser, const Variables &variables);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -38,7 +37,7 @@ class VariableExpression: public Expression
void setType(TypePtr type);
private:
VariableExpression();
Variable();
bool m_isDirty;