2023-11-30 20:36:11 +00:00
|
|
|
#include "flags.h"
|
|
|
|
#include <sstream>
|
2023-12-01 02:32:03 +00:00
|
|
|
#include <iostream>
|
2023-11-30 20:36:11 +00:00
|
|
|
|
|
|
|
namespace Flags {
|
|
|
|
|
|
|
|
std::vector<std::string> split(const std::string &input, const char separator) {
|
|
|
|
std::vector<std::string> result;
|
|
|
|
std::istringstream stream(input);
|
|
|
|
std::string part;
|
|
|
|
while (std::getline(stream, part, separator))
|
|
|
|
result.push_back(part);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool starts_with(const std::string &input, const std::string &start) {
|
2023-12-01 02:32:03 +00:00
|
|
|
return (input.size() >= start.size() && input.substr(0, 2) == start);
|
|
|
|
}
|
|
|
|
|
|
|
|
PARSER(StringFlag, std::string, {
|
|
|
|
set_found(true);
|
|
|
|
set_parsed(true);
|
|
|
|
value = arg;
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(IntFlag, int, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = std::stoi(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(LongIntFlag, long int, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = std::stol(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(LongLongIntFlag, long long int, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = std::stoll(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(UnsignedLongIntFlag, unsigned long int, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = std::stoul(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(UnsignedLongLongIntFlag, unsigned long long int, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = std::stoull(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(FloatFlag, float, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = std::stof(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(DoubleFlag, double, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = stod(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(LongDoubleFlag, long double, {
|
|
|
|
set_found(true);
|
|
|
|
try {
|
|
|
|
value = stold(arg);
|
|
|
|
set_parsed(true);
|
|
|
|
} catch (std::exception &) {
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
PARSER(BoolFlag, bool, {
|
|
|
|
std::string copy(arg);
|
|
|
|
std::transform(copy.begin(), copy.end(), copy.begin(),
|
|
|
|
[](const char c) { return std::tolower(c); });
|
|
|
|
if (copy == "false")
|
|
|
|
value = false;
|
|
|
|
else
|
|
|
|
value = true;
|
|
|
|
})
|
|
|
|
|
|
|
|
Parser::Parser(const std::string &prefix, const std::string &help_text)
|
|
|
|
: prefix(prefix), help_text(help_text) {
|
|
|
|
set_parser<std::string>(flag_constructor_t(StringFlag::make));
|
|
|
|
set_parser<int>(flag_constructor_t(IntFlag::make));
|
|
|
|
set_parser<long int>(flag_constructor_t(LongIntFlag::make));
|
|
|
|
set_parser<long long int>(flag_constructor_t(LongLongIntFlag::make));
|
|
|
|
set_parser<unsigned long int>(flag_constructor_t(UnsignedLongIntFlag::make));
|
|
|
|
set_parser<unsigned long long int>(
|
|
|
|
flag_constructor_t(UnsignedLongLongIntFlag::make));
|
|
|
|
set_parser<float>(flag_constructor_t(FloatFlag::make));
|
|
|
|
set_parser<double>(flag_constructor_t(DoubleFlag::make));
|
|
|
|
set_parser<long double>(flag_constructor_t(LongDoubleFlag::make));
|
|
|
|
set_parser<bool>(flag_constructor_t(BoolFlag::make));
|
2023-11-30 20:36:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Parser::parse(int argc, char **argv) {
|
|
|
|
// put each argument into a std::string
|
|
|
|
std::vector<std::string> args;
|
|
|
|
for (int i = 0; i < argc; i++) {
|
|
|
|
std::string arg(argv[i]);
|
2023-12-01 02:32:03 +00:00
|
|
|
if (starts_with(arg, prefix) && arg.size() > prefix.size()) {
|
2023-11-30 20:36:11 +00:00
|
|
|
std::vector<std::string> parts = split(arg, '=');
|
|
|
|
args.insert(args.end(), parts.begin(), parts.end());
|
|
|
|
} else {
|
|
|
|
args.push_back(arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// search for flags
|
|
|
|
for (size_t i = 1; i < args.size() - 1; i++) {
|
|
|
|
const std::string &arg = args[i];
|
2023-12-01 02:32:03 +00:00
|
|
|
if (starts_with(arg, prefix) && arg.size() > prefix.size()) {
|
|
|
|
flags[arg.substr(prefix.size())]->parse(args[i + 1]);
|
2023-11-30 20:36:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// check for the last argument
|
|
|
|
if (starts_with(args[args.size() - 1], prefix) &&
|
2023-12-01 02:32:03 +00:00
|
|
|
args[args.size() - 1].size() > prefix.size()) {
|
|
|
|
flags[args[args.size() - 1].substr(prefix.size())]->parse("");
|
2023-11-30 20:36:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return get_found() == flags.size();
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:32:03 +00:00
|
|
|
unsigned Parser::get_parsed() const {
|
2023-11-30 20:36:11 +00:00
|
|
|
return std::count_if(
|
|
|
|
flags.begin(), flags.end(),
|
|
|
|
[](std::pair<std::string, Flag *> f) { return f.second->get_parsed(); });
|
|
|
|
}
|
|
|
|
|
2023-12-01 02:32:03 +00:00
|
|
|
unsigned Parser::get_found() const {
|
2023-11-30 20:36:11 +00:00
|
|
|
return std::count_if(
|
|
|
|
flags.begin(), flags.end(),
|
|
|
|
[](std::pair<std::string, Flag *> f) { return f.second->get_found(); });
|
|
|
|
}
|
|
|
|
|
|
|
|
void Parser::help() const {
|
|
|
|
std::cout << help_text << std::endl;
|
|
|
|
|
|
|
|
for (auto f : flags) {
|
|
|
|
std::cout << '\t' << prefix << f.first << ": "
|
|
|
|
<< f.second->get_description() << std::endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace Flags
|