parser_options.hpp

Go to the documentation of this file.

#pragma once
#include <optional>
#include <string>
#include <map>
#include <vector>
#include <getopt.h>
 
#include <arkanjo/cli/cli_error.hpp>
 
enum ArgumentsType {
    NoArgument,
    RequiredArgument,
    OptionalArgument,
    PositionalArgument,
};
 
struct CliOption {
    const char *long_name;
    char short_name;
    ArgumentsType has_arg;
    const char *description {""};
};
 
#define OPTION_END {nullptr, 0, NoArgument, nullptr}
 
struct ParsedOptions {
    std::map<std::string, std::string> args;
 
    std::vector<std::string> extra_args;
 
    bool has(const std::string& name) const {
        return args.find(name) != args.end();
    }
 
    std::optional<std::string_view> get(const std::string& name) const {
        auto it = args.find(name);
 
        if (it == args.end())
            return std::nullopt;
 
        return it->second;
    }
 
    template<typename T> std::optional<T> get_as(const std::string& name) const {
        auto value = get(name);
 
        if (!value)
            return std::nullopt;
 
        if constexpr (std::is_same_v<T, std::string>) {
            return std::string(*value);
        } else if constexpr (std::is_same_v<T, int>) {
            return std::stoi(std::string(*value));
        } else if constexpr (std::is_same_v<T, size_t>) {
            return static_cast<size_t>(std::stoull(std::string(*value)));
        } else if constexpr (std::is_same_v<T, double>) {
            return std::stod(std::string(*value));
        } else if constexpr (std::is_same_v<T, bool>) {
            return *value == "true";
        } else {
            static_assert(!sizeof(T), "Unsupported type");
        }
    }
};
 
bool parse_options(int argc, char* argv[], const std::vector<CliOption>& options, ParsedOptions& ctx_options);