Merge branch 'develop' of github.com:potassco/plasp into feature-normalization

CMakeLists.txt

@@ -25,6 +25,7 @@ if (CMAKE_GENERATOR STREQUAL "Ninja" AND
 endif()
 
 add_subdirectory(lib/tokenize)
+add_subdirectory(lib/colorlog)
 add_subdirectory(lib/pddlparse)
 add_subdirectory(src)
 add_subdirectory(app)

app/CMakeLists.txt

@@ -7,6 +7,7 @@ set(includes
 	${Boost_INCLUDE_DIRS}
 	${PROJECT_SOURCE_DIR}/include
 	${PROJECT_SOURCE_DIR}/lib/tokenize/include
+	${PROJECT_SOURCE_DIR}/lib/colorlog/include
 	${PROJECT_SOURCE_DIR}/lib/variant/include
 	${PROJECT_SOURCE_DIR}/lib/pddlparse/include
 )

app/main.cpp

@@ -4,16 +4,18 @@
 
 #include <boost/program_options.hpp>
 
+#include <colorlog/ColorStream.h>
+#include <colorlog/Logger.h>
+#include <colorlog/Priority.h>
+
 #include <pddlparse/AST.h>
 #include <pddlparse/Exception.h>
 #include <pddlparse/Mode.h>
 #include <pddlparse/Parse.h>
 
 #include <plasp/LanguageDetection.h>
-#include <plasp/output/ColorStream.h>
+#include <plasp/TranslatorException.h>
-#include <plasp/output/Logger.h>
+
-#include <plasp/output/Priority.h>
-#include <plasp/output/TranslatorException.h>
 #include <plasp/pddl/TranslatorASP.h>
 #include <plasp/sas/Description.h>
 #include <plasp/sas/TranslatorASP.h>
@@ -49,7 +51,7 @@ int main(int argc, char **argv)
 			std::cout << description;
 		};
 
-	plasp::output::Logger logger;
+	colorlog::Logger logger;
 
 	try
 	{
@@ -62,7 +64,7 @@ int main(int argc, char **argv)
 	}
 	catch (const po::error &e)
 	{
-		logger.log(plasp::output::Priority::Error, e.what());
+		logger.log(colorlog::Priority::Error, e.what());
 		std::cout << std::endl;
 		printHelp();
 		return EXIT_FAILURE;
@@ -81,7 +83,7 @@ int main(int argc, char **argv)
 	}
 
 	if (warningsAsErrors)
-		logger.setAbortPriority(plasp::output::Priority::Warning);
+		logger.setAbortPriority(colorlog::Priority::Warning);
 
 	auto parsingMode = pddl::Mode::Strict;
 
@@ -91,7 +93,7 @@ int main(int argc, char **argv)
 		parsingMode = pddl::Mode::Compatibility;
 	else if (parsingModeString != "strict")
 	{
-		logger.log(plasp::output::Priority::Error, "unknown parsing mode “" + parsingModeString + "”");
+		logger.log(colorlog::Priority::Error, "unknown parsing mode “" + parsingModeString + "”");
 		std::cout << std::endl;
 		printHelp();
 		return EXIT_FAILURE;
@@ -101,20 +103,20 @@ int main(int argc, char **argv)
 		[&]()
 		{
 			if (parsingMode != pddl::Mode::Compatibility)
-				logger.log(plasp::output::Priority::Info, "try using --parsing-mode=compatibility for extended legacy feature support");
+				logger.log(colorlog::Priority::Info, "try using --parsing-mode=compatibility for extended legacy feature support");
 		};
 
 	const auto colorPolicy = variablesMap["color"].as<std::string>();
 
 	if (colorPolicy == "auto")
-		logger.setColorPolicy(plasp::output::ColorStream::ColorPolicy::Auto);
+		logger.setColorPolicy(colorlog::ColorStream::ColorPolicy::Auto);
 	else if (colorPolicy == "never")
-		logger.setColorPolicy(plasp::output::ColorStream::ColorPolicy::Never);
+		logger.setColorPolicy(colorlog::ColorStream::ColorPolicy::Never);
 	else if (colorPolicy == "always")
-		logger.setColorPolicy(plasp::output::ColorStream::ColorPolicy::Always);
+		logger.setColorPolicy(colorlog::ColorStream::ColorPolicy::Always);
 	else
 	{
-		logger.log(plasp::output::Priority::Error, "unknown color policy “" + colorPolicy + "”");
+		logger.log(colorlog::Priority::Error, "unknown color policy “" + colorPolicy + "”");
 		std::cout << std::endl;
 		printHelp();
 		return EXIT_FAILURE;
@@ -124,12 +126,12 @@ int main(int argc, char **argv)
 
 	try
 	{
-		const auto logPriority = plasp::output::priorityFromName(logPriorityString.c_str());
+		const auto logPriority = colorlog::priorityFromName(logPriorityString.c_str());
 		logger.setLogPriority(logPriority);
 	}
 	catch (const std::exception &e)
 	{
-		logger.log(plasp::output::Priority::Error, ("unknown log priorty “" + logPriorityString + "”").c_str());
+		logger.log(colorlog::Priority::Error, ("unknown log priorty “" + logPriorityString + "”").c_str());
 		logger.errorStream() << std::endl;
 		printHelp();
 		return EXIT_FAILURE;
@@ -168,7 +170,7 @@ int main(int argc, char **argv)
 
 		if (language == plasp::Language::Type::Unknown)
 		{
-			logger.log(plasp::output::Priority::Error, "unknown input language");
+			logger.log(colorlog::Priority::Error, "unknown input language");
 			std::cout << std::endl;
 			printHelp();
 			return EXIT_FAILURE;
@@ -179,7 +181,7 @@ int main(int argc, char **argv)
 			const auto logWarning =
 				[&](const auto &location, const auto &warning)
 				{
-					logger.log(plasp::output::Priority::Warning, location, warning);
+					logger.log(colorlog::Priority::Warning, location, warning);
 				};
 
 			auto context = pddl::Context(std::move(tokenizer), logWarning);
@@ -197,7 +199,7 @@ int main(int argc, char **argv)
 	}
 	catch (const tokenize::TokenizerException &e)
 	{
-		logger.log(plasp::output::Priority::Error, e.location(), e.message().c_str());
+		logger.log(colorlog::Priority::Error, e.location(), e.message().c_str());
 
 		printCompatibilityInfo();
 
@@ -206,22 +208,22 @@ int main(int argc, char **argv)
 	catch (const pddl::ParserException &e)
 	{
 		if (e.location())
-			logger.log(plasp::output::Priority::Error, e.location().value(), e.message().c_str());
+			logger.log(colorlog::Priority::Error, e.location().value(), e.message().c_str());
 		else
-			logger.log(plasp::output::Priority::Error, e.message().c_str());
+			logger.log(colorlog::Priority::Error, e.message().c_str());
 
 		printCompatibilityInfo();
 
 		return EXIT_FAILURE;
 	}
-	catch (const plasp::output::TranslatorException &e)
+	catch (const plasp::TranslatorException &e)
 	{
-		logger.log(plasp::output::Priority::Error, e.what());
+		logger.log(colorlog::Priority::Error, e.what());
 		return EXIT_FAILURE;
 	}
 	catch (const std::exception &e)
 	{
-		logger.log(plasp::output::Priority::Error, e.what());
+		logger.log(colorlog::Priority::Error, e.what());
 		return EXIT_FAILURE;
 	}
 

include/plasp/LanguageDetection.h

@@ -1,10 +1,10 @@
 #ifndef __PLASP__LANGUAGE_DETECTION_H
 #define __PLASP__LANGUAGE_DETECTION_H
 
-#include <plasp/Language.h>
-
 #include <tokenize/Tokenizer.h>
 
+#include <plasp/Language.h>
+
 namespace plasp
 {
 

include/plasp/TranslatorException.h

@@ -1,13 +1,11 @@
-#ifndef __PLASP__OUTPUT__TRANSLATOR_EXCEPTION_H
+#ifndef __PLASP__TRANSLATOR_EXCEPTION_H
-#define __PLASP__OUTPUT__TRANSLATOR_EXCEPTION_H
+#define __PLASP__TRANSLATOR_EXCEPTION_H
 
 #include <exception>
 #include <string>
 
 namespace plasp
 {
-namespace output
-{
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //
@@ -50,7 +48,6 @@ class TranslatorException: public std::exception
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-}
 }
 
 #endif

include/plasp/pddl/TranslatorASP.h

@@ -1,7 +1,7 @@
 #ifndef __PLASP__PDDL__TRANSLATOR_ASP_H
 #define __PLASP__PDDL__TRANSLATOR_ASP_H
 
-#include <plasp/output/ColorStream.h>
+#include <colorlog/ColorStream.h>
 
 #include <pddlparse/ASTForward.h>
 #include <pddlparse/Parse.h>
@@ -20,7 +20,7 @@ namespace pddl
 class TranslatorASP
 {
 	public:
-		explicit TranslatorASP(const ::pddl::ast::Description &description, output::ColorStream &outputStream);
+		explicit TranslatorASP(const ::pddl::ast::Description &description, colorlog::ColorStream &outputStream);
 
 		void translate() const;
 
@@ -36,7 +36,7 @@ class TranslatorASP
 		void translateConstants(const std::string &heading, const ::pddl::ast::ConstantDeclarations &constants) const;
 
 		const ::pddl::ast::Description &m_description;
-		output::ColorStream &m_outputStream;
+		colorlog::ColorStream &m_outputStream;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/plasp/pddl/translation/Effect.h

@@ -1,10 +1,11 @@
 #ifndef __PLASP__PDDL__TRANSLATION__EFFECT_H
 #define __PLASP__PDDL__TRANSLATION__EFFECT_H
 
+#include <colorlog/Formatting.h>
+
 #include <pddlparse/AST.h>
 
-#include <plasp/output/Formatting.h>
+#include <plasp/TranslatorException.h>
-#include <plasp/output/TranslatorException.h>
 
 #include <plasp/pddl/translation/Predicate.h>
 #include <plasp/pddl/translation/Primitives.h>
@@ -21,25 +22,25 @@ namespace pddl
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<typename PrintObjectName>
-inline void translateEffect(output::ColorStream &outputStream, const ::pddl::ast::Effect &effect, const std::string &objectType, PrintObjectName printObjectName)
+inline void translateEffect(colorlog::ColorStream &outputStream, const ::pddl::ast::Effect &effect, const std::string &objectType, PrintObjectName printObjectName)
 {
 	const auto handleUnsupported =
 		[](const auto &)
 		{
-			throw output::TranslatorException("only “and” expressions and (negated) predicates supported as action effects currently");
+			throw TranslatorException("only “and” expressions and (negated) predicates supported as action effects currently");
 		};
 
 	const auto handlePredicate =
 		[&](const ::pddl::ast::PredicatePointer &predicate, bool isPositive = true)
 		{
-			outputStream << std::endl << output::Function("postcondition") << "(";
+			outputStream << std::endl << colorlog::Function("postcondition") << "(";
 			printObjectName();
 			outputStream
-				<< ", " << output::Keyword("effect") << "("
+				<< ", " << colorlog::Keyword("effect") << "("
-				<< output::Reserved("unconditional") << ")"
+				<< colorlog::Reserved("unconditional") << ")"
 				<< ", ";
 			translatePredicateToVariable(outputStream, *predicate, isPositive);
-			outputStream << ") :- " << output::Function(objectType.c_str()) << "(";
+			outputStream << ") :- " << colorlog::Function(objectType.c_str()) << "(";
 			printObjectName();
 			outputStream << ").";
 		};

include/plasp/pddl/translation/Goal.h

@@ -1,10 +1,11 @@
 #ifndef __PLASP__PDDL__TRANSLATION__GOAL_H
 #define __PLASP__PDDL__TRANSLATION__GOAL_H
 
+#include <colorlog/Formatting.h>
+
 #include <pddlparse/AST.h>
 
-#include <plasp/output/Formatting.h>
+#include <plasp/TranslatorException.h>
-#include <plasp/output/TranslatorException.h>
 
 #include <plasp/pddl/translation/Predicate.h>
 #include <plasp/pddl/translation/Primitives.h>
@@ -20,18 +21,18 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline void translateGoal(output::ColorStream &outputStream, const ::pddl::ast::Goal &goal)
+inline void translateGoal(colorlog::ColorStream &outputStream, const ::pddl::ast::Goal &goal)
 {
 	const auto handleUnsupported =
 		[](const auto &)
 		{
-			throw output::TranslatorException("only “and” expressions and (negated) predicates supported as goals currently");
+			throw TranslatorException("only “and” expressions and (negated) predicates supported as goals currently");
 		};
 
 	const auto handlePredicate =
 		[&](const ::pddl::ast::PredicatePointer &predicate, bool isPositive = true)
 		{
-			outputStream << std::endl << output::Function("goal") << "(";
+			outputStream << std::endl << colorlog::Function("goal") << "(";
 			// TODO: assert that goal is variable-free
 			translatePredicateToVariable(outputStream, *predicate, isPositive);
 			outputStream << ").";

include/plasp/pddl/translation/Precondition.h

@@ -1,10 +1,11 @@
 #ifndef __PLASP__PDDL__TRANSLATION__PRECONDITION_H
 #define __PLASP__PDDL__TRANSLATION__PRECONDITION_H
 
+#include <colorlog/Formatting.h>
+
 #include <pddlparse/AST.h>
 
-#include <plasp/output/Formatting.h>
+#include <plasp/TranslatorException.h>
-#include <plasp/output/TranslatorException.h>
 
 #include <plasp/pddl/translation/Predicate.h>
 #include <plasp/pddl/translation/Primitives.h>
@@ -21,22 +22,22 @@ namespace pddl
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<typename PrintObjectName>
-inline void translatePrecondition(output::ColorStream &outputStream, const ::pddl::ast::Precondition &precondition, const std::string &objectType, PrintObjectName printObjectName)
+inline void translatePrecondition(colorlog::ColorStream &outputStream, const ::pddl::ast::Precondition &precondition, const std::string &objectType, PrintObjectName printObjectName)
 {
 	const auto handleUnsupported =
 		[](const auto &)
 		{
-			throw output::TranslatorException("only “and” expressions and (negated) predicates supported as action preconditions currently");
+			throw TranslatorException("only “and” expressions and (negated) predicates supported as action preconditions currently");
 		};
 
 	const auto handlePredicate =
 		[&](const ::pddl::ast::PredicatePointer &predicate, bool isPositive = true)
 		{
-			outputStream << std::endl << output::Function("precondition") << "(";
+			outputStream << std::endl << colorlog::Function("precondition") << "(";
 			printObjectName();
 			outputStream << ", ";
 			translatePredicateToVariable(outputStream, *predicate, isPositive);
-			outputStream << ") :- " << output::Function(objectType.c_str()) << "(";
+			outputStream << ") :- " << colorlog::Function(objectType.c_str()) << "(";
 			printObjectName();
 			outputStream << ").";
 		};

include/plasp/pddl/translation/Predicate.h

@@ -1,11 +1,11 @@
 #ifndef __PLASP__PDDL__TRANSLATION__PREDICATE_H
 #define __PLASP__PDDL__TRANSLATION__PREDICATE_H
 
+#include <colorlog/Formatting.h>
+
 #include <pddlparse/AST.h>
 #include <pddlparse/Parse.h>
 
-#include <plasp/output/Formatting.h>
-
 #include <plasp/pddl/translation/Primitives.h>
 #include <plasp/pddl/translation/Variables.h>
 
@@ -20,12 +20,12 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void translatePredicate(output::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate);
+void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate);
-void translatePredicateDeclaration(output::ColorStream &outputStream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration);
+void translatePredicateDeclaration(colorlog::ColorStream &outputStream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline void translatePredicate(output::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate)
+inline void translatePredicate(colorlog::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate)
 {
 	const auto &arguments = predicate.arguments;
 
@@ -44,7 +44,7 @@ inline void translatePredicate(output::ColorStream &outputStream, const ::pddl::
 		const auto handleConstant =
 			[&](const ::pddl::ast::ConstantPointer &constant)
 			{
-				outputStream << output::Keyword("constant") << "(" << *constant << ")";
+				outputStream << colorlog::Keyword("constant") << "(" << *constant << ")";
 			};
 
 		const auto handleVariable =
@@ -56,7 +56,7 @@ inline void translatePredicate(output::ColorStream &outputStream, const ::pddl::
 		const auto handleUnsupported =
 			[&](const auto &)
 			{
-				throw output::TranslatorException("only variables and constants supported in predicates currently");
+				throw TranslatorException("only variables and constants supported in predicates currently");
 			};
 
 		argument.match(handleConstant, handleVariable, handleUnsupported);
@@ -67,9 +67,9 @@ inline void translatePredicate(output::ColorStream &outputStream, const ::pddl::
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline void translatePredicateDeclaration(output::ColorStream &outputStream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration)
+inline void translatePredicateDeclaration(colorlog::ColorStream &outputStream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration)
 {
-	outputStream << output::Keyword("variable") << "(";
+	outputStream << colorlog::Keyword("variable") << "(";
 
 	if (predicateDeclaration.parameters.empty())
 	{
@@ -84,18 +84,18 @@ inline void translatePredicateDeclaration(output::ColorStream &outputStream, con
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void translatePredicateToVariable(output::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate, bool isPositive = true)
+void translatePredicateToVariable(colorlog::ColorStream &outputStream, const ::pddl::ast::Predicate &predicate, bool isPositive = true)
 {
-	outputStream << output::Keyword("variable") << "(";
+	outputStream << colorlog::Keyword("variable") << "(";
 	translatePredicate(outputStream, predicate);
-	outputStream << "), " << output::Keyword("value") << "(";
+	outputStream << "), " << colorlog::Keyword("value") << "(";
 	translatePredicate(outputStream, predicate);
 	outputStream << ", ";
 
 	if (isPositive)
-		outputStream << output::Boolean("true");
+		outputStream << colorlog::Boolean("true");
 	else
-		outputStream << output::Boolean("false");
+		outputStream << colorlog::Boolean("false");
 
 	outputStream << ")";
 }

include/plasp/pddl/translation/Primitives.h

@@ -1,10 +1,11 @@
 #ifndef __PLASP__PDDL__TRANSLATION__PRIMITIVES_H
 #define __PLASP__PDDL__TRANSLATION__PRIMITIVES_H
 
+#include <colorlog/Formatting.h>
+
 #include <pddlparse/AST.h>
 
-#include <plasp/output/Formatting.h>
+#include <plasp/TranslatorException.h>
-#include <plasp/output/TranslatorException.h>
 
 namespace plasp
 {
@@ -17,16 +18,16 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl::ast::ConstantDeclaration &constantDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::ConstantDeclaration &constantDeclaration)
 {
 	assert(!constantDeclaration.name.empty());
 
-	return (stream << output::String(constantDeclaration.name.c_str()));
+	return (stream << colorlog::String(constantDeclaration.name.c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl::ast::Constant &constant)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::Constant &constant)
 {
 	assert(constant.declaration != nullptr);
 
@@ -35,16 +36,16 @@ inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl::ast::PrimitiveTypeDeclaration &primitiveTypeDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::PrimitiveTypeDeclaration &primitiveTypeDeclaration)
 {
 	assert(!primitiveTypeDeclaration.name.empty());
 
-	return (stream << output::String(primitiveTypeDeclaration.name.c_str()));
+	return (stream << colorlog::String(primitiveTypeDeclaration.name.c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl::ast::PrimitiveType &primitiveType)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::PrimitiveType &primitiveType)
 {
 	assert(primitiveType.declaration != nullptr);
 
@@ -53,7 +54,7 @@ inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &operator<<(output::ColorStream &stream, ::pddl::ast::VariableDeclaration &variableDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::ast::VariableDeclaration &variableDeclaration)
 {
 	assert(!variableDeclaration.name.empty());
 	assert(std::isalpha(variableDeclaration.name[0]));
@@ -62,14 +63,14 @@ inline output::ColorStream &operator<<(output::ColorStream &stream, ::pddl::ast:
 		variableDeclaration.name[0] = std::toupper(variableDeclaration.name[0]);
 
 	return (stream
-		<< output::Format({output::Color::Green, output::FontWeight::Bold})
+		<< colorlog::Format({colorlog::Color::Green, colorlog::FontWeight::Bold})
 		<< variableDeclaration.name
-		<< output::ResetFormat());
+		<< colorlog::ResetFormat());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &operator<<(output::ColorStream &stream, ::pddl::ast::Variable &variable)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, ::pddl::ast::Variable &variable)
 {
 	assert(variable.declaration != nullptr);
 
@@ -79,23 +80,23 @@ inline output::ColorStream &operator<<(output::ColorStream &stream, ::pddl::ast:
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // TODO: move to appropriate header
-inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl::ast::Action &action)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::Action &action)
 {
-	return (stream << output::String(action.name.c_str()));
+	return (stream << colorlog::String(action.name.c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // TODO: move to appropriate header
-inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::PredicateDeclaration &predicateDeclaration)
 {
-	return (stream << output::String(predicateDeclaration.name.c_str()));
+	return (stream << colorlog::String(predicateDeclaration.name.c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // TODO: move to appropriate header
-inline output::ColorStream &operator<<(output::ColorStream &stream, const ::pddl::ast::Predicate &predicate)
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const ::pddl::ast::Predicate &predicate)
 {
 	return (stream << *predicate.declaration);
 }

include/plasp/pddl/translation/Variables.h

@@ -1,11 +1,12 @@
 #ifndef __PLASP__PDDL__TRANSLATION__VARIABLES_H
 #define __PLASP__PDDL__TRANSLATION__VARIABLES_H
 
+#include <colorlog/Formatting.h>
+
 #include <pddlparse/AST.h>
 #include <pddlparse/Parse.h>
 
-#include <plasp/output/Formatting.h>
+#include <plasp/TranslatorException.h>
-#include <plasp/output/TranslatorException.h>
 
 namespace plasp
 {
@@ -19,14 +20,14 @@ namespace pddl
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<class T>
-void translateVariablesForRuleHead(output::ColorStream &outputStream, const T &variables);
+void translateVariablesForRuleHead(colorlog::ColorStream &outputStream, const T &variables);
 template<class T>
-void translateVariablesForRuleBody(output::ColorStream &outputStream, const T &variables);
+void translateVariablesForRuleBody(colorlog::ColorStream &outputStream, const T &variables);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<class T>
-inline void translateVariablesForRuleHead(output::ColorStream &outputStream, const T &variables)
+inline void translateVariablesForRuleHead(colorlog::ColorStream &outputStream, const T &variables)
 {
 	if (variables.empty())
 		return;
@@ -38,7 +39,7 @@ inline void translateVariablesForRuleHead(output::ColorStream &outputStream, con
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<class T>
-inline void translateVariablesForRuleBody(output::ColorStream &outputStream, const T &variables)
+inline void translateVariablesForRuleBody(colorlog::ColorStream &outputStream, const T &variables)
 {
 	if (variables.empty())
 		return;
@@ -53,18 +54,18 @@ inline void translateVariablesForRuleBody(output::ColorStream &outputStream, con
 		if (variable->type)
 		{
 			if (!variable->type.value().template is<::pddl::ast::PrimitiveTypePointer>())
-				throw output::TranslatorException("only primitive types supported currently");
+				throw TranslatorException("only primitive types supported currently");
 
 			const auto &type = variable->type.value().template get<::pddl::ast::PrimitiveTypePointer>();
 
-			outputStream << output::Function("has") << "("
+			outputStream << colorlog::Function("has") << "("
-				<< *variable << ", " << output::Keyword("type") << "(" << *type << "))";
+				<< *variable << ", " << colorlog::Keyword("type") << "(" << *type << "))";
 		}
 		else
 		{
-			outputStream << output::Function("has") << "("
+			outputStream << colorlog::Function("has") << "("
 				<< *variable << ", "
-				<< output::Keyword("type") << "(" << output::String("object") << "))";
+				<< colorlog::Keyword("type") << "(" << colorlog::String("object") << "))";
 		}
 	}
 }

include/plasp/sas/AssignedVariable.h

@@ -4,11 +4,11 @@
 #include <iosfwd>
 #include <vector>
 
+#include <tokenize/Tokenizer.h>
+
 #include <plasp/sas/Value.h>
 #include <plasp/sas/Variable.h>
 
-#include <tokenize/Tokenizer.h>
-
 namespace plasp
 {
 namespace sas

include/plasp/sas/AxiomRule.h

@@ -3,11 +3,11 @@
 
 #include <vector>
 
+#include <tokenize/Tokenizer.h>
+
 #include <plasp/sas/AssignedVariable.h>
 #include <plasp/sas/Variable.h>
 
-#include <tokenize/Tokenizer.h>
-
 namespace plasp
 {
 namespace sas

include/plasp/sas/Debugging.h

@@ -3,6 +3,8 @@
 
 #include <iosfwd>
 
+#include <colorlog/ColorStream.h>
+
 #include <plasp/sas/Description.h>
 
 namespace plasp
@@ -16,7 +18,7 @@ namespace sas
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-output::ColorStream &operator<<(output::ColorStream &ostream, const Description &description);
+colorlog::ColorStream &operator<<(colorlog::ColorStream &ostream, const Description &description);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 

include/plasp/sas/Description.h

@@ -6,6 +6,7 @@
 #include <memory>
 #include <vector>
 
+#include <tokenize/Tokenizer.h>
 
 #include <plasp/sas/AxiomRule.h>
 #include <plasp/sas/Goal.h>
@@ -14,8 +15,6 @@
 #include <plasp/sas/Operator.h>
 #include <plasp/sas/Variable.h>
 
-#include <tokenize/Tokenizer.h>
-
 namespace plasp
 {
 namespace sas

include/plasp/sas/Effect.h

@@ -3,11 +3,11 @@
 
 #include <vector>
 
+#include <tokenize/Tokenizer.h>
+
 #include <plasp/sas/AssignedVariable.h>
 #include <plasp/sas/Variable.h>
 
-#include <tokenize/Tokenizer.h>
-
 namespace plasp
 {
 namespace sas

include/plasp/sas/Goal.h

@@ -1,10 +1,10 @@
 #ifndef __PLASP__SAS__GOAL_H
 #define __PLASP__SAS__GOAL_H
 
-#include <plasp/sas/AssignedVariable.h>
-
 #include <tokenize/Tokenizer.h>
 
+#include <plasp/sas/AssignedVariable.h>
+
 namespace plasp
 {
 namespace sas

include/plasp/sas/InitialState.h

@@ -1,10 +1,10 @@
 #ifndef __PLASP__SAS__INITIAL_STATE_H
 #define __PLASP__SAS__INITIAL_STATE_H
 
-#include <plasp/sas/AssignedVariable.h>
-
 #include <tokenize/Tokenizer.h>
 
+#include <plasp/sas/AssignedVariable.h>
+
 namespace plasp
 {
 namespace sas

include/plasp/sas/MutexGroup.h

@@ -3,10 +3,10 @@
 
 #include <vector>
 
-#include <plasp/sas/AssignedVariable.h>
-
 #include <tokenize/Tokenizer.h>
 
+#include <plasp/sas/AssignedVariable.h>
+
 namespace plasp
 {
 namespace sas

include/plasp/sas/Operator.h

@@ -4,13 +4,15 @@
 #include <string>
 #include <vector>
 
-#include <plasp/output/ColorStream.h>
+#include <tokenize/Tokenizer.h>
+
+#include <colorlog/ColorStream.h>
+
 #include <plasp/sas/AssignedVariable.h>
 #include <plasp/sas/Effect.h>
 #include <plasp/sas/Predicate.h>
 #include <plasp/sas/Variable.h>
 
-#include <tokenize/Tokenizer.h>
 
 namespace plasp
 {
@@ -37,7 +39,7 @@ class Operator
 		static Operator fromSAS(tokenize::Tokenizer<> &tokenizer, const Variables &variables);
 
 	public:
-		void printPredicateAsASP(output::ColorStream &stream) const;
+		void printPredicateAsASP(colorlog::ColorStream &stream) const;
 
 		const Predicate &predicate() const;
 		const Conditions &preconditions() const;

include/plasp/sas/Predicate.h

@@ -5,10 +5,10 @@
 #include <string>
 #include <vector>
 
-#include <plasp/output/ColorStream.h>
-
 #include <tokenize/Tokenizer.h>
 
+#include <colorlog/ColorStream.h>
+
 namespace plasp
 {
 namespace sas
@@ -28,8 +28,8 @@ class Predicate
 		using Arguments = std::vector<std::string>;
 
 	public:
-		void printAsSAS(output::ColorStream &stream) const;
+		void printAsSAS(colorlog::ColorStream &stream) const;
-		void printAsASP(output::ColorStream &stream) const;
+		void printAsASP(colorlog::ColorStream &stream) const;
 
 		const std::string &name() const;
 		const Arguments &arguments() const;

include/plasp/sas/TranslatorASP.h

@@ -3,7 +3,8 @@
 
 #include <iosfwd>
 
-#include <plasp/output/ColorStream.h>
+#include <colorlog/ColorStream.h>
+
 #include <plasp/sas/Description.h>
 
 namespace plasp
@@ -20,7 +21,7 @@ namespace sas
 class TranslatorASP
 {
 	public:
-		explicit TranslatorASP(const Description &description, output::ColorStream &outputStream);
+		explicit TranslatorASP(const Description &description, colorlog::ColorStream &outputStream);
 
 		void translate() const;
 
@@ -34,7 +35,7 @@ class TranslatorASP
 		void translateAxiomRules() const;
 
 		const Description &m_description;
-		output::ColorStream &m_outputStream;
+		colorlog::ColorStream &m_outputStream;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/plasp/sas/Value.h

@@ -5,10 +5,10 @@
 #include <string>
 #include <vector>
 
-#include <plasp/output/ColorStream.h>
-
 #include <tokenize/Tokenizer.h>
 
+#include <colorlog/ColorStream.h>
+
 namespace plasp
 {
 namespace sas
@@ -46,8 +46,8 @@ struct Value
 	public:
 		Value negated() const;
 
-		void printAsSAS(output::ColorStream &stream) const;
+		void printAsSAS(colorlog::ColorStream &stream) const;
-		void printAsASPPredicate(output::ColorStream &stream) const;
+		void printAsASPPredicate(colorlog::ColorStream &stream) const;
 
 		Sign sign() const;
 		const std::string &name() const;

include/plasp/sas/Variable.h

@@ -5,11 +5,12 @@
 #include <string>
 #include <vector>
 
-#include <plasp/output/ColorStream.h>
-#include <plasp/sas/Value.h>
-
 #include <tokenize/Tokenizer.h>
 
+#include <colorlog/ColorStream.h>
+
+#include <plasp/sas/Value.h>
+
 namespace plasp
 {
 namespace sas
@@ -33,7 +34,7 @@ class Variable
 		static const Variable &referenceFromSAS(tokenize::Tokenizer<> &tokenizer, const Variables &variables);
 
 	public:
-		void printNameAsASPPredicate(output::ColorStream &outputStream) const;
+		void printNameAsASPPredicate(colorlog::ColorStream &outputStream) const;
 
 		const std::string &name() const;
 		int axiomLayer() const;

include/plasp/sas/VariableTransition.h

@@ -3,11 +3,11 @@
 
 #include <iosfwd>
 
+#include <tokenize/Tokenizer.h>
+
 #include <plasp/sas/Value.h>
 #include <plasp/sas/Variable.h>
 
-#include <tokenize/Tokenizer.h>
-
 namespace plasp
 {
 namespace sas

lib/colorlog/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 2.6)
+project(colorlog)
+
+set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -Werror ${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS_DEBUG "-g ${CMAKE_CXX_FLAGS_DEBUG}")
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+if (CMAKE_GENERATOR STREQUAL "Ninja" AND
+	((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9) OR
+	(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5)))
+	# Force colored warnings in Ninja's output, if the compiler has -fdiagnostics-color support.
+	# Rationale in https://github.com/ninja-build/ninja/issues/814
+	set(CMAKE_CXX_FLAGS "-fdiagnostics-color=always ${CMAKE_CXX_FLAGS}")
+endif()
+
+add_subdirectory(src)

lib/colorlog/include/colorlog/ColorStream.h

@@ -1,12 +1,10 @@
-#ifndef __PLASP__OUTPUT__COLOR_STREAM_H
+#ifndef __COLOR_LOG__COLOR_STREAM_H
-#define __PLASP__OUTPUT__COLOR_STREAM_H
+#define __COLOR_LOG__COLOR_STREAM_H
 
 #include <iostream>
 #include <unistd.h>
 
-namespace plasp
+namespace colorlog
-{
-namespace output
 {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -288,7 +286,6 @@ ColorStream &ColorStream::operator<<(unsigned char value)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-}
 }
 
 #endif

lib/colorlog/include/colorlog/Formatting.h

@@ -1,13 +1,11 @@
-#ifndef __PLASP__OUTPUT__FORMATTING_H
+#ifndef __COLOR_LOG__FORMATTING_H
-#define __PLASP__OUTPUT__FORMATTING_H
+#define __COLOR_LOG__FORMATTING_H
 
 #include <iostream>
 
-#include <plasp/output/ColorStream.h>
+#include <colorlog/ColorStream.h>
 
-namespace plasp
+namespace colorlog
-{
-namespace output
 {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -89,7 +87,7 @@ struct Function
 	Function(const char *name)
 	:	name{name}
 	{
-	};
+	}
 
 	const char *name;
 };
@@ -111,7 +109,7 @@ struct Keyword
 	Keyword(const char *name)
 	:	name{name}
 	{
-	};
+	}
 
 	const char *name;
 };
@@ -133,7 +131,7 @@ struct Operator
 	Operator(const char *name)
 	:	name{name}
 	{
-	};
+	}
 
 	const char *name;
 };
@@ -153,7 +151,7 @@ struct Number
 	Number(T value)
 	:	value{value}
 	{
-	};
+	}
 
 	T value;
 };
@@ -176,7 +174,7 @@ struct Variable
 	Variable(const char *name)
 	:	name{name}
 	{
-	};
+	}
 
 	const char *name;
 };
@@ -198,7 +196,7 @@ struct String
 	String(const char *content)
 	:	content{content}
 	{
-	};
+	}
 
 	const char *content;
 };
@@ -220,7 +218,7 @@ struct Boolean
 	Boolean(const char *value)
 	:	value{value}
 	{
-	};
+	}
 
 	const char *value;
 };
@@ -242,7 +240,7 @@ struct Reserved
 	Reserved(const char *name)
 	:	name{name}
 	{
-	};
+	}
 
 	const char *name;
 };
@@ -264,7 +262,7 @@ struct Heading1
 	Heading1(const char *content)
 	:	content{content}
 	{
-	};
+	}
 
 	const char *content;
 };
@@ -289,7 +287,7 @@ struct Heading2
 	Heading2(const char *content)
 	:	content{content}
 	{
-	};
+	}
 
 	const char *content;
 };
@@ -307,7 +305,6 @@ inline ColorStream &operator<<(ColorStream &stream, const Heading2 &heading2)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-}
 }
 
 #endif

lib/colorlog/include/colorlog/Logger.h

@@ -1,16 +1,14 @@
-#ifndef __PLASP__OUTPUT__LOGGER_H
+#ifndef __COLOR_LOG__LOGGER_H
-#define __PLASP__OUTPUT__LOGGER_H
+#define __COLOR_LOG__LOGGER_H
 
 #include <string>
 
-#include <plasp/output/ColorStream.h>
+#include <colorlog/ColorStream.h>
-#include <plasp/output/Priority.h>
+#include <colorlog/Priority.h>
 
 #include <tokenize/Location.h>
 
-namespace plasp
+namespace colorlog
-{
-namespace output
 {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -50,7 +48,6 @@ class Logger
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-}
 }
 
 #endif

lib/colorlog/include/colorlog/Priority.h

@@ -1,12 +1,10 @@
-#ifndef __PLASP__OUTPUT__PRIORITY_H
+#ifndef __COLOR_LOG__PRIORITY_H
-#define __PLASP__OUTPUT__PRIORITY_H
+#define __COLOR_LOG__PRIORITY_H
 
 #include <cstring>
 #include <exception>
 
-namespace plasp
+namespace colorlog
-{
-namespace output
 {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -60,7 +58,6 @@ inline Priority priorityFromName(const char *priorityName)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-}
 }
 
 #endif

lib/colorlog/src/CMakeLists.txt

@@ -0,0 +1,21 @@
+set(target colorlog)
+
+file(GLOB core_sources "colorlog/*.cpp")
+file(GLOB core_headers "../include/colorlog/*.h")
+
+set(includes
+	${PROJECT_SOURCE_DIR}/include
+	${PROJECT_SOURCE_DIR}/../../lib/tokenize/include
+)
+
+set(sources
+	${core_sources}
+	${core_headers}
+)
+
+set(libraries
+)
+
+add_library(${target} ${sources})
+target_include_directories(${target} PRIVATE ${includes})
+target_link_libraries(${target} ${libraries})

lib/colorlog/src/colorlog/Logger.cpp

@@ -1,10 +1,8 @@
-#include <plasp/output/Logger.h>
+#include <colorlog/Logger.h>
 
-#include <plasp/output/Formatting.h>
+#include <colorlog/Formatting.h>
 
-namespace plasp
+namespace colorlog
-{
-namespace output
 {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -165,4 +163,3 @@ void Logger::log(Priority priority, const tokenize::Location &location, const st
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 }
-}

lib/pddlparse/include/pddlparse/AST.h

@@ -61,23 +61,6 @@ struct ConstantDeclaration
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-struct Dummy
-{
-	explicit Dummy(std::string name)
-	:	name{name}
-	{
-	}
-
-	Dummy(const Dummy &other) = delete;
-	Dummy &operator=(const Dummy &&other) = delete;
-	Dummy(Dummy &&other) = default;
-	Dummy &operator=(Dummy &&other) = default;
-
-	std::string name;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
 struct PrimitiveType
 {
 	explicit PrimitiveType(PrimitiveTypeDeclaration *declaration)
@@ -288,6 +271,7 @@ struct And: public NAry<And<Argument>, Argument>
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+// TODO: make binary expression
 template<class Argument>
 struct At
 {

lib/pddlparse/include/pddlparse/ASTOutput.h

@@ -0,0 +1,728 @@
+#ifndef __PDDL_PARSE__AST_OUTPUT_H
+#define __PDDL_PARSE__AST_OUTPUT_H
+
+#include <colorlog/ColorStream.h>
+#include <colorlog/Formatting.h>
+
+#include <pddlparse/AST.h>
+#include <pddlparse/detail/parsing/Requirement.h>
+
+namespace pddl
+{
+namespace ast
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Output
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace detail
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct PrintContext
+{
+	size_t indentationLevel{0};
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct Identifier
+{
+	Identifier(const char *content)
+	:	content{content}
+	{
+	}
+
+	Identifier(const std::string &content)
+	:	content{content.c_str()}
+	{
+	}
+
+	const char *content;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const Identifier &identifier)
+{
+	return (stream
+		<< colorlog::Format({colorlog::Color::Green, colorlog::FontWeight::Normal})
+		<< identifier.content << colorlog::ResetFormat());
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct Type
+{
+	Type(const char *name)
+	:	name{name}
+	{
+	}
+
+	Type(const std::string &name)
+	:	name{name.c_str()}
+	{
+	}
+
+	const char *name;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const Type &type)
+{
+	return (stream
+		<< colorlog::Format({colorlog::Color::Red, colorlog::FontWeight::Normal})
+		<< type.name << colorlog::ResetFormat());
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct Constant
+{
+	Constant(const char *name)
+	:	name{name}
+	{
+	}
+
+	Constant(const std::string &name)
+	:	name{name.c_str()}
+	{
+	}
+
+	const char *name;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const Constant &constant)
+{
+	return (stream
+		<< colorlog::Format({colorlog::Color::Yellow, colorlog::FontWeight::Normal})
+		<< constant.name << colorlog::ResetFormat());
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+colorlog::ColorStream &printIndentedNewline(colorlog::ColorStream &stream, detail::PrintContext &printContext)
+{
+	stream << std::endl;
+
+	for (size_t i = 0; i < printContext.indentationLevel; i++)
+		stream << "\t";
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Forward declarations
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Constant &constant, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const ConstantDeclaration &constantDeclaration, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const PrimitiveType &primitiveType, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const PrimitiveTypeDeclaration &primitiveTypeDeclaration, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Variable &variable, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const VariableDeclaration &variableDeclaration, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Predicate &predicate, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const PredicateDeclaration &predicateDeclaration, detail::PrintContext &printContext);
+
+template<class Derived, class ArgumentLeft, class ArgumentRight = ArgumentLeft>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Binary<Derived, ArgumentLeft, ArgumentRight> &binary, detail::PrintContext &printContext);
+template<class Derived, class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const NAry<Derived, Argument> &nAry, detail::PrintContext &printContext);
+template<class Derived, class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Quantified<Derived, Argument> &quantified, detail::PrintContext &printContext);
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const At<Argument> &at, detail::PrintContext &printContext);
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Not<Argument> &not_, detail::PrintContext &printContext);
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Action &action, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Domain &domain, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const InitialState &initialState, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Problem &problem, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Requirement &requirement, detail::PrintContext &printContext);
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Description &description, detail::PrintContext &printContext);
+
+template<class ValueType>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const std::unique_ptr<ValueType> &variant, detail::PrintContext &printContext);
+template<class ValueType>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const std::vector<ValueType> &variant, detail::PrintContext &printContext);
+template<class Variant>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Variant &variant, detail::PrintContext &printContext);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Primitives
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Constant &constant, detail::PrintContext &)
+{
+	return stream << detail::Constant(constant.declaration->name);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const ConstantDeclaration &constantDeclaration, detail::PrintContext &printContext)
+{
+	stream << detail::Constant(constantDeclaration.name);
+
+	if (constantDeclaration.type)
+	{
+		stream << " - ";
+		print(stream, constantDeclaration.type.value(), printContext);
+	}
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const PrimitiveType &primitiveType, detail::PrintContext &)
+{
+	return stream << detail::Type(primitiveType.declaration->name);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const PrimitiveTypeDeclaration &primitiveTypeDeclaration, detail::PrintContext &printContext)
+{
+	if (primitiveTypeDeclaration.parentTypes.empty())
+		return (stream << detail::Type(primitiveTypeDeclaration.name));
+
+	if (!primitiveTypeDeclaration.parentTypes.empty())
+		for (const auto &parentType : primitiveTypeDeclaration.parentTypes)
+		{
+			if (&parentType != &primitiveTypeDeclaration.parentTypes.front())
+				printIndentedNewline(stream, printContext);
+
+			stream << detail::Type(primitiveTypeDeclaration.name) << " - " << detail::Type(parentType->declaration->name);
+		}
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Unsupported &unsupported, detail::PrintContext &)
+{
+	const auto unsupportedName = "<unsupported " + unsupported.type + ">";
+
+	return (stream << colorlog::Reserved(unsupportedName.c_str()));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Variable &variable, detail::PrintContext &)
+{
+	const auto variableName = "?" + variable.declaration->name;
+
+	return (stream << colorlog::Variable(variableName.c_str()));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const VariableDeclaration &variableDeclaration, detail::PrintContext &printContext)
+{
+	const auto variableName = "?" + variableDeclaration.name;
+
+	stream << colorlog::Variable(variableName.c_str());
+
+	if (variableDeclaration.type)
+	{
+		stream << " - ";
+		print(stream, *variableDeclaration.type, printContext);
+	}
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Compounds
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Predicate &predicate, detail::PrintContext &printContext)
+{
+	stream << "(" << detail::Identifier(predicate.declaration->name) << " ";
+
+	for (const auto &argument : predicate.arguments)
+	{
+		if (&argument != &predicate.arguments.front())
+			stream << " ";
+
+		print(stream, argument, printContext);
+	}
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const PredicateDeclaration &predicateDeclaration, detail::PrintContext &printContext)
+{
+	stream << "(" << detail::Identifier(predicateDeclaration.name);
+
+	for (const auto &parameter : predicateDeclaration.parameters)
+	{
+		stream << " ";
+		print(stream, *parameter, printContext);
+	}
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Expressions: Base Classes
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Derived, class ArgumentLeft, class ArgumentRight>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Binary<Derived, ArgumentLeft, ArgumentRight> &binary, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword(Derived::Identifier);
+
+	printContext.indentationLevel++;
+
+	printIndentedNewline(stream, printContext);
+	print(stream, binary.argumentLeft, printContext);
+	printIndentedNewline(stream, printContext);
+	print(stream, binary.argumentRight, printContext);
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Derived, class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const NAry<Derived, Argument> &nAry, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword(Derived::Identifier);
+
+	printContext.indentationLevel++;
+
+	for (const auto &argument : nAry.arguments)
+	{
+		printIndentedNewline(stream, printContext);
+		print(stream, argument, printContext);
+	}
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Derived, class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Quantified<Derived, Argument> &quantified, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword(Derived::Identifier);
+
+	printContext.indentationLevel++;
+
+	printIndentedNewline(stream, printContext);
+	print(stream, quantified.parameters, printContext);
+	printIndentedNewline(stream, printContext);
+	print(stream, quantified.argument, printContext);
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Expressions
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const And<Argument> &and_, detail::PrintContext &printContext)
+{
+	return print(stream, static_cast<const NAry<And<Argument>, Argument> &>(and_), printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const At<Argument> &at, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword("at");
+
+	printContext.indentationLevel++;
+
+	printIndentedNewline(stream, printContext);
+	stream << colorlog::Number<decltype(at.timePoint)>(at.timePoint);
+	printIndentedNewline(stream, printContext);
+	print(stream, at.argument, printContext);
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Either<Argument> &either, detail::PrintContext &printContext)
+{
+	return print(stream, static_cast<const NAry<Either<Argument>, Argument> &>(either), printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Exists<Argument> &exists, detail::PrintContext &printContext)
+{
+	return print(stream, static_cast<const Quantified<Exists<Argument>, Argument> &>(exists), printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const ForAll<Argument> &forAll, detail::PrintContext &printContext)
+{
+	return print(stream, static_cast<const Quantified<ForAll<Argument>, Argument> &>(forAll), printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Imply<Argument> &imply, detail::PrintContext &printContext)
+{
+	return print(stream, static_cast<const Binary<Imply<Argument>, Argument> &>(imply), printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Not<Argument> &not_, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword("not");
+
+	printContext.indentationLevel++;
+
+	printIndentedNewline(stream, printContext);
+	print(stream, not_.argument, printContext);
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Argument>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Or<Argument> &or_, detail::PrintContext &printContext)
+{
+	return print(stream, static_cast<const NAry<Or<Argument>, Argument> &>(or_), printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class ArgumentLeft, class ArgumentRight>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const When<ArgumentLeft, ArgumentRight> &when, detail::PrintContext &printContext)
+{
+	return print(stream, static_cast<const Binary<When<ArgumentLeft, ArgumentRight>, ArgumentLeft, ArgumentRight> &>(when), printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// PDDL Structure
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Action &action, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword(":action") << " " << detail::Identifier(action.name);
+
+	printContext.indentationLevel++;
+
+	if (!action.parameters.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":parameters");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, action.parameters, printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (action.precondition)
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":precondition");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, action.precondition.value(), printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (action.effect)
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":effect");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, action.effect.value(), printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Domain &domain, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword("define") << " (" << colorlog::Keyword("domain") << " " << detail::Identifier(domain.name) << ")";
+
+	printContext.indentationLevel++;
+
+	if (!domain.requirements.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":requirements");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, domain.requirements, printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (!domain.types.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":types");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, domain.types, printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (!domain.constants.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":constants");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, domain.constants, printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (!domain.predicates.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":predicates");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, domain.predicates, printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (!domain.actions.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		print(stream, domain.actions, printContext);
+	}
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const InitialState &initialState, detail::PrintContext &printContext)
+{
+	assert(!initialState.facts.empty());
+
+	stream << "(" << colorlog::Keyword(":init");
+
+	printContext.indentationLevel++;
+
+	printIndentedNewline(stream, printContext);
+	print(stream, initialState.facts, printContext);
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Problem &problem, detail::PrintContext &printContext)
+{
+	stream << "(" << colorlog::Keyword("define") << " (" << colorlog::Keyword("problem") << " " << detail::Identifier(problem.name) << ")";
+
+	printContext.indentationLevel++;
+
+	printIndentedNewline(stream, printContext);
+	stream << "(" << colorlog::Keyword(":domain") << " " << detail::Identifier(problem.domain->name) << ")";
+
+	if (!problem.requirements.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":requirements");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, problem.requirements, printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (!problem.objects.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":objects");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, problem.objects, printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	if (!problem.initialState.facts.empty())
+	{
+		printIndentedNewline(stream, printContext);
+		print(stream, problem.initialState, printContext);
+	}
+
+	if (problem.goal)
+	{
+		printIndentedNewline(stream, printContext);
+		stream << "(" << colorlog::Keyword(":goal");
+
+		printContext.indentationLevel++;
+
+		printIndentedNewline(stream, printContext);
+		print(stream, problem.goal.value(), printContext);
+		stream << ")";
+
+		printContext.indentationLevel--;
+	}
+
+	printContext.indentationLevel--;
+
+	return (stream << ")");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Requirement &requirement, detail::PrintContext &)
+{
+	auto requirementName = std::string(":") + pddl::detail::toString(requirement);
+
+	return (stream << detail::Identifier(requirementName.c_str()));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Description &description, detail::PrintContext &printContext)
+{
+	print(stream, *description.domain, printContext);
+	stream << std::endl;
+
+	if (description.problem)
+	{
+		stream << std::endl;
+		print(stream, *description.problem.value(), printContext);
+		stream << std::endl;
+	}
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline colorlog::ColorStream &operator<<(colorlog::ColorStream &stream, const Description &description)
+{
+	detail::PrintContext printContext;
+
+	return print(stream, description, printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Variants
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class ValueType>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const std::unique_ptr<ValueType> &uniquePointer, detail::PrintContext &printContext)
+{
+	assert(uniquePointer);
+	return print(stream, *uniquePointer, printContext);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class ValueType>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const std::vector<ValueType> &vector, detail::PrintContext &printContext)
+{
+	for (const auto &element : vector)
+	{
+		if (&element != &vector.front())
+			printIndentedNewline(stream, printContext);
+
+		print(stream, element, printContext);
+	}
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class Variant>
+inline colorlog::ColorStream &print(colorlog::ColorStream &stream, const Variant &variant, detail::PrintContext &printContext)
+{
+	variant.match([&](const auto &x){return print(stream, x, printContext);});
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+}
+
+#endif

lib/pddlparse/src/CMakeLists.txt

@@ -11,6 +11,7 @@ file(GLOB detail_parsing_headers "../include/pddlparse/detail/parsing/*.h")
 
 set(includes
 	${PROJECT_SOURCE_DIR}/include
+	${PROJECT_SOURCE_DIR}/../../lib/colorlog/include
 	${PROJECT_SOURCE_DIR}/../../lib/tokenize/include
 	${PROJECT_SOURCE_DIR}/../../lib/variant/include
 )

src/CMakeLists.txt

@@ -6,28 +6,17 @@ file(GLOB core_headers "../include/plasp/*.h")
 file(GLOB pddl_sources "plasp/pddl/*.cpp")
 file(GLOB pddl_headers "../include/plasp/pddl/*.h")
 
-file(GLOB pddl_expressions_sources "plasp/pddl/expressions/*.cpp")
-file(GLOB pddl_expressions_headers "../include/plasp/pddl/expressions/*.h")
-
 file(GLOB pddl_translation_sources "plasp/pddl/translation/*.cpp")
 file(GLOB pddl_translation_headers "../include/plasp/pddl/translation/*.h")
 
 file(GLOB sas_sources "plasp/sas/*.cpp")
 file(GLOB sas_headers "../include/plasp/sas/*.h")
 
-file(GLOB input_sources "plasp/input/*.cpp")
-file(GLOB input_headers "../include/plasp/input/*.h")
-
-file(GLOB output_sources "plasp/output/*.cpp")
-file(GLOB output_headers "../include/plasp/output/*.h")
-
-file(GLOB utils_sources "plasp/utils/*.cpp")
-file(GLOB utils_headers "../include/plasp/utils/*.h")
-
 set(includes
 	${Boost_INCLUDE_DIRS}
 	${PROJECT_SOURCE_DIR}/include
 	${PROJECT_SOURCE_DIR}/lib/tokenize/include
+	${PROJECT_SOURCE_DIR}/lib/colorlog/include
 	${PROJECT_SOURCE_DIR}/lib/variant/include
 	${PROJECT_SOURCE_DIR}/lib/pddlparse/include
 )
@@ -60,6 +49,7 @@ set(sources
 
 set(libraries
 	${Boost_LIBRARIES}
+	colorlog
 	pddlparse
 	pthread
 )

src/plasp/pddl/TranslatorASP.cpp

@@ -2,10 +2,11 @@
 
 #include <boost/assert.hpp>
 
+#include <colorlog/Formatting.h>
+
 #include <pddlparse/AST.h>
 
-#include <plasp/output/Formatting.h>
+#include <plasp/TranslatorException.h>
-#include <plasp/output/TranslatorException.h>
 
 #include <plasp/pddl/translation/Effect.h>
 #include <plasp/pddl/translation/Goal.h>
@@ -25,7 +26,7 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-TranslatorASP::TranslatorASP(const ::pddl::ast::Description &description, output::ColorStream &outputStream)
+TranslatorASP::TranslatorASP(const ::pddl::ast::Description &description, colorlog::ColorStream &outputStream)
 :	m_description{description},
 	m_outputStream(outputStream)
 {
@@ -48,7 +49,7 @@ void TranslatorASP::translate() const
 
 void TranslatorASP::translateDomain() const
 {
-	m_outputStream << output::Heading1("domain");
+	m_outputStream << colorlog::Heading1("domain");
 
 	const auto &domain = m_description.domain;
 
@@ -82,7 +83,7 @@ void TranslatorASP::translateDomain() const
 
 void TranslatorASP::translateTypes() const
 {
-	m_outputStream << output::Heading2("types");
+	m_outputStream << colorlog::Heading2("types");
 
 	m_outputStream << std::endl;
 
@@ -91,8 +92,8 @@ void TranslatorASP::translateTypes() const
 	if (types.empty())
 	{
 		m_outputStream
-			<< output::Function("type") << "("
+			<< colorlog::Function("type") << "("
-			<< output::Keyword("type") << "(" << output::String("object") << "))." << std::endl;
+			<< colorlog::Keyword("type") << "(" << colorlog::String("object") << "))." << std::endl;
 
 		return;
 	}
@@ -100,8 +101,8 @@ void TranslatorASP::translateTypes() const
 	for (const auto &type : types)
 	{
 		m_outputStream
-			<< output::Function("type") << "("
+			<< colorlog::Function("type") << "("
-			<< output::Keyword("type") << "("
+			<< colorlog::Keyword("type") << "("
 			<< *type
 			<< "))." << std::endl;
 
@@ -111,23 +112,23 @@ void TranslatorASP::translateTypes() const
 			[&](const auto &parentType)
 			{
 				m_outputStream
-					<< output::Function("inherits") << "(" << output::Keyword("type")
+					<< colorlog::Function("inherits") << "(" << colorlog::Keyword("type")
-					<< "(" << *type << "), " << output::Keyword("type")
+					<< "(" << *type << "), " << colorlog::Keyword("type")
 					<< "(" << *parentType << "))." << std::endl;
 			});
 	}
 
 	m_outputStream
 		<< std::endl
-		<< output::Function("has") << "("
+		<< colorlog::Function("has") << "("
-		<< output::Variable("X") << ", "
+		<< colorlog::Variable("X") << ", "
-		<< output::Keyword("type") << "(" << output::Variable("T2") << ")) :- "
+		<< colorlog::Keyword("type") << "(" << colorlog::Variable("T2") << ")) :- "
-		<< output::Function("has") << "("
+		<< colorlog::Function("has") << "("
-		<< output::Variable("X") << ", "
+		<< colorlog::Variable("X") << ", "
-		<< output::Keyword("type") << "(" << output::Variable("T1") << ")), "
+		<< colorlog::Keyword("type") << "(" << colorlog::Variable("T1") << ")), "
-		<< output::Function("inherits") << "("
+		<< colorlog::Function("inherits") << "("
-		<< output::Keyword("type") << "(" << output::Variable("T1") << "), "
+		<< colorlog::Keyword("type") << "(" << colorlog::Variable("T1") << "), "
-		<< output::Keyword("type") << "(" << output::Variable("T2") << "))."
+		<< colorlog::Keyword("type") << "(" << colorlog::Variable("T2") << "))."
 		<< std::endl;
 }
 
@@ -135,13 +136,13 @@ void TranslatorASP::translateTypes() const
 
 void TranslatorASP::translatePredicates() const
 {
-	m_outputStream << output::Heading2("variables");
+	m_outputStream << colorlog::Heading2("variables");
 
 	const auto &predicates = m_description.domain->predicates;
 
 	for (const auto &predicate : predicates)
 	{
-		m_outputStream << std::endl << output::Function("variable") << "(";
+		m_outputStream << std::endl << colorlog::Function("variable") << "(";
 
 		translatePredicateDeclaration(m_outputStream, *predicate);
 
@@ -154,14 +155,14 @@ void TranslatorASP::translatePredicates() const
 
 	m_outputStream
 		<< std::endl << std::endl
-		<< output::Function("boolean") << "(" << output::Boolean("true") << ")." << std::endl
+		<< colorlog::Function("boolean") << "(" << colorlog::Boolean("true") << ")." << std::endl
-		<< output::Function("boolean") << "(" << output::Boolean("false") << ")." << std::endl
+		<< colorlog::Function("boolean") << "(" << colorlog::Boolean("false") << ")." << std::endl
 		<< std::endl
-		<< output::Function("contains") << "("
+		<< colorlog::Function("contains") << "("
-		<< output::Keyword("variable") << "(" << output::Variable("X") << "), "
+		<< colorlog::Keyword("variable") << "(" << colorlog::Variable("X") << "), "
-		<< output::Keyword("value") << "(" << output::Variable("X") << ", " << output::Variable("B") << ")) :- "
+		<< colorlog::Keyword("value") << "(" << colorlog::Variable("X") << ", " << colorlog::Variable("B") << ")) :- "
-		<< output::Function("variable") << "(" << output::Keyword("variable") << "(" << output::Variable("X") << ")), "
+		<< colorlog::Function("variable") << "(" << colorlog::Keyword("variable") << "(" << colorlog::Variable("X") << ")), "
-		<< output::Function("boolean") << "(" << output::Variable("B") << ")."
+		<< colorlog::Function("boolean") << "(" << colorlog::Variable("B") << ")."
 		<< std::endl;
 }
 
@@ -169,7 +170,7 @@ void TranslatorASP::translatePredicates() const
 
 void TranslatorASP::translateActions() const
 {
-	m_outputStream << output::Heading2("actions");
+	m_outputStream << colorlog::Heading2("actions");
 
 	const auto &actions = m_description.domain->actions;
 
@@ -178,7 +179,7 @@ void TranslatorASP::translateActions() const
 		const auto printActionName =
 			[&]()
 			{
-				m_outputStream << output::Keyword("action") << "(";
+				m_outputStream << colorlog::Keyword("action") << "(";
 
 				if (action->parameters.empty())
 				{
@@ -194,7 +195,7 @@ void TranslatorASP::translateActions() const
 		m_outputStream << std::endl;
 
 		// Name
-		m_outputStream << output::Function("action") << "(";
+		m_outputStream << colorlog::Function("action") << "(";
 		printActionName();
 		m_outputStream << ")";
 
@@ -217,13 +218,13 @@ void TranslatorASP::translateActions() const
 
 void TranslatorASP::translateConstants(const std::string &heading, const ::pddl::ast::ConstantDeclarations &constants) const
 {
-	m_outputStream << output::Heading2(heading.c_str());
+	m_outputStream << colorlog::Heading2(heading.c_str());
 
 	for (const auto &constant : constants)
 	{
 		m_outputStream << std::endl
-			<< output::Function("constant") << "("
+			<< colorlog::Function("constant") << "("
-			<< output::Keyword("constant") << "("
+			<< colorlog::Keyword("constant") << "("
 			<< *constant
 			<< "))." << std::endl;
 
@@ -232,19 +233,19 @@ void TranslatorASP::translateConstants(const std::string &heading, const ::pddl:
 		if (type)
 		{
 			if (!type.value().is<::pddl::ast::PrimitiveTypePointer>())
-				throw output::TranslatorException("only primitive types supported currently");
+				throw TranslatorException("only primitive types supported currently");
 
 			const auto &primitveType = type.value().get<::pddl::ast::PrimitiveTypePointer>();
 
-			m_outputStream << output::Function("has") << "("
+			m_outputStream << colorlog::Function("has") << "("
-				<< output::Keyword("constant") << "(" << *constant << "), "
+				<< colorlog::Keyword("constant") << "(" << *constant << "), "
-				<< output::Keyword("type") << "(" << *primitveType << "))." << std::endl;
+				<< colorlog::Keyword("type") << "(" << *primitveType << "))." << std::endl;
 		}
 		else
 		{
-			m_outputStream << output::Function("has") << "("
+			m_outputStream << colorlog::Function("has") << "("
-				<< output::Keyword("constant") << "(" << *constant << "), "
+				<< colorlog::Keyword("constant") << "(" << *constant << "), "
-				<< output::Keyword("type") << "(" << output::String("object") << "))." << std::endl;
+				<< colorlog::Keyword("type") << "(" << colorlog::String("object") << "))." << std::endl;
 		}
 	}
 }
@@ -255,7 +256,7 @@ void TranslatorASP::translateProblem() const
 {
 	assert(m_description.problem);
 
-	m_outputStream << output::Heading1("problem");
+	m_outputStream << colorlog::Heading1("problem");
 
 	const auto &problem = m_description.problem.value();
 
@@ -284,13 +285,13 @@ void TranslatorASP::translateInitialState() const
 {
 	assert(m_description.problem);
 
-	m_outputStream << output::Heading2("initial state");
+	m_outputStream << colorlog::Heading2("initial state");
 
 	const auto &facts = m_description.problem.value()->initialState.facts;
 
 	for (const auto &fact : facts)
 	{
-		m_outputStream << std::endl << output::Function("initialState") << "(";
+		m_outputStream << std::endl << colorlog::Function("initialState") << "(";
 
 		// Translate single predicate
 		if (fact.is<::pddl::ast::AtomicFormula>() && fact.get<::pddl::ast::AtomicFormula>().is<::pddl::ast::PredicatePointer>())
@@ -305,28 +306,28 @@ void TranslatorASP::translateInitialState() const
 			const auto &notExpression = fact.get<::pddl::ast::NotPointer<::pddl::ast::Fact>>();
 
 			if (!notExpression->argument.is<::pddl::ast::AtomicFormula>() || !notExpression->argument.get<::pddl::ast::AtomicFormula>().is<::pddl::ast::PredicatePointer>())
-				throw output::TranslatorException("only negations of simple predicates supported in initial state currently");
+				throw TranslatorException("only negations of simple predicates supported in initial state currently");
 
 			const auto &predicate = notExpression->argument.get<::pddl::ast::AtomicFormula>().get<::pddl::ast::PredicatePointer>();
 
 			translatePredicateToVariable(m_outputStream, *predicate, false);
 		}
 		else
-			throw output::TranslatorException("only predicates and their negations supported in initial state currently");
+			throw TranslatorException("only predicates and their negations supported in initial state currently");
 
 		m_outputStream << ").";
 	}
 
 	m_outputStream
 		<< std::endl << std::endl
-		<< output::Function("initialState") << "("
+		<< colorlog::Function("initialState") << "("
-		<< output::Keyword("variable") << "(" << output::Variable("X") << "), "
+		<< colorlog::Keyword("variable") << "(" << colorlog::Variable("X") << "), "
-		<< output::Keyword("value") << "(" << output::Variable("X") << ", " << output::Boolean("false") << ")) :- "
+		<< colorlog::Keyword("value") << "(" << colorlog::Variable("X") << ", " << colorlog::Boolean("false") << ")) :- "
-		<< output::Function("variable") << "(" << output::Keyword("variable") << "(" << output::Variable("X") << ")), "
+		<< colorlog::Function("variable") << "(" << colorlog::Keyword("variable") << "(" << colorlog::Variable("X") << ")), "
-		<< output::Keyword("not") << " "
+		<< colorlog::Keyword("not") << " "
-		<< output::Function("initialState") << "("
+		<< colorlog::Function("initialState") << "("
-		<< output::Keyword("variable") << "(" << output::Variable("X") << "), "
+		<< colorlog::Keyword("variable") << "(" << colorlog::Variable("X") << "), "
-		<< output::Keyword("value") << "(" << output::Variable("X") << ", " << output::Boolean("true") << "))."
+		<< colorlog::Keyword("value") << "(" << colorlog::Variable("X") << ", " << colorlog::Boolean("true") << "))."
 		<< std::endl;
 }
 
@@ -337,7 +338,7 @@ void TranslatorASP::translateGoal() const
 	assert(m_description.problem);
 	assert(m_description.problem.value()->goal);
 
-	m_outputStream << output::Heading2("goal");
+	m_outputStream << colorlog::Heading2("goal");
 
 	const auto &goal = m_description.problem.value()->goal.value();
 	// TODO: refactor

src/plasp/sas/Debugging.cpp

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

src/plasp/sas/Description.cpp

@@ -5,10 +5,10 @@
 #include <fstream>
 #include <sstream>
 
-#include <plasp/sas/VariableTransition.h>
-
 #include <tokenize/TokenizerException.h>
 
+#include <plasp/sas/VariableTransition.h>
+
 namespace plasp
 {
 namespace sas

src/plasp/sas/Operator.cpp

@@ -3,7 +3,8 @@
 #include <iostream>
 #include <limits>
 
-#include <plasp/output/Formatting.h>
+#include <colorlog/Formatting.h>
+
 #include <plasp/sas/VariableTransition.h>
 
 namespace plasp
@@ -46,9 +47,9 @@ Operator Operator::fromSAS(tokenize::Tokenizer<> &tokenizer, const Variables &va
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Operator::printPredicateAsASP(output::ColorStream &stream) const
+void Operator::printPredicateAsASP(colorlog::ColorStream &stream) const
 {
-	stream << output::Keyword("action") << "(";
+	stream << colorlog::Keyword("action") << "(";
 	m_predicate.printAsASP(stream);
 	stream << ")";
 }

src/plasp/sas/Predicate.cpp

@@ -4,10 +4,10 @@
 #include <limits>
 #include <sstream>
 
-#include <plasp/output/Formatting.h>
-
 #include <tokenize/TokenizerException.h>
 
+#include <colorlog/Formatting.h>
+
 namespace plasp
 {
 namespace sas
@@ -66,7 +66,7 @@ const Predicate::Arguments &Predicate::arguments() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Predicate::printAsSAS(output::ColorStream &stream) const
+void Predicate::printAsSAS(colorlog::ColorStream &stream) const
 {
 	if (m_arguments.empty())
 	{
@@ -84,18 +84,18 @@ void Predicate::printAsSAS(output::ColorStream &stream) const
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Predicate::printAsASP(output::ColorStream &stream) const
+void Predicate::printAsASP(colorlog::ColorStream &stream) const
 {
 	if (m_arguments.empty())
 	{
-		stream << output::String(m_name.c_str());
+		stream << colorlog::String(m_name.c_str());
 		return;
 	}
 
-	stream << "(" << output::String(m_name.c_str());
+	stream << "(" << colorlog::String(m_name.c_str());
 
 	for (size_t i = 0; i < m_arguments.size(); i++)
-		stream << ", " << output::String(m_arguments[i].c_str());
+		stream << ", " << colorlog::String(m_arguments[i].c_str());
 
 	stream << ")";
 }

src/plasp/sas/TranslatorASP.cpp

@@ -2,7 +2,7 @@
 
 #include <boost/assert.hpp>
 
-#include <plasp/output/Formatting.h>
+#include <colorlog/Formatting.h>
 
 namespace plasp
 {
@@ -15,7 +15,7 @@ namespace sas
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-TranslatorASP::TranslatorASP(const Description &description, output::ColorStream &outputStream)
+TranslatorASP::TranslatorASP(const Description &description, colorlog::ColorStream &outputStream)
 :	m_description(description),
 	m_outputStream(outputStream)
 {
@@ -58,30 +58,30 @@ void TranslatorASP::translate() const
 
 void TranslatorASP::translateRequirements() const
 {
-	m_outputStream << output::Heading2("feature requirements") << std::endl;
+	m_outputStream << colorlog::Heading2("feature requirements") << std::endl;
 
 	if (m_description.usesActionCosts())
-		m_outputStream << output::Function("requires") << "(" << output::Keyword("feature") << "(" << output::Reserved("actionCosts") << "))." << std::endl;
+		m_outputStream << colorlog::Function("requires") << "(" << colorlog::Keyword("feature") << "(" << colorlog::Reserved("actionCosts") << "))." << std::endl;
 
 	if (m_description.usesAxiomRules())
-		m_outputStream << output::Function("requires") << "(" << output::Keyword("feature") << "(" << output::Reserved("axiomRules") << "))." << std::endl;
+		m_outputStream << colorlog::Function("requires") << "(" << colorlog::Keyword("feature") << "(" << colorlog::Reserved("axiomRules") << "))." << std::endl;
 
 	if (m_description.usesConditionalEffects())
-		m_outputStream << output::Function("requires") << "(" << output::Keyword("feature") << "(" << output::Reserved("conditionalEffects") << "))." << std::endl;
+		m_outputStream << colorlog::Function("requires") << "(" << colorlog::Keyword("feature") << "(" << colorlog::Reserved("conditionalEffects") << "))." << std::endl;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void TranslatorASP::translateInitialState() const
 {
-	m_outputStream << output::Heading2("initial state") << std::endl;
+	m_outputStream << colorlog::Heading2("initial state") << std::endl;
 
 	const auto &initialStateFacts = m_description.initialState().facts();
 
 	std::for_each(initialStateFacts.cbegin(), initialStateFacts.cend(),
 		[&](const auto &fact)
 		{
-			m_outputStream << output::Function("initialState") << "(";
+			m_outputStream << colorlog::Function("initialState") << "(";
 			fact.variable().printNameAsASPPredicate(m_outputStream);
 			m_outputStream << ", ";
 			fact.value().printAsASPPredicate(m_outputStream);
@@ -93,14 +93,14 @@ void TranslatorASP::translateInitialState() const
 
 void TranslatorASP::translateGoal() const
 {
-	m_outputStream << output::Heading2("goal") << std::endl;
+	m_outputStream << colorlog::Heading2("goal") << std::endl;
 
 	const auto &goalFacts = m_description.goal().facts();
 
 	std::for_each(goalFacts.cbegin(), goalFacts.cend(),
 		[&](const auto &fact)
 		{
-			m_outputStream << output::Function("goal") << "(";
+			m_outputStream << colorlog::Function("goal") << "(";
 			fact.variable().printNameAsASPPredicate(m_outputStream);
 			m_outputStream << ", ";
 			fact.value().printAsASPPredicate(m_outputStream);
@@ -112,7 +112,7 @@ void TranslatorASP::translateGoal() const
 
 void TranslatorASP::translateVariables() const
 {
-	m_outputStream << output::Heading2("variables");
+	m_outputStream << colorlog::Heading2("variables");
 
 	const auto &variables = m_description.variables();
 
@@ -123,14 +123,14 @@ void TranslatorASP::translateVariables() const
 
 			BOOST_ASSERT(!values.empty());
 
-			m_outputStream << std::endl << output::Function("variable") << "(";
+			m_outputStream << std::endl << colorlog::Function("variable") << "(";
 			variable.printNameAsASPPredicate(m_outputStream);
 			m_outputStream << ")." << std::endl;
 
 			std::for_each(values.cbegin(), values.cend(),
 				[&](const auto &value)
 				{
-					m_outputStream << output::Function("contains") << "(";
+					m_outputStream << colorlog::Function("contains") << "(";
 					variable.printNameAsASPPredicate(m_outputStream);
 					m_outputStream << ", ";
 					value.printAsASPPredicate(m_outputStream);
@@ -143,7 +143,7 @@ void TranslatorASP::translateVariables() const
 
 void TranslatorASP::translateActions() const
 {
-	m_outputStream << output::Heading2("actions");
+	m_outputStream << colorlog::Heading2("actions");
 
 	const auto &operators = m_description.operators();
 
@@ -152,7 +152,7 @@ void TranslatorASP::translateActions() const
 	std::for_each(operators.cbegin(), operators.cend(),
 		[&](const auto &operator_)
 		{
-			m_outputStream << std::endl << output::Function("action") << "(";
+			m_outputStream << std::endl << colorlog::Function("action") << "(";
 			operator_.printPredicateAsASP(m_outputStream);
 			m_outputStream << ")." << std::endl;
 
@@ -161,7 +161,7 @@ void TranslatorASP::translateActions() const
 			std::for_each(preconditions.cbegin(), preconditions.cend(),
 				[&](const auto &precondition)
 				{
-					m_outputStream << output::Function("precondition") << "(";
+					m_outputStream << colorlog::Function("precondition") << "(";
 					operator_.printPredicateAsASP(m_outputStream);
 					m_outputStream << ", ";
 					precondition.variable().printNameAsASPPredicate(m_outputStream);
@@ -177,13 +177,13 @@ void TranslatorASP::translateActions() const
 				{
 					const auto &conditions = effect.conditions();
 
-					m_outputStream << output::Function("postcondition") << "(";
+					m_outputStream << colorlog::Function("postcondition") << "(";
 					operator_.printPredicateAsASP(m_outputStream);
 
 					if (conditions.empty())
-						m_outputStream << ", " << output::Keyword("effect") << "(" << output::Reserved("unconditional") << "), ";
+						m_outputStream << ", " << colorlog::Keyword("effect") << "(" << colorlog::Reserved("unconditional") << "), ";
 					else
-						m_outputStream << ", " << output::Keyword("effect") << "(" << output::Number<decltype(currentEffectID)>(currentEffectID) << "), ";
+						m_outputStream << ", " << colorlog::Keyword("effect") << "(" << colorlog::Number<decltype(currentEffectID)>(currentEffectID) << "), ";
 
 					effect.postcondition().variable().printNameAsASPPredicate(m_outputStream);
 					m_outputStream << ", ";
@@ -195,8 +195,8 @@ void TranslatorASP::translateActions() const
 						{
 							// Conditions of conditional effects
 							m_outputStream
-								<< output::Function("precondition") << "("
+								<< colorlog::Function("precondition") << "("
-								<< output::Keyword("effect") << "(" << output::Number<decltype(currentEffectID)>(currentEffectID) << "), ";
+								<< colorlog::Keyword("effect") << "(" << colorlog::Number<decltype(currentEffectID)>(currentEffectID) << "), ";
 							condition.variable().printNameAsASPPredicate(m_outputStream);
 							m_outputStream << ", ";
 							condition.value().printAsASPPredicate(m_outputStream);
@@ -207,9 +207,9 @@ void TranslatorASP::translateActions() const
 						currentEffectID++;
 				});
 
-			m_outputStream << output::Function("costs") << "(";
+			m_outputStream << colorlog::Function("costs") << "(";
 			operator_.printPredicateAsASP(m_outputStream);
-			m_outputStream << ", " << output::Number<decltype(operator_.costs())>(operator_.costs()) << ")." << std::endl;
+			m_outputStream << ", " << colorlog::Number<decltype(operator_.costs())>(operator_.costs()) << ")." << std::endl;
 		});
 }
 
@@ -217,7 +217,7 @@ void TranslatorASP::translateActions() const
 
 void TranslatorASP::translateMutexes() const
 {
-	m_outputStream << output::Heading2("mutex groups");
+	m_outputStream << colorlog::Heading2("mutex groups");
 
 	const auto &mutexGroups = m_description.mutexGroups();
 
@@ -231,9 +231,9 @@ void TranslatorASP::translateMutexes() const
 
 			m_outputStream
 				<< std::endl
-				<< output::Function("mutexGroup") << "("
+				<< colorlog::Function("mutexGroup") << "("
-				<< output::Keyword("mutexGroup") << "("
+				<< colorlog::Keyword("mutexGroup") << "("
-				<< output::Number<decltype(mutexGroupID)>(mutexGroupID)
+				<< colorlog::Number<decltype(mutexGroupID)>(mutexGroupID)
 				<< "))." << std::endl;
 
 			const auto &facts = mutexGroup.facts();
@@ -241,7 +241,7 @@ void TranslatorASP::translateMutexes() const
 			std::for_each(facts.cbegin(), facts.cend(),
 				[&](const auto &fact)
 				{
-					m_outputStream << output::Function("contains") << "(" << output::Keyword("mutexGroup") << "(" << output::Number<decltype(mutexGroupID)>(mutexGroupID) << "), ";
+					m_outputStream << colorlog::Function("contains") << "(" << colorlog::Keyword("mutexGroup") << "(" << colorlog::Number<decltype(mutexGroupID)>(mutexGroupID) << "), ";
 					fact.variable().printNameAsASPPredicate(m_outputStream);
 					m_outputStream << ", ";
 					fact.value().printAsASPPredicate(m_outputStream);
@@ -254,7 +254,7 @@ void TranslatorASP::translateMutexes() const
 
 void TranslatorASP::translateAxiomRules() const
 {
-	m_outputStream << output::Heading2("axiom rules");
+	m_outputStream << colorlog::Heading2("axiom rules");
 
 	const auto &axiomRules = m_description.axiomRules();
 
@@ -268,9 +268,9 @@ void TranslatorASP::translateAxiomRules() const
 
 			m_outputStream
 				<< std::endl
-				<< output::Function("axiomRule") << "("
+				<< colorlog::Function("axiomRule") << "("
-				<< output::Keyword("axiomRule") << "("
+				<< colorlog::Keyword("axiomRule") << "("
-				<< output::Number<decltype(axiomRuleID)>(axiomRuleID)
+				<< colorlog::Number<decltype(axiomRuleID)>(axiomRuleID)
 				<< "))." << std::endl;
 
 			// TODO: Translate axiom rule layer
@@ -281,8 +281,8 @@ void TranslatorASP::translateAxiomRules() const
 				[&](const auto &condition)
 				{
 					m_outputStream
-						<< output::Function("precondition") << "("
+						<< colorlog::Function("precondition") << "("
-						<< output::Keyword("axiomRule") << "(" << output::Number<decltype(axiomRuleID)>(axiomRuleID) << "), ";
+						<< colorlog::Keyword("axiomRule") << "(" << colorlog::Number<decltype(axiomRuleID)>(axiomRuleID) << "), ";
 					condition.variable().printNameAsASPPredicate(m_outputStream);
 					m_outputStream << ", ";
 					condition.value().printAsASPPredicate(m_outputStream);
@@ -292,9 +292,9 @@ void TranslatorASP::translateAxiomRules() const
 			const auto &postcondition = axiomRule.postcondition();
 
 			m_outputStream
-				<< output::Function("postcondition") << "("
+				<< colorlog::Function("postcondition") << "("
-				<< output::Keyword("axiomRule") << "(" << output::Number<decltype(axiomRuleID)>(axiomRuleID) << "), "
+				<< colorlog::Keyword("axiomRule") << "(" << colorlog::Number<decltype(axiomRuleID)>(axiomRuleID) << "), "
-				<< output::Keyword("effect") << "(" << output::Reserved("unconditional") << "), ";
+				<< colorlog::Keyword("effect") << "(" << colorlog::Reserved("unconditional") << "), ";
 			postcondition.variable().printNameAsASPPredicate(m_outputStream);
 			m_outputStream << ", ";
 			postcondition.value().printAsASPPredicate(m_outputStream);

src/plasp/sas/Value.cpp

@@ -2,11 +2,12 @@
 
 #include <iostream>
 
-#include <plasp/output/Formatting.h>
-#include <plasp/sas/Variable.h>
-
 #include <tokenize/TokenizerException.h>
 
+#include <colorlog/Formatting.h>
+
+#include <plasp/sas/Variable.h>
+
 namespace plasp
 {
 namespace sas
@@ -128,22 +129,22 @@ const std::string &Value::name() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Value::printAsASPPredicate(output::ColorStream &stream) const
+void Value::printAsASPPredicate(colorlog::ColorStream &stream) const
 {
 	// TODO: do not compare by value
 	if (*this == Value::None)
 	{
-		stream << output::Keyword("value") << "(" << output::Reserved("none") << ")";
+		stream << colorlog::Keyword("value") << "(" << colorlog::Reserved("none") << ")";
 		return;
 	}
 
-	stream << output::Keyword("value") << "(" << output::String(m_name.c_str()) << ", "
+	stream << colorlog::Keyword("value") << "(" << colorlog::String(m_name.c_str()) << ", "
-		<< (m_sign == Sign::Positive ? output::Boolean("true") : output::Boolean("false")) << ")";
+		<< (m_sign == Sign::Positive ? colorlog::Boolean("true") : colorlog::Boolean("false")) << ")";
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Value::printAsSAS(output::ColorStream &stream) const
+void Value::printAsSAS(colorlog::ColorStream &stream) const
 {
 	if (m_sign == Value::Sign::Positive)
 		stream << "Atom ";

src/plasp/sas/Variable.cpp

@@ -2,10 +2,10 @@
 
 #include <iostream>
 
-#include <plasp/output/Formatting.h>
-
 #include <tokenize/TokenizerException.h>
 
+#include <colorlog/Formatting.h>
+
 namespace plasp
 {
 namespace sas
@@ -53,10 +53,10 @@ Variable Variable::fromSAS(tokenize::Tokenizer<> &tokenizer)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Variable::printNameAsASPPredicate(output::ColorStream &stream) const
+void Variable::printNameAsASPPredicate(colorlog::ColorStream &stream) const
 {
 	// TODO: assert that name is a number indeed
-	stream << output::Keyword("variable") << "(" << output::Number<std::string>(m_name) << ")";
+	stream << colorlog::Keyword("variable") << "(" << colorlog::Number<std::string>(m_name) << ")";
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

tests/CMakeLists.txt

@@ -7,6 +7,7 @@ set(includes
 	${PROJECT_SOURCE_DIR}/include
 	${PROJECT_SOURCE_DIR}/lib/catch/single_include
 	${PROJECT_SOURCE_DIR}/lib/tokenize/include
+	${PROJECT_SOURCE_DIR}/lib/colorlog/include
 	${PROJECT_SOURCE_DIR}/lib/variant/include
 	${PROJECT_SOURCE_DIR}/lib/pddlparse/include
 )

tests/TestPDDLTranslation.cpp

@@ -3,10 +3,11 @@
 #include <boost/iostreams/stream.hpp>
 #include <boost/iostreams/device/null.hpp>
 
+#include <colorlog/Logger.h>
+
 #include <pddlparse/AST.h>
 #include <pddlparse/Parse.h>
 
-#include <plasp/output/Logger.h>
 #include <plasp/pddl/TranslatorASP.h>
 
 boost::iostreams::stream<boost::iostreams::null_sink> nullStream((boost::iostreams::null_sink()));
@@ -17,7 +18,7 @@ const pddl::Context::WarningCallback ignoreWarnings = [](const auto &, const aut
 TEST_CASE("[PDDL translation] Former issues are fixed", "[PDDL translation]")
 {
 	// TODO: refactor
-	plasp::output::Logger logger(nullStream, nullStream);
+	colorlog::Logger logger(nullStream, nullStream);
 	pddl::Tokenizer tokenizer;
 	pddl::Context context(std::move(tokenizer), ignoreWarnings);