command.h

Go to the documentation of this file.

#ifndef KOUTIL_ARGS_COMMAND_H
#define KOUTIL_ARGS_COMMAND_H
 
#include "koutil/args/argument.h"
#include "koutil/args/handle.h"
#include "koutil/args/option.h"
#include "koutil/args/result.h"
#include <cstddef>
#include <cstdint>
#include <functional>
#include <ostream>
#include <span>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace koutil::args {
 
template <extends_result Result = result_base_t> class command_t {
public:
    using result_t   = Result;
    using option_t   = option_t<result_t>;
    using argument_t = argument_t<result_t>;
    using handle_t = std::function<void(std::span<const char* const>, result_t&)>;
 
    template <void_handle<std::span<const char* const>, result_t&> Handle>
    explicit command_t(std::string_view name, std::string_view description, Handle&& handle)
        : m_name(name)
        , m_description(description)
        , m_handle(std::forward<Handle>(handle)) { }
 
    explicit command_t(std::string_view name, std::string_view description)
        : m_name(name)
        , m_description(description)
        , m_handle(nullptr) { }
 
    [[nodiscard]] std::string_view name() const { return m_name; }
 
    [[nodiscard]] std::string_view description() const { return m_description; }
 
    [[nodiscard]] const auto& arguments() const { return m_arguments; }
 
    [[nodiscard]] const auto& options() const { return m_options; }
 
    [[nodiscard]] const auto& commands() const { return m_commands; }
 
    const std::string& path() const { return m_path; }
 
    bool add_command(command_t&& command);
 
    bool add_option(const option_t& option);
 
    void add_argument(const argument_t& argument);
 
    void process(const char* const* args, std::uint32_t argc, result_t& result);
 
    void process(std::span<const char* const> args, result_t& result);
 
    void show_help(std::ostream& out, std::size_t terminal_size = 80) const;
 
    void clear_used();
 
private:
    std::uint32_t
    process_option(std::string_view name, std::span<const char* const> args, std::uint32_t index, result_t& result);
 
    void check_options(result_t& result);
 
    struct string_hash {
        using is_transparent = void;
 
        [[nodiscard]] std::size_t operator()(std::string_view s) const { return std::hash<std::string_view>()(s); }
 
        [[nodiscard]] std::size_t operator()(const std::string& s) const { return std::hash<std::string>()(s); }
    };
 
    std::string m_path;
 
    std::string_view m_name;
    std::string_view m_description;
    handle_t m_handle;
 
    std::vector<argument_t> m_arguments;
    std::vector<option_t> m_options;
    std::vector<command_t> m_commands;
    std::unordered_map<std::string_view, std::uint32_t, string_hash> m_cmd_map;
 
    std::unordered_map<std::string_view, std::uint32_t, string_hash> m_long_options;
    std::unordered_map<char, std::uint32_t> m_short_options;
};
 
}
 
#endif