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

Removed now unnecessary Parser function arguments.

Browse Source
This commit is contained in:
Patrick Lühne
2016-06-04 16:24:10 +02:00
parent a776fc9e06
commit 813fecbf15
24 changed files with 170 additions and 185 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(utils::Parser &parser, Context &context);
static Action &parseDeclaration(Context &context);
public:
const std::string &name() const;

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

@@ -75,13 +75,11 @@ class Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parsePreconditionExpression(utils::Parser &parser, Context &context,
const expressions::Variables &parameters);
ExpressionPointer parseExpression(utils::Parser &parser, Context &context,
ExpressionPointer parsePreconditionExpression(Context &context,
const expressions::Variables &parameters);
ExpressionPointer parseExpression(Context &context, const expressions::Variables &parameters);
ExpressionPointer parseEffectExpression(utils::Parser &parser, Context &context,
const expressions::Variables &parameters);
ExpressionPointer parseEffectExpression(Context &context, const expressions::Variables &parameters);
////////////////////////////////////////////////////////////////////////////////////////////////////

4
include/plasp/pddl/Requirement.h
View File

@@ -3,7 +3,7 @@
#include <vector>
#include <plasp/utils/Parser.h>
#include <plasp/pddl/Context.h>
namespace plasp
{
@@ -49,7 +49,7 @@ class Requirement
ActionCosts
};
static Requirement parse(utils::Parser &parser);
static Requirement parse(Context &context);
public:
Requirement(Type type);

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

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

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

@@ -22,10 +22,10 @@ namespace expressions
class Constant: public Expression
{
public:
static ConstantPointer parseDeclaration(utils::Parser &parser, Context &context);
static void parseTypedDeclaration(utils::Parser &parser, Context &context);
static ConstantPointer parseDeclaration(Context &context);
static void parseTypedDeclaration(Context &context);
static Constant *parseExisting(utils::Parser &parser, Context &context);
static Constant *parseExisting(Context &context);
// TODO: method for lazy creation if not existing

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

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

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

@@ -2,9 +2,9 @@
#define __PLASP__PDDL__EXPRESSION__N_ARY_H
#include <plasp/pddl/ConsistencyException.h>
#include <plasp/pddl/Context.h>
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/expressions/Variable.h>
#include <plasp/utils/Parser.h>
namespace plasp
{
@@ -26,8 +26,7 @@ class NAry: public Expression
protected:
template<typename ExpressionParser>
void parse(utils::Parser &parser, Context &context, const Variables &parameters,
ExpressionParser parseExpression);
void parse(Context &context, const Variables &parameters, ExpressionParser parseExpression);
private:
Expressions m_arguments;
@@ -36,18 +35,17 @@ class NAry: public Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
void NAry::parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression)
void NAry::parse(Context &context, const Variables &parameters, ExpressionParser parseExpression)
{
parser.skipWhiteSpace();
context.parser.skipWhiteSpace();
// Assume that expression identifier (and, or, etc.) is already parsed
// Parse arguments of the expression
while (parser.currentCharacter() != ')')
while (context.parser.currentCharacter() != ')')
{
m_arguments.emplace_back(parseExpression(parser, context, parameters));
m_arguments.emplace_back(parseExpression(context, parameters));
parser.skipWhiteSpace();
context.parser.skipWhiteSpace();
}
}

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

@@ -1,6 +1,7 @@
#ifndef __PLASP__PDDL__EXPRESSION__NOT_H
#define __PLASP__PDDL__EXPRESSION__NOT_H
#include <plasp/pddl/Context.h>
#include <plasp/pddl/Expression.h>
namespace plasp
@@ -20,8 +21,8 @@ class Not: public Expression
{
public:
template<typename ExpressionParser>
static NotPointer parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression);
static NotPointer parse(Context &context, const Variables &parameters,
ExpressionParser parseExpression);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;
@@ -37,15 +38,15 @@ class Not: public Expression
////////////////////////////////////////////////////////////////////////////////////////////////////
template<typename ExpressionParser>
NotPointer Not::parse(utils::Parser &parser, Context &context,
const Variables &parameters, ExpressionParser parseExpression)
NotPointer Not::parse(Context &context, const Variables &parameters,
ExpressionParser parseExpression)
{
auto expression = std::make_unique<Not>(Not());
parser.skipWhiteSpace();
context.parser.skipWhiteSpace();
// Parse argument
expression->m_argument = parseExpression(parser, context, parameters);
expression->m_argument = parseExpression(context, parameters);
return expression;
}

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

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

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

@@ -19,8 +19,8 @@ namespace expressions
class Predicate: public Expression
{
public:
static PredicatePointer parse(std::string name, utils::Parser &parser,
Context &context, const Variables &parameters);
static PredicatePointer parse(std::string name, Context &context,
const Variables &parameters);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;

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

@@ -19,7 +19,7 @@ namespace expressions
class PredicateDeclaration: public Expression
{
public:
static void parse(utils::Parser &parser, Context &context);
static void parse(Context &context);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;

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

@@ -4,7 +4,6 @@
#include <plasp/pddl/ConsistencyException.h>
#include <plasp/pddl/Expression.h>
#include <plasp/pddl/Identifier.h>
#include <plasp/utils/Parser.h>
#include <plasp/utils/ParserException.h>
namespace plasp
@@ -23,12 +22,10 @@ namespace expressions
class PrimitiveType: public Expression
{
public:
static PrimitiveType *parseDeclaration(utils::Parser &parser, Context &context);
static void parseTypedDeclaration(utils::Parser &parser, Context &context);
static PrimitiveType *parseDeclaration(Context &context);
static void parseTypedDeclaration(Context &context);
static PrimitiveType *parseExisting(utils::Parser &parser, Context &context);
// TODO: method for lazy creation if not existing
static PrimitiveType *parseExisting(Context &context);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;

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

@@ -20,8 +20,7 @@ namespace expressions
//
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer parseExistingPrimitiveType(utils::Parser &parser, Context &context,
const Variables &parameters);
ExpressionPointer parseExistingPrimitiveType(Context &context, const Variables &parameters);
////////////////////////////////////////////////////////////////////////////////////////////////////

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

@@ -19,12 +19,11 @@ namespace expressions
class Variable: public Expression
{
public:
static VariablePointer parseDeclaration(utils::Parser &parser);
static VariablePointer parseDeclaration(Context &context);
static void parseTypedDeclaration(utils::Parser &parser, Context &context,
Variables &parameters);
static void parseTypedDeclaration(Context &context, Variables &parameters);
static const Variable *parseExisting(utils::Parser &parser, const Variables &variables);
static const Variable *parseExisting(Context &context, const Variables &variables);
public:
void accept(ExpressionVisitor &expressionVisitor) const override;