command_line_builder.h

Go to the documentation of this file.

#ifndef OOKII_COMMAND_LINE_BUILDER_H_
#define OOKII_COMMAND_LINE_BUILDER_H_
 
#pragma once
 
#include "command_line_parser.h"
 
namespace ookii
{
    namespace details
    {
        template <typename Ret, typename Arg, typename... Rest>
        Arg first_argument_helper(Ret (*)(Arg, Rest...));
 
        template <typename Ret, typename F, typename Arg, typename... Rest>
        Arg first_argument_helper(Ret (F::*)(Arg, Rest...));
 
        template <typename Ret, typename F, typename Arg, typename... Rest>
        Arg first_argument_helper(Ret (F::*)(Arg, Rest...) const);
 
        template <typename F>
        decltype(first_argument_helper(&F::operator())) first_argument_helper(F);
 
        template <typename T>
        using first_argument_type = decltype(first_argument_helper(std::declval<T>()));
 
#ifdef _WIN32
        template<typename CharType>
        inline void show_win32_version()
        {
            auto info = details::get_version_resource();
            if (!info)
            {
                console_stream<CharType>::cout() << "Unknown version." << std::endl;
                return;
            }
 
            console_stream<CharType>::cout() << info->product_name << " " << info->version << std::endl;
            if (!info->copyright.empty())
            {
                console_stream<CharType>::cout() << info->copyright << std::endl;
            }
        }
#endif
    }
 
    template<typename CharType = details::default_char_type, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_parser_builder
    {
        using parser_storage_type = details::parser_storage<CharType, Traits, Alloc>;
        using creation_options_type = details::creation_options<CharType, Traits, Alloc>;
 
    public:
        using parser_type = basic_command_line_parser<CharType, Traits, Alloc>;
        using string_type = typename parser_type::string_type;
        using argument_base_type = typename parser_type::argument_base_type;
        using string_provider_type = typename parser_type::string_provider_type;
        using version_function = std::function<void()>;
 
        template<typename T>
        using typed_argument_type = command_line_argument<T, CharType, Traits, Alloc>;
 
        template<typename T>
        using multi_value_argument_type = multi_value_command_line_argument<T, CharType, Traits, Alloc>;
 
        class argument_builder_base;
 
        template<typename T>
        class argument_builder;
 
        template<typename T>
        class multi_value_argument_builder;
 
        template<typename T>
        class action_argument_builder;
 
        class argument_builder_base
        {
            using storage_type = typename argument_base_type::storage_type;
 
        public:
            virtual ~argument_builder_base() = default;
 
            argument_builder_base(argument_builder_base &) = delete;
            argument_builder_base &operator=(argument_builder_base &) = delete;
 
            template<typename T>
            argument_builder<T> &add_argument(T &value, string_type name)
            {
                return _parser_builder.add_argument(value, name);
            }
 
            template<typename T>
            argument_builder<T> &add_argument(T &value, CharType short_name)
            {
                return _parser_builder.add_argument(value, short_name);
            }
 
            template<typename Action>
            action_argument_builder<details::first_argument_type<Action>> &add_action_argument(Action action, string_type name)
            {
                return _parser_builder.add_action_argument(action, name);
            }
 
            template<typename Action>
            action_argument_builder<details::first_argument_type<Action>> &add_action_argument(Action action, CharType short_name)
            {
                return _parser_builder.add_action_argument(action, short_name);
            }
 
            template<typename T>
            multi_value_argument_builder<T> &add_multi_value_argument(T &value, string_type name)
            {
                return _parser_builder.add_multi_value_argument(value, name);
            }
 
            template<typename T>
            multi_value_argument_builder<T> &add_multi_value_argument(T &value, CharType short_name)
            {
                return _parser_builder.add_multi_value_argument(value, short_name);
            }
 
            action_argument_builder<bool> &add_version_argument(version_function function)
            {
                return _parser_builder.add_version_argument(function);
            }
 
#if defined(_WIN32) || defined(DOXYGEN)
            action_argument_builder<bool> &add_win32_version_argument()
            {
                return _parser_builder.add_win32_version_argument();
            }
#endif
 
            parser_type build()
            {
                return _parser_builder.build();
            }
 
            const string_type &name() const noexcept
            {
                return _storage.name;
            }
 
            const CharType &short_name() const noexcept
            {
                return _storage.short_name;
            }
 
            virtual std::unique_ptr<argument_base_type> to_argument(parser_type &parser) = 0;
 
        protected:
            argument_builder_base(basic_parser_builder &basic_parser_builder, string_type name)
                : _storage{name},
                  _parser_builder{basic_parser_builder}
            {
            }
 
            argument_builder_base(basic_parser_builder &basic_parser_builder, CharType short_name)
                : _storage{string_type{short_name}},
                  _parser_builder{basic_parser_builder}
            {
                _storage.short_name = short_name;
                _storage.has_long_name = false;
            }
 
            storage_type &storage()
            {
                return _storage;
            }
 
            size_t get_next_position()
            {
                return _parser_builder.get_next_position();
            }
 
        private:
            storage_type _storage;
            basic_parser_builder &_parser_builder;
        };
 
        template<typename BuilderType>
        class argument_builder_common : public argument_builder_base
        {
        public:
            using argument_builder_base::argument_builder_base;
 
            BuilderType &name(string_type name)
            {
                this->storage().name = name;
                this->storage().has_long_name = true;
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &short_name()
            {
                this->storage().short_name = this->storage().name[0];
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &short_name(CharType short_name)
            {
                this->storage().short_name = short_name;
                return *static_cast<BuilderType*>(this);
            }
 
            const string_type &name() const noexcept
            {
                return argument_builder_base::name();
            }
 
            const CharType &short_name() const noexcept
            {
                return argument_builder_base::short_name();
            }
 
            BuilderType &value_description(string_type value_description)
            {
                this->storage().value_description = value_description;
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &description(string_type description)
            {
                this->storage().description = description;
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &positional()
            {
                if (!this->storage().position)
                {
                    this->storage().position = this->get_next_position();
                }
 
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &required()
            {
                this->storage().is_required = true;
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &alias(string_type alias)
            {
                this->storage().aliases.push_back(alias);
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &short_alias(CharType alias)
            {
                this->storage().short_aliases.push_back(alias);
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &cancel_parsing()
            {
                this->storage().cancel_parsing = true;
                return *static_cast<BuilderType*>(this);
            }
        };
 
        template<typename ArgumentType, typename BuilderType>
        class typed_argument_builder : public argument_builder_common<BuilderType>
        {
            using base_type = argument_builder_common<BuilderType>;
            using typed_storage_type = typename ArgumentType::typed_storage_type;
            using value_type = typename ArgumentType::value_type;
            using element_type = typename ArgumentType::element_type;
            using converter_type = typename typed_storage_type::converter_type;
 
        public:
            typed_argument_builder(basic_parser_builder &basic_parser_builder, string_type name, value_type &value)
                : base_type{basic_parser_builder, name},
                  _typed_storage{value}
            {
            }
 
            typed_argument_builder(basic_parser_builder &basic_parser_builder, CharType short_name, value_type &value)
                : base_type{basic_parser_builder, short_name},
                  _typed_storage{value}
            {
            }
 
            BuilderType &default_value(element_type default_value)
            {
                this->_typed_storage.default_value = default_value;
                return *static_cast<BuilderType*>(this);
            }
 
            BuilderType &converter(converter_type converter)
            {
                this->_typed_storage.converter = converter;
                return *static_cast<BuilderType*>(this);
            }
 
        private:
            virtual std::unique_ptr<argument_base_type> to_argument(parser_type &parser) override
            {
                if (this->storage().value_description.empty())
                    this->storage().value_description = ::ookii::value_description<element_type, CharType, Traits, Alloc>::get();
 
                return make_unique<ArgumentType>(parser, std::move(this->storage()), std::move(_typed_storage));
            }
 
            typed_storage_type _typed_storage;
        };
 
        template<typename T>
        class argument_builder final : public typed_argument_builder<typed_argument_type<T>, argument_builder<T>>
        {
            using base_type = typed_argument_builder<typed_argument_type<T>, argument_builder<T>>;
 
        public:
            using base_type::base_type;
        };
 
        template<typename T>
        class multi_value_argument_builder final : public typed_argument_builder<multi_value_argument_type<T>, multi_value_argument_builder<T>>
        {
            using base_type = typed_argument_builder<multi_value_argument_type<T>, multi_value_argument_builder<T>>;
            
        public:
            using base_type::base_type;
 
            multi_value_argument_builder &separator(CharType separator)
            {
                this->storage().multi_value_separator = separator;
                return *this;
            }
        };
 
        template<typename T>
        class action_argument_builder final : public argument_builder_common<action_argument_builder<T>>
        {
            using argument_type = action_command_line_argument<T, CharType, Traits, Alloc>;
            using base_type = argument_builder_common<action_argument_builder<T>>;
            using typed_storage_type = typename argument_type::typed_storage_type;
            using value_type = typename argument_type::value_type;
            using element_type = typename argument_type::element_type;
            using converter_type = typename typed_storage_type::converter_type;
 
        public:
            using function_type = typename argument_type::function_type;
 
            action_argument_builder(basic_parser_builder &parser_builder, string_type name, function_type action)
                : base_type{parser_builder, name},
                  _typed_storage{action}
            {
            }
 
            action_argument_builder(basic_parser_builder &parser_builder, CharType short_name, function_type action)
                : base_type{parser_builder, short_name},
                  _typed_storage{action}
            {
            }
 
            action_argument_builder &converter(converter_type converter)
            {
                this->_typed_storage.converter = converter;
                return *this;
            }
 
        private:
            virtual std::unique_ptr<argument_base_type> to_argument(parser_type &parser) override
            {
                if (this->storage().value_description.empty())
                    this->storage().value_description = ::ookii::value_description<element_type, CharType, Traits, Alloc>::get();
 
                return make_unique<argument_type>(parser, std::move(this->storage()), std::move(_typed_storage));
            }
 
            typed_storage_type _typed_storage;
        };
 
        basic_parser_builder(string_type command_name, const string_provider_type *string_provider = nullptr)
            : _storage{command_name, string_provider}
        {
        }
 
        template<typename T>
        argument_builder<T> &add_argument(T &value, string_type name)
        {
            _arguments.push_back(std::make_unique<argument_builder<T>>(*this, name, value));
            return *static_cast<argument_builder<T>*>(_arguments.back().get());
        }
 
        template<typename T>
        argument_builder<T> &add_argument(T &value, CharType short_name)
        {
            _arguments.push_back(std::make_unique<argument_builder<T>>(*this, short_name, value));
            return *static_cast<argument_builder<T>*>(_arguments.back().get());
        }
 
        template<typename Action>
        action_argument_builder<details::first_argument_type<Action>> &add_action_argument(Action action, string_type name)
        {
            using argument_type = action_argument_builder<details::first_argument_type<Action>>;
            _arguments.push_back(std::make_unique<argument_type>(*this, name, action));
            return *static_cast<argument_type*>(_arguments.back().get());
        }
 
        template<typename Action>
        action_argument_builder<details::first_argument_type<Action>> &add_action_argument(Action action, CharType short_name)
        {
            using argument_type = action_argument_builder<details::first_argument_type<Action>>;
            _arguments.push_back(std::make_unique<argument_type>(*this, short_name, action));
            return *static_cast<argument_type*>(_arguments.back().get());
        }
 
        template<typename T>
        multi_value_argument_builder<T> &add_multi_value_argument(T &value, string_type name)
        {
            _arguments.push_back(std::make_unique<multi_value_argument_builder<T>>(*this, name, value));
            return *static_cast<multi_value_argument_builder<T>*>(_arguments.back().get());
        }
 
        template<typename T>
        multi_value_argument_builder<T> &add_multi_value_argument(T &value, CharType short_name)
        {
            _arguments.push_back(std::make_unique<multi_value_argument_builder<T>>(*this, short_name, value));
            return *static_cast<multi_value_argument_builder<T>*>(_arguments.back().get());
        }
 
        action_argument_builder<bool> &add_version_argument(version_function function)
        {
            if (_version_argument != nullptr)
            {
                throw std::logic_error("Duplicate version argument.");
            }
            
            auto action = [function = std::move(function)](bool, parser_type &)
            {
                function();
                // Cancel parsing without requesting help.
                return false;
            };
 
            auto &argument = add_action_argument(action, _storage.string_provider->automatic_version_name())
                .description(_storage.string_provider->automatic_version_description());
 
            _version_argument = &argument;
            return argument;
        }
 
#if defined(_WIN32) || defined(DOXYGEN)
        action_argument_builder<bool> &add_win32_version_argument()
        {
            return add_version_argument(details::show_win32_version<CharType>);
        }
#endif
 
        parser_type build()
        {
            if (_storage.prefixes.empty())
                _storage.prefixes = parser_type::get_default_prefixes();
 
            if (_storage.mode == parsing_mode::long_short)
            {
                if (_storage.long_prefix.empty())
                {
                    _storage.long_prefix = c_default_long_prefix.data();
                }
            }
            else
            {
                _storage.long_prefix.clear();
            }
 
            // If there is a version argument, try to match its case to other arguments.
            if (_version_argument != nullptr)
            {
                auto it = std::find_if(_arguments.begin(), _arguments.end(), [this](auto &item) { return item.get() != _version_argument; });
                if (it != _arguments.end())
                {
                    auto name = _version_argument->name();
                    if (std::isupper((*it)->name()[0], _storage.locale))
                    {
                        name[0] = std::toupper(name[0], _storage.locale);
                    }
                    else
                    {
                        name[0] = std::tolower(name[0], _storage.locale);
                    }
 
                    _version_argument->name(name);
                }
            }
 
            return parser_type{_arguments, std::move(_storage), _options};
        }
 
        basic_parser_builder &case_sensitive(bool case_sensitive) noexcept
        {
            _options.case_sensitive = case_sensitive;
            return *this;
        }
 
        basic_parser_builder &locale(std::locale loc)
        {
            _storage.locale = loc;
            return *this;
        }
 
        basic_parser_builder &mode(parsing_mode mode)
        {
            if (mode < parsing_mode::default_mode || mode > parsing_mode::long_short)
            {
                throw std::invalid_argument("mode");
            }
 
            _storage.mode = mode;
            return *this;
        }
 
        template<typename Range>
        basic_parser_builder &prefixes(const Range &prefixes)
        {
            // Using enables ADL.
            using std::begin;
            using std::end;
            _storage.prefixes = std::vector<string_type>{ begin(prefixes), end(prefixes) };
            return *this;
        }
 
        template<typename T>
        basic_parser_builder &prefixes(std::initializer_list<T> prefixes)
        {
            return this->prefixes<std::initializer_list<T>>(prefixes);
        }
 
        basic_parser_builder &long_prefix(string_type prefix)
        {
            _storage.long_prefix = prefix;
            return *this;
        }
 
        basic_parser_builder &allow_whitespace_separator(bool allow) noexcept
        {
            _storage.allow_white_space_separator = allow;
            return *this;
        }
 
        basic_parser_builder &allow_duplicate_arguments(bool allow) noexcept
        {
            _storage.allow_duplicate_arguments = allow;
            return *this;
        }
 
        basic_parser_builder &argument_value_separator(CharType separator) noexcept
        {
            _storage.argument_value_separator = separator;
            return *this;
        }
 
        basic_parser_builder &description(string_type description)
        {
            _storage.description = description;
            return *this;
        }
 
        basic_parser_builder &automatic_help_argument(bool enable)
        {
            _options.automatic_help_argument = enable;
            return *this;
        }
 
        basic_parser_builder& show_usage_on_error(usage_help_request request)
        {
            _storage.show_usage_on_error = request;
            return *this;
        }
 
    private:
        size_t get_next_position() noexcept
        {
            return _next_position++;
        }
 
        std::vector<std::unique_ptr<argument_builder_base>> _arguments;
        size_t _next_position{};
        action_argument_builder<bool> *_version_argument{};
        
        creation_options_type _options{};
        parser_storage_type _storage;
 
        static constexpr auto c_default_long_prefix = literal_cast<CharType>("--");
    };
 
    using parser_builder = basic_parser_builder<char>;
    using wparser_builder = basic_parser_builder<wchar_t>;
 
}
 
#endif