subcommand.h

Go to the documentation of this file.

#ifndef OOKII_SUBCOMMAND_H_
#define OOKII_SUBCOMMAND_H_
 
#pragma once
 
#include "command_line_builder.h"
#include <span>
 
namespace ookii
{
    template<typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_command
    {
    public:
        using builder_type = basic_parser_builder<CharType, Traits, Alloc>;
 
        basic_command() = default;
 
        basic_command(builder_type &) {}
 
        virtual ~basic_command() = default;
 
        virtual int run() = 0;
    };
 
    using command = basic_command<char>;
    using wcommand = basic_command<wchar_t>;
 
    template<typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_command_with_custom_parsing : public basic_command<CharType, Traits, Alloc>
    {
    public:
        using command_manager_type = basic_command_manager<CharType, Traits, Alloc>;
        using usage_writer_type = basic_usage_writer<CharType, Traits, Alloc>;
 
        virtual bool parse(std::span<const CharType *const> args, const command_manager_type &manager, usage_writer_type *usage) = 0;
    };
 
    using command_with_custom_parsing = basic_command_with_custom_parsing<char>;
    using wcommand_with_custom_parsing = basic_command_with_custom_parsing<wchar_t>;
 
    template<typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class command_info
    {
    public:
        using command_type = basic_command<CharType, Traits, Alloc>;
        using command_with_custom_parsing_type = basic_command_with_custom_parsing<CharType, Traits, Alloc>;
        using builder_type = typename command_type::builder_type;
        using string_type = std::basic_string<CharType, Traits, Alloc>;
        using creator = std::function<std::unique_ptr<command_type>(builder_type *)>;
 
    public:
 
        command_info(string_type name, string_type description, creator creator, bool use_custom_argument_parsing = false)
            : _name{name},
              _description{description},
              _creator{creator},
              _use_custom_argument_parsing{use_custom_argument_parsing}
        {
        }
 
        template<typename T, std::enable_if_t<!std::is_base_of_v<command_with_custom_parsing_type, T>, int> = 0>
        static command_info create(string_type name, string_type description)
        {
            auto creator = [](builder_type *builder) -> std::unique_ptr<command_type>
            {
                return std::make_unique<T>(*builder);
            };
 
            return {name, description, creator};
        }
 
        template<typename T, std::enable_if_t<std::is_base_of_v<command_with_custom_parsing_type, T>, int> = 0>
        static command_info create(string_type name, string_type description)
        {
            auto creator = [](builder_type *) -> std::unique_ptr<command_type>
            {
                return std::make_unique<T>();
            };
 
            return {name, description, creator, true};
        }
 
        std::unique_ptr<command_type> create(builder_type &builder) const
        {
            if (_use_custom_argument_parsing)
            {
                return {};
            }
 
            return _creator(&builder);
        }
 
        std::unique_ptr<command_type> create_custom_parsing() const
        {
            if (!_use_custom_argument_parsing)
            {
                return {};
            }
 
            return _creator(nullptr);
        }
 
        bool use_custom_argument_parsing() const noexcept
        {
            return _use_custom_argument_parsing;
        }
 
        const string_type &name() const noexcept
        {
            return _name;
        }
 
        const string_type &description() const noexcept
        {
            return _description;
        }
 
    private:
        string_type _name;
        string_type _description;
        creator _creator;
        bool _use_custom_argument_parsing{};
    };
 
    namespace details
    {
        template<typename CharType, typename Traits, typename Alloc>
        class version_command : public basic_command<CharType, Traits, Alloc>
        {
        public:
            using base_type = basic_command<CharType, Traits, Alloc>;
            using builder_type = typename base_type::builder_type;
 
            version_command(builder_type &builder, typename builder_type::version_function function)
                : base_type{builder},
                  _function{function}
            {
            }
 
            virtual int run() override
            {
                _function();
                return 0;
            }
 
        private:
            typename builder_type::version_function _function;
        };
    }
 
    template<typename CharType = details::default_char_type, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_command_manager
    {
    public:
        using info_type = command_info<CharType, Traits, Alloc>;
        using string_type = typename info_type::string_type;
        using builder_type = typename info_type::builder_type;
        using command_type = typename info_type::command_type;
        using command_with_custom_parsing_type = typename info_type::command_with_custom_parsing_type;
        using usage_writer_type = basic_usage_writer<CharType, Traits, Alloc>;
        using stream_type = std::basic_ostream<CharType, Traits>;
        using configure_function = std::function<void(builder_type&)>;
        using version_function = std::function<void()>;
        using string_provider_type = basic_localized_string_provider<CharType, Traits, Alloc>;
 
        basic_command_manager(string_type application_name, bool case_sensitive = false, const std::locale &locale = {},
            const string_provider_type *string_provider = nullptr)
            : _commands{string_less{case_sensitive, locale}},
              _application_name{application_name},
              _locale{locale},
              _string_provider{string_provider},
              _case_sensitive{case_sensitive}
        {
            if (_string_provider == nullptr)
            {
                _string_provider = &string_provider_type::get_default();
            }
        }
 
        basic_command_manager &description(string_type description)
        {
            _description = description;
            return *this;
        }
 
        const string_type &description() const
        {
            return _description;
        }
 
        basic_command_manager& common_help_argument(string_type name_with_prefix)
        {
            _common_help_argument = name_with_prefix;
            return *this;
        }
 
        const string_type& common_help_argument() const
        {
            return _common_help_argument;
        }
 
        basic_command_manager &configure_parser(configure_function function)
        {
            _configure_function = function;
            return *this;
        }
 
        template<typename T>
        basic_command_manager &add_command(string_type name = {}, string_type description = {})
        {
            if (name.empty())
                name = name_helper<T>::name();
 
            if (description.empty())
                description = description_helper<T>::description();
 
            auto [it, success] = _commands.emplace(name, info_type::template create<T>(name, description));
            if (!success)
                throw std::logic_error("Duplicate command name");
 
            return *this;
        }
 
        basic_command_manager &add_version_command(version_function function)
        {
            auto creator = [function = std::move(function)](builder_type *builder) -> std::unique_ptr<command_type>
            {
                return std::make_unique<details::version_command<CharType, Traits, Alloc>>(*builder, function);
            };
 
            auto name = _string_provider->automatic_version_command_name();
            auto description = _string_provider->automatic_version_description();
            auto [it, success] = _commands.emplace(name, info_type{name, description, creator});
            if (!success)
                throw std::logic_error("Duplicate command name");
 
            return *this;
        }
 
#if defined(_WIN32) || defined(DOXYGEN)
        basic_command_manager &add_win32_version_command()
        {
            return add_version_command(details::show_win32_version<CharType>);
        }
#endif
 
 
        auto commands() const noexcept
        {
            return details::range_filter<const info_type &, typename std::map<string_type, info_type, string_less>::const_iterator>{
                _commands.begin(),
                _commands.end(),
                [](const auto &a) -> auto&
                {
                    return a.second;
                },
                {}
            };
        }
 
        const string_type &application_name() const noexcept
        {
            return _application_name;
        }
 
        const std::locale &locale() const noexcept
        {
            return _locale;
        }
 
        const string_provider_type &string_provider() const noexcept
        {
            return *_string_provider;
        }
 
        bool case_sensitive() const noexcept
        {
            return _case_sensitive;
        }
 
        const info_type *get_command(const string_type &name) const
        {
            auto it = _commands.find(name);
            if (it == _commands.end())
                return nullptr;
 
            return &it->second;
        }
 
        std::unique_ptr<command_type> create_command(int argc, const CharType *const argv[], usage_writer_type *usage = nullptr) const
        {
            if (argc < 2)
            {
                write_usage(usage);
                return {};
            }
 
            std::span args{argv, static_cast<size_t>(argc)};
            return create_command(argv[1], args.subspan(2), usage);
        }
 
        std::unique_ptr<command_type> create_command(std::span<const CharType *const> args, usage_writer_type *usage = nullptr) const
        {
            if (args.size() < 1)
            {
                write_usage(usage);
                return {};
            }
 
            return create_command(args[0], args.subspan(1), usage);
        }
 
        std::unique_ptr<command_type> create_command(const string_type &name, std::span<const CharType *const> args, usage_writer_type *usage = nullptr) const
        {
            auto info = get_command(name);
            if (info == nullptr)
            {
                write_usage(usage);
                return {};
            }
 
            std::unique_ptr<command_type> command;
            if (info->use_custom_argument_parsing())
            {
                command = info->create_custom_parsing();
                auto custom_command = static_cast<command_with_custom_parsing_type*>(command.get());
                if (!custom_command->parse(args, *this, usage))
                    return {};
            }
            else
            {
                auto builder = create_parser_builder(*info);
                command = info->create(builder);
                auto parser = builder.build();
                if (!parser.parse(args, usage))
                    return {};
            }
 
            return command;
        }
 
        std::optional<int> run_command(int argc, const CharType *const argv[], usage_writer_type *usage = nullptr) const
        {
            auto command = create_command(argc, argv, usage);
            if (!command)
                return {};
 
            return command->run();
        }
 
        std::optional<int> run_command(std::span<const CharType *const> args, usage_writer_type *usage = nullptr) const
        {
            auto command = create_command(args, usage);
            if (!command)
                return {};
 
            return command->run();
        }
 
        std::optional<int> run_command(const string_type &name, std::span<const CharType *const> args, usage_writer_type *usage = nullptr) const
        {
            auto command = create_command(name, args, usage);
            if (!command)
                return {};
 
            return command->run();
        }
 
        void write_usage(usage_writer_type *usage = nullptr) const
        {
            if (usage == nullptr)
            {
                usage_writer_type{}.write_command_list_usage(*this);
            }
            else
            {
                usage->write_command_list_usage(*this);
            }
        }
 
        builder_type create_parser_builder(const info_type &command) const
        {
            // Include the application name so usage will be correct.
            string_type full_name = _application_name + static_cast<CharType>(' ') + command.name();
            builder_type builder{full_name, _string_provider};
            builder.locale(_locale)
                .case_sensitive(_case_sensitive)
                .description(command.description());
 
            if (_configure_function)
            {
                _configure_function(builder);
            }
 
            return builder;
        }
 
    private:
        template<typename T, typename = void>
        struct name_helper
        {
            static string_type name()
            {
                return get_short_type_name<T, CharType, Traits, Alloc>();
            }
        };
 
        template<typename T>
        struct name_helper<T, std::void_t<decltype(T::name())>>
        {
            static string_type name()
            {
                return T::name();
            }
        };
 
        template<typename T, typename = void>
        struct description_helper
        {
            static string_type description()
            {
                return {};
            }
        };
 
        template<typename T>
        struct description_helper<T, std::void_t<decltype(T::description())>>
        {
            static string_type description()
            {
                return T::description();
            }
        };
 
        std::map<string_type, info_type, string_less> _commands;
        string_type _application_name;
        string_type _description;
        string_type _common_help_argument;
        std::locale _locale;
        configure_function _configure_function;
        const string_provider_type *_string_provider;
        bool _case_sensitive;
    };
 
    using command_manager = basic_command_manager<char>;
    using wcommand_manager = basic_command_manager<wchar_t>;
 
}
 
#endif