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

Refactoring to avoid dynamic casts.

Browse Source
This commit is contained in:
Patrick Lühne
2016-12-07 02:29:48 +01:00
parent 692d3fe83a
commit ebab65e233
11 changed files with 88 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -54,43 +54,6 @@ ExpressionPointer Expression::existentiallyQuantified()
return this;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer Expression::moveUpQuantifiers(ExpressionPointer parent, ExpressionPointer &child)
{
BOOST_ASSERT(child);
if (child->is<expressions::Exists>())
{
auto quantifiedExpression = expressions::ExistsPointer(dynamic_cast<expressions::Exists *>(child.get()));
// Move argument up
child = quantifiedExpression->argument();
// Move quantifier up
quantifiedExpression->setArgument(parent);
// Make parent point to the quantifier that has been moved up
return quantifiedExpression;
}
else if (child->is<expressions::ForAll>())
{
auto quantifiedExpression = expressions::ForAllPointer(dynamic_cast<expressions::ForAll *>(child.get()));
// Move argument up
child = quantifiedExpression->argument();
// Move quantifier up
quantifiedExpression->setArgument(parent);
// Make parent point to the quantifier that has been moved up
return quantifiedExpression;
}
return parent;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer Expression::simplified()
@@ -110,11 +73,7 @@ ExpressionPointer Expression::simplified()
ExpressionPointer Expression::negated()
{
if (is<expressions::Not>())
{
auto &notExpression = dynamic_cast<expressions::Not &>(*this);
return notExpression.argument();
}
return as<expressions::Not>().argument();
auto notExpression = expressions::NotPointer(new expressions::Not);
notExpression->setArgument(this);

30
src/plasp/pddl/TranslatorASP.cpp
View File

@@ -323,7 +323,7 @@ void TranslatorASP::translateActions() const
{
case Expression::Type::And:
{
const auto &andExpression = dynamic_cast<const expressions::And &>(precondition);
const auto &andExpression = precondition.as<expressions::And>();
std::for_each(andExpression.arguments().cbegin(), andExpression.arguments().cend(),
[&](const auto argument)
@@ -360,7 +360,7 @@ void TranslatorASP::translateActions() const
if (effect.expressionType() != Expression::Type::And)
throw output::TranslatorException("only “and” expressions and (negated) predicates supported as action effects currently");
const auto &andExpression = dynamic_cast<const expressions::And &>(effect);
const auto &andExpression = effect.as<expressions::And>();
std::for_each(andExpression.arguments().cbegin(), andExpression.arguments().cend(),
[&](const auto argument)
@@ -444,7 +444,7 @@ void translateVariablesBody(output::ColorStream &outputStream, const T &variable
if (variable.type()->expressionType() != Expression::Type::PrimitiveType)
throw output::TranslatorException("only primitive types supported currently");
const auto &type = dynamic_cast<const expressions::PrimitiveType &>(*variable.type());
const auto &type = variable.type()->template as<expressions::PrimitiveType>();
outputStream << output::Function("has") << "("
<< output::Variable(variable.name().c_str()) << ", "
@@ -466,7 +466,7 @@ void translateLiteral(output::ColorStream &outputStream, const Expression &liter
// Translate single predicate
if (literal.is<expressions::Predicate>())
{
const auto &predicate = dynamic_cast<const expressions::Predicate &>(literal);
const auto &predicate = literal.as<expressions::Predicate>();
outputStream << output::Keyword("variable") << "(";
translatePredicate(outputStream, predicate);
@@ -477,12 +477,12 @@ void translateLiteral(output::ColorStream &outputStream, const Expression &liter
// Assuming that "not" expression may only contain a predicate
else if (literal.is<expressions::Not>())
{
const auto &notExpression = dynamic_cast<const expressions::Not &>(literal);
const auto &notExpression = literal.as<expressions::Not>();
if (notExpression.argument()->expressionType() != Expression::Type::Predicate)
throw output::TranslatorException("only negations of primitive predicates supported as literals currently");
const auto &predicate = dynamic_cast<const expressions::Predicate &>(*notExpression.argument());
const auto &predicate = notExpression.argument()->as<expressions::Predicate>();
outputStream << output::Keyword("variable") << "(";
translatePredicate(outputStream, predicate);
@@ -492,7 +492,7 @@ void translateLiteral(output::ColorStream &outputStream, const Expression &liter
}
else if (literal.is<expressions::DerivedPredicate>())
{
const auto &derivedPredicate = dynamic_cast<const expressions::DerivedPredicate &>(literal);
const auto &derivedPredicate = literal.as<expressions::DerivedPredicate>();
/*m_outputStream << output::Keyword("variable") << "(";
this->translatePredicate(predicate);
@@ -521,19 +521,19 @@ void translatePredicate(output::ColorStream &outputStream, const expressions::Pr
outputStream << "(" << output::String(predicate.name().c_str());
for (auto i = arguments.cbegin(); i != arguments.cend(); i++)
for (const auto &argument : arguments)
{
outputStream << ", ";
if ((*i)->is<expressions::Constant>())
if (argument->is<expressions::Constant>())
{
const auto &constant = dynamic_cast<const expressions::Constant &>(**i);
const auto &constant = argument->as<expressions::Constant>();
outputStream << output::Keyword("constant") << "(" << output::String(constant.name().c_str()) << ")";
}
else if ((*i)->is<expressions::Variable>())
else if (argument->is<expressions::Variable>())
{
const auto &variable = dynamic_cast<const expressions::Variable &>(**i);
const auto &variable = argument->as<expressions::Variable>();
outputStream << output::Variable(variable.name().c_str());
}
@@ -587,7 +587,7 @@ void TranslatorASP::translateInitialState() const
// Translate single predicate
if (fact->is<expressions::Predicate>())
{
const auto &predicate = dynamic_cast<const expressions::Predicate &>(*fact);
const auto &predicate = fact->as<expressions::Predicate>();
m_outputStream << output::Keyword("variable") << "(";
translatePredicate(m_outputStream, predicate);
@@ -598,7 +598,7 @@ void TranslatorASP::translateInitialState() const
// Assuming that "not" expression may only contain a predicate
else if (fact->is<expressions::Not>())
{
const auto &notExpression = dynamic_cast<const expressions::Not &>(*fact);
const auto &notExpression = fact->as<expressions::Not>();
if (notExpression.argument()->expressionType() != Expression::Type::Predicate)
throw output::TranslatorException("only negations of simple predicates supported in initial state currently");
@@ -642,7 +642,7 @@ void TranslatorASP::translateGoal() const
}
else if (goal.is<expressions::And>())
{
const auto &andExpression = dynamic_cast<const expressions::And &>(goal);
const auto &andExpression = goal.as<expressions::And>();
std::for_each(andExpression.arguments().cbegin(), andExpression.arguments().cend(),
[&](const auto argument)

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

@@ -81,11 +81,11 @@ ExpressionPointer Not::simplified()
m_argument = m_argument->simplified();
if (!m_argument->is<expressions::Not>())
if (!m_argument->is<Not>())
return this;
// Remove double negations
const auto &notExpression = dynamic_cast<expressions::Not &>(*m_argument);
const auto &notExpression = m_argument->as<Not>();
return notExpression.argument();
}
@@ -104,7 +104,7 @@ ExpressionPointer Not::decomposed(DerivedPredicates &derivedPredicates)
m_argument = m_argument->decomposed(derivedPredicates);
// Predicates and derived predicates can be directly negated
if (m_argument->is<expressions::Predicate>() || m_argument->is<expressions::DerivedPredicate>())
if (m_argument->is<Predicate>() || m_argument->is<DerivedPredicate>())
return this;
derivedPredicates.emplace_back(new DerivedPredicate());

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

@@ -33,11 +33,9 @@ ExpressionPointer Or::decomposed(DerivedPredicates &derivedPredicates)
Expressions conjunction;
// “and” expressions can directly be inlined into the derived predicate
if (argument->is<expressions::And>())
if (argument->is<And>())
{
const auto &andExpression = dynamic_cast<expressions::And &>(*argument);
conjunction = std::move(andExpression.arguments());
conjunction = std::move(argument->as<And>().arguments());
for (auto &argument : conjunction)
argument = argument->decomposed(derivedPredicates);

2
src/plasp/pddl/expressions/Predicate.cpp
View File

@@ -156,7 +156,7 @@ bool Predicate::isDeclared() const
////////////////////////////////////////////////////////////////////////////////////////////////////
ExpressionPointer Predicate::decomposed(expressions::DerivedPredicates &)
ExpressionPointer Predicate::decomposed(DerivedPredicates &)
{
// Predicates cannot be further decomposed
return this;

2
src/plasp/pddl/expressions/PredicateDeclaration.cpp
View File

@@ -43,7 +43,7 @@ void PredicateDeclaration::parse(Context &context, Domain &domain)
expressionContext.variables.push(&predicate->m_parameters);
// Parse arguments
expressions::Variable::parseTypedDeclarations(context, expressionContext, predicate->m_parameters);
Variable::parseTypedDeclarations(context, expressionContext, predicate->m_parameters);
context.parser.expect<std::string>(")");