command_line_core.h

Go to the documentation of this file.

#ifndef OOKII_COMMAND_LINE_CORE_H_
#define OOKII_COMMAND_LINE_CORE_H_
 
#pragma once
 
#include <iterator>
#include <map>
#include "command_line_argument.h"
#include "parse_result.h"
#include "owned_or_borrowed_ptr.h"
 
namespace ookii
{
    namespace details
    {
#ifdef _UNICODE
        using default_char_type = wchar_t;
#else
        using default_char_type = char;
#endif
 
        template<typename CharType, typename Traits, typename Alloc>
        struct parser_storage
        {
            using string_type = std::basic_string<CharType, Traits, Alloc>;
 
            parser_storage(string_type command_name)
                : command_name(command_name)
            {
            }
 
            string_type command_name;
            string_type description;
            std::vector<string_type> prefixes;
            std::locale locale;
            CharType argument_value_separator{':'};
            bool allow_white_space_separator{true};
            bool allow_duplicate_arguments{false};
        };
    }
 
    enum class on_parsed_action
    {
        none,
        cancel_parsing,
        always_continue
    };
 
    template<typename CharType = details::default_char_type, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_command_line_parser
    {
    public:
        using argument_base_type = command_line_argument_base<CharType, Traits, Alloc>;
        using string_type = typename argument_base_type::string_type;
        using string_view_type = std::basic_string_view<CharType, Traits>;
        using result_type = parse_result<CharType, Traits, Alloc>;
        using usage_options_type = basic_usage_options<CharType, Traits, Alloc>;
        using storage_type = details::parser_storage<CharType, Traits, Alloc>;
        using on_parsed_callback = std::function<on_parsed_action(argument_base_type &, string_view_type value)>;
 
        template<typename T>
        using argument_type = command_line_argument<T, CharType, Traits, Alloc>;
 
        template<typename T>
        using converter_type = typename argument_type<T>::typed_storage_type::converter_type;
 
        static constexpr std::vector<string_type> get_default_prefixes()
        {
            std::vector<string_type> result;
 
#ifdef _WIN32
            result.reserve(2);
#else
            result.reserve(1);
#endif
 
            constexpr auto prefix1 = literal_cast<CharType>("-");
            result.push_back(prefix1.data());
 
#ifdef _WIN32
            constexpr auto prefix2 = literal_cast<CharType>("/");
            result.push_back(prefix2.data());
#endif
 
            return result;
        }
 
        template<typename Range>
        basic_command_line_parser(const Range &arguments, storage_type &&storage, bool case_sensitive)
            : _storage{std::move(storage)},
              _arguments{string_less{case_sensitive, storage.locale}}
        {
            for (const auto &argument : arguments)
            {
                auto actual_arg = argument->to_argument();
                auto name = actual_arg->name();
                const auto [it, success] = _arguments.insert(std::pair{name, std::move(actual_arg)});
                if (!success)
                    throw std::logic_error("Duplicate argument name.");
 
                if (it->second->position())
                {
                    // Usually, positional arguments should be in order in the builder, but it's
                    // technically possible for the caller to have stored references to the argument
                    // builders and called positional() on them in a different order than they were
                    // created, so make sure the resulting list is ordered correctly regardless.
                    const auto pos = std::lower_bound(_positional_arguments.begin(),
                        _positional_arguments.end(),
                        it->second,
                        [](const auto &left, const auto &right)
                        {
                            return *left->position() < *right->position();
                        });
 
                    _positional_arguments.insert(pos, it->second.get());
                }
 
                for (const auto &alias : it->second->aliases())
                {
                    // Add the aliases to the arguments list using borrowed pointers.
                    const auto [alias_it, alias_success] = _arguments.insert(std::pair{alias, it->second.as_borrowed()});
                    if (!alias_success)
                        throw std::logic_error("Duplicate argument name.");
                }
            }
        }
 
        const string_type &command_name() const noexcept
        {
            return _storage.command_name;
        }
 
        const string_type &description() const noexcept
        {
            return _storage.command_name;
        }
 
        bool allow_white_space_separator() const noexcept
        {
            return _storage.allow_white_space_separator;
        }
 
        bool allow_duplicate_arguments() const noexcept
        {
            return _storage.allow_duplicate_arguments;
        }
 
        CharType argument_value_separator() const noexcept
        {
            return _storage.argument_value_separator;
        }
 
        const std::vector<string_type> &prefixes() const noexcept
        {
            return _storage.prefixes;
        }
 
        const std::locale &locale() const noexcept
        {
            return _storage.locale;
        }
 
        auto arguments() const
        {
            return _arguments | std::views::filter([](const auto &a)
                {
                    // Borrowed pointers are aliases and shouldn't be returned here.
                    return a.second.is_owned();
                })
                | std::views::transform([](const auto &a) -> auto&
                {
                    return *a.second;
                });
        }
 
        size_t positional_argument_count() const
        {
            return _positional_arguments.size();
        }
 
        const argument_base_type &get_argument(size_t pos) const
        {
            return *_positional_arguments.at(pos);
        }
 
        const argument_base_type &get_argument(const string_type &name) const
        {
            return *_arguments.at(name);
        }
 
        template<typename Iterator>
        [[nodiscard]] result_type parse(Iterator begin, Iterator end)
        {
            for (auto &arg : _arguments)
                arg.second->reset();
 
            size_t position = 0;
            for (auto current = begin; current != end; ++current)
            {
                auto arg = *current;
                auto prefix_length = check_prefix(arg);
                if (prefix_length > 0)
                {
                    // Current is updated if parsing used the next argument for a value.
                    auto result = parse_named_argument(arg, current, end, prefix_length);
                    if (!result)
                        return result;
                }
                else
                {
                    // If this is a multi-value argument then we're on the last argument, otherwise search for the next argument without a value
                    // Skip positional arguments that have already been specified by name
                    while (position < _positional_arguments.size() && 
                        !_positional_arguments[position]->is_multi_value() &&
                        _positional_arguments[position]->has_value())
                    {
                        ++position;
                    }
 
                    if (position >= _positional_arguments.size())
                        return {parse_error::too_many_arguments};
 
                    auto result = set_argument_value(*_positional_arguments[position], arg);
                    if (!result)
                        return result;
                }
            }
 
            result_type result;
            for_each_argument_in_usage_order([&result](auto &arg)
                {
                    if (arg.is_required())
                    {
                        if (!arg.has_value())
                        {
                            result = {parse_error::missing_required_argument, arg.name()};
                            return false;
                        }
                    }
                    else
                    {
                        arg.apply_default_value();
                    }
 
                    return true;
                });
 
            return result;
        }
 
        template<typename Iterator>
        result_type parse(Iterator begin, Iterator end, const usage_options_type &options)
        {
            auto result = parse(begin, end);
            handle_error(result, options);
            return result;
        }
 
        template<typename Range>
        result_type parse(const Range &range)
        {
            // Using allows ADL.
            using std::begin;
            using std::end;
            return parse(begin(range), end(range));
        }
 
        template<typename Range>
        result_type parse(Range range, const usage_options_type &options)
        {
            auto result = parse(range);
            handle_error(result, options);
            return result;
        }
 
        template<typename T>
        result_type parse(std::initializer_list<T> args)
        {
            return parse(args.begin(), args.end());
        }
 
        template<typename T>
        result_type parse(std::initializer_list<T> args, const usage_options_type &options)
        {
            auto result = parse(args);
            handle_error(result, options);
            return result;
        }
 
        result_type parse(int argc, const CharType *const argv[])
        {
            if (argc < 1)
                return parse<const CharType *>({});
            else
                return parse(argv + 1, argv + argc);
        }
 
        result_type parse(int argc, const CharType *const argv[], const usage_options_type &options)
        {
            auto result = parse(argc, argv);
            handle_error(result, options);
            return result;
        }
 
        void write_usage(const usage_options_type &options = {})
        {
            if (!_storage.description.empty())
            {
                options.output << _storage.description << std::endl << std::endl;
            }
 
            write_usage_syntax(options);
            write_usage_descriptions(options);
        }
 
        template<typename Func>
        bool for_each_argument_in_usage_order(Func f) const
        {
            // First the positional arguments
            for (auto &arg : _positional_arguments)
            {
                auto result = f(*arg);
                if (!result)
                    return result;
            }
 
            // Then required non-positional arguments
            for (auto &arg : _arguments)
            {
                if (arg.second.is_owned() && !arg.second->position() && arg.second->is_required())
                {
                    auto result = f(*arg.second);
                    if (!result)
                        return result;
                }
            }
 
            // Then the optional non-positional arguments
            for (auto &arg : _arguments)
            {
                if (arg.second.is_owned() && !arg.second->position() && !arg.second->is_required())
                {
                    auto result = f(*arg.second);
                    if (!result)
                        return result;
                }
            }
 
            return true;
        }
 
        void on_parsed(on_parsed_callback callback)
        {
            _on_parsed_callback = callback;
        }
 
    private:
        void handle_error(const result_type &result, const usage_options_type &options)
        {
            if (!result)
            {
                // If parsing is cancelled that is not really an error, so we just show usage in
                // that case.
                if (result.error != parse_error::parsing_cancelled)
                {
                    options.error << result.get_error_message(options.error.rdbuf()->getloc()) << std::endl << std::endl;
                }
 
                write_usage(options);
            }
        }
 
        size_t check_prefix(string_view_type argument)
        {
            // Even if the named argument switch is '-', we treat a '-' followed by a digit as a value, because it could denote a negative number.
            if (argument.length() >= 2 && argument[0] == '-' && std::isdigit(argument[1], _storage.locale))
                return 0;
 
            for (auto &prefix : _storage.prefixes)
            {
                if (argument.starts_with(prefix))
                    return prefix.length();
            }
 
            return 0;
        }
 
        template<typename Iterator>
        result_type parse_named_argument(string_view_type arg, Iterator &current, Iterator end, size_t prefix_length)
        {
            string_view_type name;
            string_view_type value;
            bool has_value = false;
 
            auto separator_index = arg.find(_storage.argument_value_separator);
            if (separator_index == string_view_type::npos)
            {
                name = arg.substr(prefix_length);
            }
            else
            {
                name = arg.substr(prefix_length, separator_index - prefix_length);
                value = arg.substr(separator_index + 1);
                has_value = true;
            }
 
            auto it = this->_arguments.find(name);
            if (it == this->_arguments.end())
                return {parse_error::unknown_argument, string_type{name}};
 
            if (!has_value)
            {
                if (it->second->set_switch_value())
                {
                    return post_process_argument(*it->second, {});
                }
 
                auto value_it = current;
                if (_storage.allow_white_space_separator && ++value_it != end)
                {
                    current = value_it;
                    value = *current;
                    // If the next argument looks like an argument name, don't use it as value.
                    has_value = check_prefix(value) == 0;
                }
            }
 
            if (has_value)
            {
                if (!_storage.allow_duplicate_arguments && !it->second->is_multi_value() && it->second->has_value())
                    return {parse_error::duplicate_argument, it->second->name()};
 
                return set_argument_value(*it->second, value);
            }
            else
            {
                return {parse_error::missing_value, it->second->name()};
            }
        }
 
        result_type set_argument_value(argument_base_type &arg, string_view_type value)
        {
            if (!arg.set_value(value, _storage.locale))
                return {parse_error::invalid_value, arg.name()};
 
            return post_process_argument(arg, value);
        }
 
        result_type post_process_argument(argument_base_type &arg, string_view_type value)
        {
            auto action = on_parsed_action::none;
            if (_on_parsed_callback)
                action = _on_parsed_callback(arg, value);
 
            if (action == on_parsed_action::cancel_parsing || 
                (arg.cancel_parsing() && action != on_parsed_action::always_continue))
            {
                return {parse_error::parsing_cancelled, arg.name()};
            }
 
            return {parse_error::none};
        }
 
        void write_usage_syntax(const usage_options_type &options = {})
        {
            auto &stream = options.output;
            stream << reset_indent << set_indent(options.syntax_indent);
            stream << format::ncformat(_storage.locale, options.usage_prefix_format, _storage.command_name);
            for_each_argument_in_usage_order([this, &options, &stream](const auto &arg)
                {
                    auto syntax = _storage.prefixes[0] + arg.name();
                    if (arg.position())
                        syntax = format::ncformat(_storage.locale, options.optional_argument_format, syntax);
 
                    if (!arg.is_switch())
                    {
                        CharType separator = (_storage.allow_white_space_separator && options.use_white_space_value_separator) ? ' ' : _storage.argument_value_separator;
                        auto value = format::ncformat(_storage.locale, options.value_description_format, arg.value_description());
                        syntax += separator + value;
                    }
 
                    if (arg.is_multi_value())
                        syntax += options.multi_value_suffix;
 
                    if (!arg.is_required())
                        syntax = format::ncformat(_storage.locale, options.optional_argument_format, syntax);
 
                    stream << ' ' << syntax;
                    return true;
                });
 
            stream << std::endl << std::endl;
        }
 
        void write_usage_descriptions(const usage_options_type &options = {})
        {
            auto &stream = options.output;
            stream << reset_indent << set_indent(options.argument_description_indent);
            for_each_argument_in_usage_order([this, &options, &stream](const auto &arg)
                {
                    if (arg.description().empty())
                        return true;
 
                    auto value_description = format::ncformat(_storage.locale, options.value_description_format, arg.value_description());
                    if (arg.is_switch())
                        value_description = format::ncformat(_storage.locale, options.optional_argument_format, value_description);
 
                    auto default_value = arg.format_default_value(options, _storage.locale);
 
                    string_type aliases;
                    if (options.include_aliases_in_description && !arg.aliases().empty())
                    {
                        bool first = true;
                        for (const auto &alias : arg.aliases())
                        {
                            if (first)
                                first = false;
                            else
                                aliases += options.alias_separator;
 
                            aliases += _storage.prefixes[0] + alias;
                        }
 
                        aliases = format::ncformat(_storage.locale, options.alias_format, aliases);
                    }
 
                    stream << reset_indent << format::ncformat(_storage.locale, options.argument_description_format,
                        _storage.prefixes[0], arg.name(), value_description, aliases, arg.description(), default_value)
                        << std::endl;
 
                    return true;
                });
        }
 
        storage_type _storage;
 
        // _positional_arguments contains pointers to items owned by _arguments. Since the two
        // have the same lifetime, this is okay.
        std::map<string_type, owned_or_borrowed_ptr<argument_base_type>, string_less> _arguments;
        std::vector<argument_base_type *> _positional_arguments;
        on_parsed_callback _on_parsed_callback;
    };
 
    using command_line_parser = basic_command_line_parser<char>;
    using wcommand_line_parser = basic_command_line_parser<wchar_t>;
 
}
 
#endif