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

Colorized output for SAS translator.

Browse Source
This commit is contained in:
Patrick Lühne
2016-06-14 17:35:32 +02:00
parent 1e21457efb
commit f7cd24b67a
14 changed files with 137 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plasp/sas/Debugging.cpp
View File

@@ -13,7 +13,7 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
std::ostream &operator <<(std::ostream &ostream, const Description &description)
utils::LogStream &operator<<(utils::LogStream &ostream, const Description &description)
{
// Metric section
ostream << "uses action costs: " << (description.usesActionCosts() ? "yes" : "no") << std::endl;

9
src/plasp/sas/Operator.cpp
View File

@@ -4,6 +4,7 @@
#include <limits>
#include <plasp/sas/VariableTransition.h>
#include <plasp/utils/Formatting.h>
namespace plasp
{
@@ -45,11 +46,11 @@ Operator Operator::fromSAS(utils::Parser &parser, const Variables &variables)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Operator::printPredicateAsASP(std::ostream &ostream) const
void Operator::printPredicateAsASP(utils::LogStream &outputStream) const
{
ostream << "action(";
m_predicate.printAsASP(ostream);
ostream << ")";
outputStream << utils::Keyword("action") << "(";
m_predicate.printAsASP(outputStream);
outputStream << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////

20
src/plasp/sas/Predicate.cpp
View File

@@ -68,43 +68,43 @@ const Predicate::Arguments &Predicate::arguments() const
////////////////////////////////////////////////////////////////////////////////////////////////////
void Predicate::printAsSAS(std::ostream &ostream) const
void Predicate::printAsSAS(utils::LogStream &outputStream) const
{
if (m_arguments.empty())
{
ostream << m_name;
outputStream << m_name;
return;
}
for (size_t i = 0; i < m_arguments.size(); i++)
{
if (i > 0)
ostream << " ";
outputStream << " ";
ostream << m_arguments[i];
outputStream << m_arguments[i];
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Predicate::printAsASP(std::ostream &ostream) const
void Predicate::printAsASP(utils::LogStream &outputStream) const
{
if (m_arguments.empty())
{
ostream << utils::escapeASP(m_name);
outputStream << utils::escapeASP(m_name);
return;
}
ostream << utils::escapeASP(m_name) << "(";
outputStream << utils::escapeASP(m_name) << "(";
for (size_t i = 0; i < m_arguments.size(); i++)
{
if (i > 0)
ostream << ", ";
outputStream << ", ";
ostream << utils::escapeASP(m_arguments[i]);
outputStream << utils::escapeASP(m_arguments[i]);
}
ostream << ")";
outputStream << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////

162
src/plasp/sas/TranslatorASP.cpp
View File

@@ -1,5 +1,7 @@
#include <plasp/sas/TranslatorASP.h>
#include <plasp/utils/Formatting.h>
namespace plasp
{
namespace sas
@@ -11,9 +13,9 @@ namespace sas
//
////////////////////////////////////////////////////////////////////////////////////////////////////
TranslatorASP::TranslatorASP(const Description &description, std::ostream &ostream)
TranslatorASP::TranslatorASP(const Description &description, utils::LogStream &ostream)
: m_description(description),
m_ostream(ostream)
m_outputStream(ostream)
{
}
@@ -34,67 +36,67 @@ void TranslatorASP::translate() const
void TranslatorASP::translateRequirements() const
{
m_ostream << "% feature requirements" << std::endl;
m_outputStream << utils::Heading2("feature requirements") << std::endl;
if (m_description.usesActionCosts())
m_ostream << "requiresFeature(actionCosts)." << std::endl;
m_outputStream << utils::Keyword("requiresFeature") << "(actionCosts)." << std::endl;
if (m_description.usesAxiomRules())
m_ostream << "requiresFeature(axiomRules)." << std::endl;
m_outputStream << utils::Keyword("requiresFeature") << "(axiomRules)." << std::endl;
if (m_description.usesConditionalEffects())
m_ostream << "requiresFeature(conditionalEffects)." << std::endl;
m_outputStream << utils::Keyword("requiresFeature") << "(conditionalEffects)." << std::endl;
m_ostream << std::endl;
m_outputStream << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void TranslatorASP::translateInitialState() const
{
m_ostream << "% initial state" << std::endl;
m_outputStream << utils::Heading2("initial state") << std::endl;
const auto &initialStateFacts = m_description.initialState().facts();
std::for_each(initialStateFacts.cbegin(), initialStateFacts.cend(),
[&](const auto &fact)
{
m_ostream << "initialState(";
fact.variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
fact.value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("initialState") << "(";
fact.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
fact.value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
m_ostream << std::endl;
m_outputStream << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void TranslatorASP::translateGoal() const
{
m_ostream << "% goal" << std::endl;
m_outputStream << utils::Heading2("goal") << std::endl;
const auto &goalFacts = m_description.goal().facts();
std::for_each(goalFacts.cbegin(), goalFacts.cend(),
[&](const auto &fact)
{
m_ostream << "goal(";
fact.variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
fact.value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("goal") << "(";
fact.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
fact.value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
m_ostream << std::endl;
m_outputStream << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void TranslatorASP::translateVariables() const
{
m_ostream << "% variables";
m_outputStream << utils::Heading2("variables");
const auto &variables = m_description.variables();
@@ -105,51 +107,51 @@ void TranslatorASP::translateVariables() const
BOOST_ASSERT(!values.empty());
m_ostream << std::endl;
variable.printNameAsASPPredicate(m_ostream);
m_ostream << "." << std::endl;
m_outputStream << std::endl;
variable.printNameAsASPPredicate(m_outputStream);
m_outputStream << "." << std::endl;
std::for_each(values.cbegin(), values.cend(),
[&](const auto &value)
{
m_ostream << "contains(";
variable.printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
value.printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("contains") << "(";
variable.printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
value.printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
});
m_ostream << std::endl;
m_outputStream << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void TranslatorASP::translateActions() const
{
m_ostream << "% actions";
m_outputStream << utils::Heading2("actions");
const auto &operators = m_description.operators();
std::for_each(operators.cbegin(), operators.cend(),
[&](const auto &operator_)
{
m_ostream << std::endl;
operator_.printPredicateAsASP(m_ostream);
m_ostream << "." << std::endl;
m_outputStream << std::endl;
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << "." << std::endl;
const auto &preconditions = operator_.preconditions();
std::for_each(preconditions.cbegin(), preconditions.cend(),
[&](const auto &precondition)
{
m_ostream << "precondition(";
operator_.printPredicateAsASP(m_ostream);
m_ostream << ", ";
precondition.variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
precondition.value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("precondition") << "(";
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << ", ";
precondition.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
precondition.value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
const auto &effects = operator_.effects();
@@ -164,39 +166,39 @@ void TranslatorASP::translateActions() const
std::for_each(conditions.cbegin(), conditions.cend(),
[&](const auto &condition)
{
m_ostream << "effectCondition(";
operator_.printPredicateAsASP(m_ostream);
m_ostream << ", effect(" << currentEffectID << "), ";
condition.variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
condition.value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("effectCondition") << "(";
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << ", " << utils::Keyword("effect") << "(" << currentEffectID << "), ";
condition.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
condition.value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
m_ostream << "postcondition(";
operator_.printPredicateAsASP(m_ostream);
m_ostream << ", effect(" << currentEffectID << "), ";
effect.postcondition().variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
effect.postcondition().value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("postcondition") << "(";
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << ", " << utils::Keyword("effect") << "(" << currentEffectID << "), ";
effect.postcondition().variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
effect.postcondition().value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
currentEffectID++;
});
m_ostream << "costs(";
operator_.printPredicateAsASP(m_ostream);
m_ostream << ", " << operator_.costs() << ")." << std::endl;
m_outputStream << utils::Keyword("costs") << "(";
operator_.printPredicateAsASP(m_outputStream);
m_outputStream << ", " << operator_.costs() << ")." << std::endl;
});
m_ostream << std::endl;
m_outputStream << std::endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void TranslatorASP::translateMutexes() const
{
m_ostream << "% mutex groups";
m_outputStream << utils::Heading2("mutex groups");
const auto &mutexGroups = m_description.mutexGroups();
@@ -208,18 +210,18 @@ void TranslatorASP::translateMutexes() const
const auto mutexGroupID = std::to_string(currentMutexGroupID);
currentMutexGroupID++;
m_ostream << std::endl << "mutexGroup(" << mutexGroupID << ")." << std::endl;
m_outputStream << std::endl << utils::Keyword("mutexGroup") << "(" << mutexGroupID << ")." << std::endl;
const auto &facts = mutexGroup.facts();
std::for_each(facts.cbegin(), facts.cend(),
[&](const auto &fact)
{
m_ostream << "contains(mutexGroup(" << mutexGroupID << "), ";
fact.variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
fact.value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("contains") << "(" << utils::Keyword("mutexGroup") << "(" << mutexGroupID << "), ";
fact.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
fact.value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
});
}
@@ -231,8 +233,8 @@ void TranslatorASP::translateAxiomRules() const
if (!m_description.usesActionCosts())
return;
m_ostream << std::endl;
m_ostream << "% axiom rules";
m_outputStream << std::endl;
m_outputStream << utils::Heading2("axiom rules");
const auto &axiomRules = m_description.axiomRules();
@@ -244,27 +246,27 @@ void TranslatorASP::translateAxiomRules() const
const auto axiomRuleID = std::to_string(currentAxiomRuleID);
currentAxiomRuleID++;
m_ostream << std::endl << "axiomRule(" << axiomRuleID << ")." << std::endl;
m_outputStream << std::endl << utils::Keyword("axiomRule") << "(" << axiomRuleID << ")." << std::endl;
const auto &conditions = axiomRule.conditions();
std::for_each(conditions.cbegin(), conditions.cend(),
[&](const auto &condition)
{
m_ostream << "condition(axiomRule(" << axiomRuleID << "), ";
condition.variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
condition.value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("condition") << "(" << utils::Keyword("axiomRule") << "(" << axiomRuleID << "), ";
condition.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
condition.value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
const auto &postcondition = axiomRule.postcondition();
m_ostream << "postcondition(axiomRule(axiomRule" << axiomRuleID << "), ";
postcondition.variable().printNameAsASPPredicate(m_ostream);
m_ostream << ", ";
postcondition.value().printAsASPPredicate(m_ostream);
m_ostream << ")." << std::endl;
m_outputStream << utils::Keyword("postcondition") << "(" << utils::Keyword("axiomRule") << "(" << axiomRuleID << "), ";
postcondition.variable().printNameAsASPPredicate(m_outputStream);
m_outputStream << ", ";
postcondition.value().printAsASPPredicate(m_outputStream);
m_outputStream << ")." << std::endl;
});
}

25
src/plasp/sas/Value.cpp
View File

@@ -3,6 +3,7 @@
#include <iostream>
#include <plasp/sas/Variable.h>
#include <plasp/utils/Formatting.h>
#include <plasp/utils/IO.h>
#include <plasp/utils/ParserException.h>
@@ -127,42 +128,42 @@ const std::string &Value::name() const
////////////////////////////////////////////////////////////////////////////////////////////////////
void Value::printAsASP(std::ostream &ostream) const
void Value::printAsASP(utils::LogStream &outputStream) const
{
if (m_sign == Value::Sign::Negative)
ostream << "not ";
outputStream << utils::Keyword("not") << " ";
ostream << utils::escapeASP(m_name);
outputStream << utils::escapeASP(m_name);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Value::printAsASPPredicate(std::ostream &ostream) const
void Value::printAsASPPredicate(utils::LogStream &outputStream) const
{
// TODO: do not compare by value
if (*this == Value::None)
{
ostream << "value(none)";
outputStream << utils::Keyword("value") << "(" << utils::Keyword("none") << ")";
return;
}
ostream << "value(" << utils::escapeASP(m_name) << ", "
<< (m_sign == Sign::Positive ? "true" : "false") << ")";
outputStream << utils::Keyword("value") << "(" << utils::escapeASP(m_name) << ", "
<< (m_sign == Sign::Positive ? utils::Keyword("true") : utils::Keyword("false")) << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Value::printAsSAS(std::ostream &ostream) const
void Value::printAsSAS(utils::LogStream &outputStream) const
{
if (m_sign == Value::Sign::Positive)
ostream << "Atom ";
outputStream << "Atom ";
else
ostream << "NegatedAtom ";
outputStream << "NegatedAtom ";
ostream << m_name;
outputStream << m_name;
if (!m_hasArguments)
ostream << "()";
outputStream << "()";
}
////////////////////////////////////////////////////////////////////////////////////////////////////

5
src/plasp/sas/Variable.cpp
View File

@@ -2,6 +2,7 @@
#include <iostream>
#include <plasp/utils/Formatting.h>
#include <plasp/utils/IO.h>
#include <plasp/utils/ParserException.h>
@@ -51,9 +52,9 @@ Variable Variable::fromSAS(utils::Parser &parser)
////////////////////////////////////////////////////////////////////////////////////////////////////
void Variable::printNameAsASPPredicate(std::ostream &ostream) const
void Variable::printNameAsASPPredicate(utils::LogStream &outputStream) const
{
ostream << "variable(" << utils::escapeASP(m_name) << ")";
outputStream << utils::Keyword("variable") << "(" << utils::escapeASP(m_name) << ")";
}
////////////////////////////////////////////////////////////////////////////////////////////////////