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

Showing list of available commands in help message.

Browse Source
This commit is contained in:
Patrick Lühne
2017-10-14 01:20:26 +02:00
parent d20b30d34d
commit 0d5245b48b
12 changed files with 216 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
app/src/plasp-app/OptionGroups.cpp
View File

@@ -83,6 +83,7 @@ void OptionGroupParser::addTo(cxxopts::Options &options)
("parsing-mode", "Parsing mode (strict, compatibility)", cxxopts::value<std::string>()->default_value("strict"))
("l,language", "Input language (pddl, sas, auto)", cxxopts::value<std::string>()->default_value("auto"));
options.parse_positional("input");
options.positional_help("[<input_file...>]");
}
////////////////////////////////////////////////////////////////////////////////////////////////////

79
app/src/plasp-app/commands/CommandHelp.cpp Normal file
View File

@@ -0,0 +1,79 @@
#include <plasp-app/commands/CommandHelp.h>
#include <colorlog/Logger.h>
#include <plasp-app/CommandType.h>
////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Command Help
//
////////////////////////////////////////////////////////////////////////////////////////////////////
int CommandHelp::run(int argc, char **argv)
{
colorlog::Logger logger;
if (argc > 1)
{
try
{
switch (parseCommandType(argv[1]))
{
case CommandType::Help:
case CommandType::Version:
break;
case CommandType::Normalize:
CommandNormalize().printHelp();
return EXIT_SUCCESS;
case CommandType::Translate:
CommandTranslate().printHelp();
return EXIT_SUCCESS;
default:
logger.log(colorlog::Priority::Error, std::string("command “") + argv[1] + "” not yet implemented");
exit(EXIT_FAILURE);
}
}
catch (std::exception &exception)
{
}
}
std::cout
<< "ASP planning tools for PDDL." << std::endl
<< "Usage:" << std::endl
<< " plasp <command> [<arguments>]" << std::endl << std::endl
<< " available commands:" << std::endl;
AvailableCommands availableCommands;
size_t lengthOfLongestCommandName = 0;
forEach(availableCommands,
[&](const auto &command)
{
lengthOfLongestCommandName = std::max(lengthOfLongestCommandName, std::strlen(command.Name));
});
const auto printSpaces =
[](const auto numberOfSpaces)
{
for (auto i = static_cast<decltype(numberOfSpaces)>(0); i < numberOfSpaces; i++)
std::cout << " ";
};
forEach(availableCommands,
[&](const auto &command)
{
const auto lengthOfCommandName = std::strlen(command.Name);
std::cout << " " << command.Name;
printSpaces(lengthOfLongestCommandName - lengthOfCommandName + 2);
std::cout << command.Description << std::endl;
});
return EXIT_SUCCESS;
}

7
app/src/plasp-app/commands/CommandNormalize.cpp
View File

@@ -27,13 +27,6 @@
//
////////////////////////////////////////////////////////////////////////////////////////////////////
CommandNormalize::CommandNormalize()
: Command(cxxopts::Options("plasp normalize", "Normalize PDDL to plasp’s custom PDDL format."))
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
int CommandNormalize::run(int argc, char **argv)
{
parseOptions(argc, argv);

7
app/src/plasp-app/commands/CommandTranslate.cpp
View File

@@ -30,13 +30,6 @@
//
////////////////////////////////////////////////////////////////////////////////////////////////////
CommandTranslate::CommandTranslate()
: Command(cxxopts::Options("plasp translate", "Translate PDDL to ASP."))
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
int CommandTranslate::run(int argc, char **argv)
{
parseOptions(argc, argv);

7
app/src/plasp-app/commands/CommandVersion.cpp
View File

@@ -6,13 +6,6 @@
//
////////////////////////////////////////////////////////////////////////////////////////////////////
CommandVersion::CommandVersion()
: Command(cxxopts::Options("plasp version", "Display version information."))
{
}
////////////////////////////////////////////////////////////////////////////////////////////////////
int CommandVersion::run(int, char **)
{
printVersion();

72
app/src/plasp-app/main.cpp
View File

@@ -8,10 +8,8 @@
#include <colorlog/Priority.h>
#include <plasp-app/Command.h>
#include <plasp-app/CommandType.h>
#include <plasp-app/Version.h>
#include <plasp-app/commands/CommandNormalize.h>
#include <plasp-app/commands/CommandTranslate.h>
#include <plasp-app/commands/CommandVersion.h>
////////////////////////////////////////////////////////////////////////////////////////////////////
//
@@ -19,65 +17,14 @@
//
////////////////////////////////////////////////////////////////////////////////////////////////////
enum class CommandType
{
Help,
Version,
CheckSyntax,
Requirements,
PrettyPrint,
Normalize,
Translate
};
////////////////////////////////////////////////////////////////////////////////////////////////////
static const std::map<std::string, CommandType> commandNames =
{
{"help", CommandType::Help},
{"-h", CommandType::Help},
{"--help", CommandType::Help},
{"version", CommandType::Version},
{"-v", CommandType::Version},
{"--version", CommandType::Version},
{"check-syntax", CommandType::CheckSyntax},
{"requirements", CommandType::Requirements},
{"pretty-print", CommandType::PrettyPrint},
{"normalize", CommandType::Normalize},
{"translate", CommandType::Translate},
};
////////////////////////////////////////////////////////////////////////////////////////////////////
const auto parseCommandType =
[](const std::string &commandString)
{
const auto matchingCommand = commandNames.find(commandString);
if (matchingCommand == commandNames.cend())
throw std::runtime_error(std::string("“") + commandString + "” is not a plasp command");
return matchingCommand->second;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
const auto printHelp =
[&]()
{
// TODO: add list of available commands
std::cout
<< "ASP planning tools for PDDL." << std::endl
<< "Usage: plasp <command> [<arguments>]" << std::endl;
};
colorlog::Logger logger;
if (argc < 2)
{
printHelp();
CommandHelp().run(argc - 1, &argv[1]);
return EXIT_FAILURE;
}
@@ -86,16 +33,19 @@ int main(int argc, char **argv)
switch (parseCommandType(argv[1]))
{
case CommandType::Help:
printHelp();
return EXIT_SUCCESS;
return CommandHelp().run(argc - 1, &argv[1]);
case CommandType::Version:
return CommandVersion().run(argc - 1, &argv[1]);
return EXIT_SUCCESS;
case CommandType::Normalize:
return CommandNormalize().run(argc - 1, &argv[1]);
case CommandType::Translate:
return CommandTranslate().run(argc - 1, &argv[1]);
default:
logger.log(colorlog::Priority::Error, std::string("command “") + argv[1] + "” not yet implemented");
exit(EXIT_FAILURE);
}
}
@@ -103,7 +53,9 @@ int main(int argc, char **argv)
{
logger.log(colorlog::Priority::Error, exception.what());
std::cout << std::endl;
printHelp();
CommandHelp().run(argc - 1, &argv[1]);
return EXIT_FAILURE;
}