subcommand.h

Go to the documentation of this file.

#ifndef KOUTIL_ARGPARSER_SUBCOMMAND_H
#define KOUTIL_ARGPARSER_SUBCOMMAND_H
 
#include "koutil/argparser/arg.h"
#include "koutil/type/types.h"
#include <cassert>
#include <concepts>
#include <cstddef>
#include <string_view>
#include <tuple>
#include <type_traits>
 
namespace koutil::argparser {
 
class CommandsBase;
 
struct SubcommandBase {
    std::string_view name;
 
    constexpr SubcommandBase(std::string_view cmd_name)
        : name(cmd_name) { }
 
    constexpr virtual ~SubcommandBase() = default;
 
    [[nodiscard]] constexpr virtual const ArgumentsBase& get_args() const = 0;
 
    [[nodiscard]] constexpr virtual const CommandsBase& get_cmds() const = 0;
 
    constexpr bool operator==(std::string_view n) const { return name == n; }
};
 
template <typename T>
concept is_subcommand = requires(T t) {
    std::is_base_of_v<SubcommandBase, T>;
    requires std::same_as<std::decay_t<decltype(t.name)>, std::string_view>;
};
 
template <typename T>
concept are_commands = std::is_base_of_v<CommandsBase, std::decay_t<T>>;
 
class CommandsBase {
public:
    constexpr virtual ~CommandsBase() = default;
 
    [[nodiscard]] constexpr virtual const SubcommandBase* find(std::string_view name) const = 0;
 
    [[nodiscard]] constexpr virtual std::size_t size() const = 0;
};
 
template <is_subcommand... Cmd> class Commands : public CommandsBase {
private:
    static constexpr std::size_t count = sizeof...(Cmd);
    using storage_t
        = std::conditional_t<count != 1, std::tuple<Cmd...>, type::types_get_t<type::types<std::decay_t<Cmd>...>, 0>>;
 
public:
    constexpr Commands(const Cmd&... cmd)
        requires(count != 1)
        : m_cmds(std::tuple<Cmd...>(cmd...)) {
        assert(!contains_duplicate());
    }
 
    [[nodiscard]] constexpr std::size_t size() const override { return count; }
 
    [[nodiscard]] constexpr const SubcommandBase* find(std::string_view name) const override {
 
        if constexpr (count == 1) {
            return &m_cmds;
        } else if constexpr (count == 0) {
            return nullptr;
        } else {
            return find_impl<0>(name);
        }
    }
 
private:
    storage_t m_cmds;
 
    [[nodiscard]] constexpr bool contains_duplicate() const {
        if constexpr (count <= 1) {
            return false;
        }
        return contains_duplicate_impl<0, 1>();
    }
 
    template <std::size_t I, std::size_t J>
        requires(I < count && J < count)
    [[nodiscard]] constexpr bool contains_duplicate_impl() const {
        const auto& cmd   = std::get<I>(m_cmds);
        const auto& other = std::get<J>(m_cmds);
 
        if (cmd.name == other.name) {
            return true;
        }
 
        if constexpr (J + 1 >= count) {
            return contains_duplicate_impl<I + 1, I + 2>();
        } else {
            return contains_duplicate_impl<I, J + 1>();
        }
    }
 
    template <std::size_t I, std::size_t J>
        requires(I >= count || J >= count)
    [[nodiscard]] constexpr bool contains_duplicate_impl() const {
        return false;
    }
 
    template <std::size_t I> [[nodiscard]] constexpr const SubcommandBase* find_impl(std::string_view name) const {
        if constexpr (I >= count) {
            return nullptr;
        } else {
 
            const auto& cmd = std::get<I>(m_cmds);
 
            if (cmd.name == name) {
                return &cmd;
            } else {
                return find_impl<I + 1>(name);
            }
        }
    }
};
 
template <is_subcommand Cmd> class Commands<Cmd> : public CommandsBase {
public:
    constexpr Commands(const Cmd& cmd)
        : m_cmd(cmd) { }
 
    [[nodiscard]] constexpr const SubcommandBase* find(std::string_view name) const override {
        if (m_cmd.name == name) {
            return &m_cmd;
        } else {
            return nullptr;
        }
    }
 
    [[nodiscard]] constexpr std::size_t size() const override { return 1; }
 
private:
    Cmd m_cmd;
};
 
template <typename Args, typename Cmd> struct Subcommand;
 
template <is_arg... Args, is_subcommand... Cmd>
struct Subcommand<type::types<Args...>, type::types<Cmd...>> : public SubcommandBase {
 
    Arguments<Args...> args;
    Commands<Cmd...> cmds;
 
    constexpr Subcommand(
        std::string_view cmd_name, const Arguments<Args...>& arguments, const Commands<Cmd...>& commands
    )
        : SubcommandBase(cmd_name)
        , args(arguments)
        , cmds(commands) { }
 
    [[nodiscard]] constexpr const ArgumentsBase& get_args() const override { return args; }
 
    [[nodiscard]] constexpr const CommandsBase& get_cmds() const override { return cmds; }
};
 
template <is_arg... Args, is_subcommand... Cmds>
constexpr auto make_subcommand(
    std::string_view name,
    const Arguments<Args...>& args = Arguments<> {},
    const Commands<Cmds...>& cmds  = Commands<> {}
) {
    return Subcommand<type::types<Args...>, type::types<Cmds...>>(name, args, cmds);
}
 
}
 
#endif