shell_command.h

Go to the documentation of this file.

#ifndef OOKII_SHELL_COMMAND_H_
#define OOKII_SHELL_COMMAND_H_
 
#pragma once
 
#include "command_line_builder.h"
#include "shell_command_usage_options.h"
 
namespace ookii
{
    template<typename CharType = details::default_char_type, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_shell_command
    {
    public:
        using builder_type = basic_parser_builder<CharType, Traits, Alloc>;
 
        basic_shell_command() = default;
 
        basic_shell_command(builder_type &) {}
 
        virtual ~basic_shell_command() = default;
 
        virtual int run() = 0;
    };
 
    using shell_command = basic_shell_command<char>;
    using wshell_command = basic_shell_command<wchar_t>;
 
    template<typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class shell_command_info
    {
    public:
        using command_type = basic_shell_command<CharType, Traits, Alloc>;
        using builder_type = typename command_type::builder_type;
        using string_type = std::basic_string<CharType, Traits, Alloc>;
 
    private:
        using creator = std::function<std::unique_ptr<command_type>(builder_type &)>;
 
    public:
 
        template<typename T>
        static shell_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};
        }
 
        std::unique_ptr<command_type> create(builder_type &builder) const
        {
            return _creator(builder);
        }
 
        const string_type &name() const noexcept
        {
            return _name;
        }
 
        const string_type &description() const noexcept
        {
            return _description;
        }
 
    private:
        shell_command_info(string_type name, string_type description, creator creator)
            : _name{name},
              _description{description},
              _creator{creator}
        {
        }
 
        string_type _name;
        string_type _description;
        creator _creator;
    };
 
    template<typename CharType = details::default_char_type, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_shell_command_manager
    {
    public:
        using info_type = shell_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 usage_options_type = basic_shell_command_usage_options<CharType, Traits, Alloc>;
        using stream_type = std::basic_ostream<CharType, Traits>;
 
        static constexpr int error_return_code = 1;
 
        basic_shell_command_manager(string_type application_name, bool case_sensitive = false, const std::locale &locale = {})
            : _commands{string_less{case_sensitive, locale}},
              _application_name{application_name},
              _locale{locale},
              _case_sensitive{case_sensitive}
        {
        }
 
        template<typename T>
        basic_shell_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;
        }
 
        auto commands() const noexcept
        {
            return _commands | std::views::values;
        }
 
        const info_type *get_command(const string_type &name) const
        {
            auto it = _commands.find(name);
            if (it == _commands.end())
                return nullptr;
 
            return &it->second;
        }
 
        template<typename Iterator>
        std::unique_ptr<command_type> create_command(const string_type &name, Iterator begin, Iterator end, const usage_options_type &options = {}) const
        {
            auto info = get_command(name);
            if (info == nullptr)
            {
                write_usage(options);
                return {};
            }
 
            auto builder = create_parser_builder(*info);
            auto command = info->create(builder);
            auto parser = builder.build();
            if (!parser.parse(begin, end, options))
                return {};
 
            return command;
        }
 
        template<typename Range>
        std::unique_ptr<command_type> create_command(const string_type &name, Range range, const usage_options_type &options = {}) const
        {
            // For ADL
            using std::begin;
            using std::end;
            return create_command(name, begin(range), end(range), options);
        }
 
        template<typename T>
        std::unique_ptr<command_type> create_command(const string_type &name, std::initializer_list<T> args, const usage_options_type &options = {}) const
        {
            return create_command(name, args.begin(), args.end(), options);
        }
 
        template<typename Iterator>
        std::unique_ptr<command_type> create_command(Iterator begin, Iterator end, const usage_options_type &options = {}) const
        {
            if (begin == end)
            {
                write_usage(options);
                return {};
            }
 
            auto &name = *begin;
            return create_command(name, ++begin, end, options);
        }
 
        template<typename Range>
        std::unique_ptr<command_type> create_command(Range range, const usage_options_type &options = {}) const
        {
            // For ADL
            using std::begin;
            using std::end;
            return create_command(begin(range), end(range), options);
        }
 
        template<typename T>
        std::unique_ptr<command_type> create_command(std::initializer_list<T> args, const usage_options_type &options = {}) const
        {
            return create_command(args.begin(), args.end(), options);
        }
 
        std::unique_ptr<command_type> create_command(int argc, const CharType *const argv[], const usage_options_type &options = {}) const
        {
            if (argc < 2)
            {
                write_usage(options);
                return {};
            }
 
            return create_command(argv + 1, argv + argc, options);
        }
 
        template<typename Iterator>
        int run_command(const string_type &name, Iterator begin, Iterator end, const usage_options_type &options = {}) const
        {
            auto command = create_command(name, begin, end, options);
            if (!command)
                return error_return_code;
 
            return command->run();
        }
 
        template<typename Range>
        int run_command(const string_type &name, Range range, const usage_options_type &options = {}) const
        {
            // For ADL
            using std::begin;
            using std::end;
            return run_command(name, begin(range), end(range), options);
        }
 
        template<typename T>
        int run_command(const string_type &name, std::initializer_list<T> args, const usage_options_type &options = {}) const
        {
            return run_command(name, args.begin(), args.end(), options);
        }
 
        template<typename Iterator>
        int run_command(Iterator begin, Iterator end, const usage_options_type &options = {}) const
        {
            auto command = create_command(begin, end, options);
            if (!command)
                return error_return_code;
 
            return command->run();
        }
 
        template<typename Range>
        int run_command(Range range, const usage_options_type &options = {}) const
        {
            // For ADL
            using std::begin;
            using std::end;
            return run_command(begin(range), end(range), options);
        }
 
        template<typename T>
        int run_command(std::initializer_list<T> args, const usage_options_type &options = {}) const
        {
            return run_command(args.begin(), args.end(), options);
        }
 
        int run_command(int argc, const CharType *const argv[], const usage_options_type &options = {}) const
        {
            auto command = create_command(argc, argv, options);
            if (!command)
                return error_return_code;
 
            return command->run();
        }
 
        void write_usage(const usage_options_type &options = {}) const
        {
            auto &stream = options.output;
            auto usage = format::ncformat(_locale, options.command_usage_format, _application_name);
            usage = format::ncformat(_locale, options.usage_prefix_format, usage);
            stream << usage << std::endl << std::endl;
            stream << options.available_commands_header << std::endl << std::endl;
            stream << set_indent(options.command_indent);
            for (const auto &command : _commands)
            {
                stream << reset_indent;
                stream << format::ncformat(_locale, options.command_format, command.second.name(), command.second.description()) << std::endl;
            }
        }
 
        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};
            builder.locale(_locale)
                .case_sensitive(_case_sensitive)
                .description(command.description());
 
            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;
        std::locale _locale;
        bool _case_sensitive;
    };
 
    using shell_command_manager = basic_shell_command_manager<char>;
    using wshell_command_manager = basic_shell_command_manager<wchar_t>;
 
}
 
#endif