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

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

@@ -37,7 +37,7 @@ Action &Action::parseDeclaration(utils::Parser &parser, Context &context)
// Read parameters
while (parser.currentCharacter() != ')')
{
expressions::VariableExpression::parseTypedDeclaration(parser, context, action->m_parameters);
expressions::Variable::parseTypedDeclaration(parser, context, action->m_parameters);
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;
}

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

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

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>
@@ -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);
}

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>
@@ -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;
}

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>
@@ -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);
}

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>
@@ -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);
}

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>
@@ -11,14 +11,14 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// PredicateExpression
// Predicate
//
////////////////////////////////////////////////////////////////////////////////////////////////////
PredicateExpressionPointer PredicateExpression::parse(std::string name, utils::Parser &parser,
Context &context, const VariableExpressions &parameters)
PredicatePointer Predicate::parse(std::string name, utils::Parser &parser,
Context &context, const Variables &parameters)
{
auto expression = std::make_unique<PredicateExpression>(PredicateExpression());
auto expression = std::make_unique<Predicate>(Predicate());
expression->m_name = name;
@@ -26,7 +26,7 @@ PredicateExpressionPointer PredicateExpression::parse(std::string name, utils::P
// Parse arguments
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
@@ -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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
const std::vector<const VariableExpression *> &PredicateExpression::arguments() const
const std::vector<const Variable *> &Predicate::arguments() const
{
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>
@@ -16,24 +16,24 @@ namespace expressions
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// VariableExpression
// Variable
//
////////////////////////////////////////////////////////////////////////////////////////////////////
VariableExpression::VariableExpression()
Variable::Variable()
: m_isDirty{false}
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
VariableExpressionPointer VariableExpression::parseDeclaration(utils::Parser &parser)
VariablePointer Variable::parseDeclaration(utils::Parser &parser)
{
parser.skipWhiteSpace();
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->setDirty();
@@ -43,11 +43,10 @@ VariableExpressionPointer VariableExpression::parseDeclaration(utils::Parser &pa
////////////////////////////////////////////////////////////////////////////////////////////////////
void VariableExpression::parseTypedDeclaration(utils::Parser &parser, Context &context,
VariableExpressions &variableExpressions)
void Variable::parseTypedDeclaration(utils::Parser &parser, Context &context, Variables &variables)
{
// Parse and store variable itself
variableExpressions.emplace_back(parseDeclaration(parser));
variables.emplace_back(parseDeclaration(parser));
parser.skipWhiteSpace();
@@ -59,7 +58,7 @@ void VariableExpression::parseTypedDeclaration(utils::Parser &parser, Context &c
const auto type = parseType(parser, context);
// 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)
{
if (!variable->isDirty())
@@ -72,8 +71,7 @@ void VariableExpression::parseTypedDeclaration(utils::Parser &parser, Context &c
////////////////////////////////////////////////////////////////////////////////////////////////////
const VariableExpression *VariableExpression::parse(utils::Parser &parser,
const VariableExpressions &variableExpressions)
const Variable *Variable::parse(utils::Parser &parser, const Variables &variables)
{
parser.skipWhiteSpace();
@@ -81,13 +79,13 @@ const VariableExpression *VariableExpression::parse(utils::Parser &parser,
const auto variableName = parser.parseIdentifier(isIdentifier);
const auto match = std::find_if(variableExpressions.cbegin(), variableExpressions.cend(),
[&](const auto &variableExpression)
const auto match = std::find_if(variables.cbegin(), variables.cend(),
[&](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");
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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
const std::string &VariableExpression::name() const
const std::string &Variable::name() const
{
return m_name;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TypePtr VariableExpression::type() const
TypePtr Variable::type() const
{
return m_type;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void VariableExpression::setDirty(bool isDirty)
void Variable::setDirty(bool isDirty)
{
m_isDirty = isDirty;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
bool VariableExpression::isDirty() const
bool Variable::isDirty() const
{
return m_isDirty;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void VariableExpression::setType(TypePtr type)
void Variable::setType(TypePtr type)
{
m_type = type;
}