108 lines
2.9 KiB
C++
108 lines
2.9 KiB
C++
#pragma once
|
|
|
|
#include <optional>
|
|
#include <print>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
class ArgParser {
|
|
public:
|
|
void add(const std::string& shortOpt, const std::string& longOpt, const std::string& description, bool requiresValue = true) {
|
|
Argument arg{shortOpt, longOpt, description, std::nullopt, requiresValue, false};
|
|
m_arguments.push_back(arg);
|
|
if (!shortOpt.empty())
|
|
m_optMap[shortOpt] = &m_arguments.back();
|
|
if (!longOpt.empty())
|
|
m_optMap[longOpt] = &m_arguments.back();
|
|
}
|
|
|
|
bool parse(int argc, char* argv[]) {
|
|
if (argc == 1) {
|
|
printHelp();
|
|
return false;
|
|
}
|
|
|
|
for (int i = 1; i < argc; ++i) {
|
|
std::string arg = argv[i];
|
|
|
|
if (arg == "-h" || arg == "--help") {
|
|
printHelp();
|
|
return false;
|
|
}
|
|
|
|
if (auto* argument = findArgument(arg); argument) {
|
|
argument->exists = true;
|
|
if (argument->requiresValue) {
|
|
if (i + 1 >= argc)
|
|
throw std::invalid_argument("Missing value for " + arg);
|
|
argument->value = argv[++i];
|
|
}
|
|
} else {
|
|
throw std::invalid_argument("Unknown option: " + arg);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename T>
|
|
T get(const std::string& arg) const {
|
|
const Argument* argument = findArgument(arg);
|
|
if (!argument || !argument->value)
|
|
throw std::runtime_error(arg + " has no value");
|
|
|
|
return convertToType<T>(*argument->value);
|
|
}
|
|
|
|
bool has(const std::string& arg) const {
|
|
const Argument* argument = findArgument(arg);
|
|
return argument && argument->exists;
|
|
}
|
|
|
|
void printHelp() const {
|
|
std::println("Usage: [options]");
|
|
for (const auto& arg : m_arguments) {
|
|
std::println(" {}, {}: {}", arg.shortOpt, arg.longOpt, arg.description);
|
|
}
|
|
}
|
|
|
|
private:
|
|
struct Argument {
|
|
std::string shortOpt;
|
|
std::string longOpt;
|
|
std::string description;
|
|
std::optional<std::string> value;
|
|
bool requiresValue;
|
|
bool exists = false;
|
|
};
|
|
|
|
Argument* findArgument(const std::string& opt) {
|
|
if (auto it = m_optMap.find(opt); it != m_optMap.end())
|
|
return it->second;
|
|
return nullptr;
|
|
}
|
|
|
|
const Argument* findArgument(const std::string& opt) const {
|
|
if (auto it = m_optMap.find(opt); it != m_optMap.end())
|
|
return it->second;
|
|
return nullptr;
|
|
}
|
|
|
|
template <typename T>
|
|
T convertToType(const std::string& value) const {
|
|
if constexpr (std::is_same_v<T, std::string>) {
|
|
return value;
|
|
} else if constexpr (std::is_same_v<T, int>) {
|
|
return std::stoi(value);
|
|
} else if constexpr (std::is_same_v<T, double>) {
|
|
return std::stod(value);
|
|
} else {
|
|
throw std::runtime_error("Unsupported type for argument conversion");
|
|
}
|
|
}
|
|
|
|
std::vector<Argument> m_arguments;
|
|
std::unordered_map<std::string, Argument*> m_optMap;
|
|
};
|