argument_parser.hpp

Go to the documentation of this file.

// Copyright (c) 2023-2025 Jakub Musiał
// This file is part of the CPP-AP project (https://github.com/SpectraL519/cpp-ap).
// Licensed under the MIT License. See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "argument/default.hpp"
#include "argument/optional.hpp"
#include "argument/positional.hpp"
#include "detail/argument_token.hpp"
#include "detail/concepts.hpp"
#include "version.hpp"
 
#include <algorithm>
#include <format>
#include <iostream>
#include <ranges>
#include <span>
 
#ifdef AP_TESTING
 
namespace ap_testing {
struct argument_parser_test_fixture;
} // namespace ap_testing
 
#endif
 
namespace ap {
 
class argument_parser;
 
namespace detail {
 
void add_default_argument(const argument::default_positional, argument_parser&) noexcept;
void add_default_argument(const argument::default_optional, argument_parser&) noexcept;
 
} // namespace detail
 
class argument_parser {
public:
    argument_parser(const argument_parser&) = delete;
    argument_parser& operator=(const argument_parser&) = delete;
 
    argument_parser() = default;
 
    argument_parser(argument_parser&&) = default;
    argument_parser& operator=(argument_parser&&) = default;
 
    ~argument_parser() = default;
 
    argument_parser& program_name(std::string_view name) noexcept {
        this->_program_name.emplace(name);
        return *this;
    }
 
    argument_parser& program_version(const version& version) noexcept {
        this->_program_version.emplace(version.str());
        return *this;
    }
 
    argument_parser& program_version(std::string_view version) noexcept {
        this->_program_version.emplace(version);
        return *this;
    }
 
    argument_parser& program_description(std::string_view description) noexcept {
        this->_program_description.emplace(description);
        return *this;
    }
 
    argument_parser& verbose(const bool v = true) noexcept {
        this->_verbose = v;
        return *this;
    }
 
    template <detail::c_range_of<argument::default_positional> AR>
    argument_parser& default_positional_arguments(const AR& arg_discriminator_range) noexcept {
        for (const auto arg_discriminator : arg_discriminator_range)
            detail::add_default_argument(arg_discriminator, *this);
        return *this;
    }
 
    argument_parser& default_positional_arguments(
        const std::initializer_list<argument::default_positional> arg_discriminator_list
    ) noexcept {
        return this->default_positional_arguments<>(arg_discriminator_list);
    }
 
    template <detail::c_range_of<argument::default_optional> AR>
    argument_parser& default_optional_arguments(const AR& arg_discriminator_range) noexcept {
        for (const auto arg_discriminator : arg_discriminator_range)
            detail::add_default_argument(arg_discriminator, *this);
        return *this;
    }
 
    argument_parser& default_optional_arguments(
        const std::initializer_list<argument::default_optional> arg_discriminator_list
    ) noexcept {
        return this->default_optional_arguments<>(arg_discriminator_list);
    }
 
    template <detail::c_argument_value_type T = std::string>
    argument::positional<T>& add_positional_argument(const std::string_view primary_name) {
        this->_verify_arg_name_pattern(primary_name);
 
        const detail::argument_name arg_name(std::make_optional<std::string>(primary_name));
        if (this->_is_arg_name_used(arg_name))
            throw invalid_configuration::argument_name_used(arg_name);
 
        this->_positional_args.emplace_back(std::make_unique<argument::positional<T>>(arg_name));
        return static_cast<argument::positional<T>&>(*this->_positional_args.back());
    }
 
    template <detail::c_argument_value_type T = std::string>
    argument::positional<T>& add_positional_argument(
        const std::string_view primary_name, const std::string_view secondary_name
    ) {
        this->_verify_arg_name_pattern(primary_name);
        this->_verify_arg_name_pattern(secondary_name);
 
        const detail::argument_name arg_name{
            std::make_optional<std::string>(primary_name),
            std::make_optional<std::string>(secondary_name)
        };
        if (this->_is_arg_name_used(arg_name))
            throw invalid_configuration::argument_name_used(arg_name);
 
        this->_positional_args.emplace_back(std::make_unique<argument::positional<T>>(arg_name));
        return static_cast<argument::positional<T>&>(*this->_positional_args.back());
    }
 
    template <detail::c_argument_value_type T = std::string>
    argument::optional<T>& add_optional_argument(
        const std::string_view name,
        const detail::argument_name_discriminator name_discr = n_primary
    ) {
        this->_verify_arg_name_pattern(name);
 
        const auto arg_name =
            name_discr == n_primary
                ? detail::
                      argument_name{std::make_optional<std::string>(name), std::nullopt, this->_flag_prefix_char}
                : detail::argument_name{
                      std::nullopt, std::make_optional<std::string>(name), this->_flag_prefix_char
                  };
 
        if (this->_is_arg_name_used(arg_name))
            throw invalid_configuration::argument_name_used(arg_name);
 
        this->_optional_args.push_back(std::make_unique<argument::optional<T>>(arg_name));
        return static_cast<argument::optional<T>&>(*this->_optional_args.back());
    }
 
    template <detail::c_argument_value_type T = std::string>
    argument::optional<T>& add_optional_argument(
        const std::string_view primary_name, const std::string_view secondary_name
    ) {
        this->_verify_arg_name_pattern(primary_name);
        this->_verify_arg_name_pattern(secondary_name);
 
        const detail::argument_name arg_name(
            std::make_optional<std::string>(primary_name),
            std::make_optional<std::string>(secondary_name),
            this->_flag_prefix_char
        );
        if (this->_is_arg_name_used(arg_name))
            throw invalid_configuration::argument_name_used(arg_name);
 
        this->_optional_args.emplace_back(std::make_unique<argument::optional<T>>(arg_name));
        return static_cast<argument::optional<T>&>(*this->_optional_args.back());
    }
 
    template <bool StoreImplicitly = true>
    argument::optional<bool>& add_flag(
        const std::string_view name,
        const detail::argument_name_discriminator name_discr = n_primary
    ) {
        return this->add_optional_argument<bool>(name, name_discr)
            .default_value(not StoreImplicitly)
            .implicit_value(StoreImplicitly)
            .nargs(0ull);
    }
 
    template <bool StoreImplicitly = true>
    argument::optional<bool>& add_flag(
        const std::string_view primary_name, const std::string_view secondary_name
    ) {
        return this->add_optional_argument<bool>(primary_name, secondary_name)
            .default_value(not StoreImplicitly)
            .implicit_value(StoreImplicitly)
            .nargs(0ull);
    }
 
    void parse_args(int argc, char* argv[]) {
        this->parse_args(std::span(argv + 1, static_cast<std::size_t>(argc - 1)));
    }
 
    template <detail::c_range_of<std::string, detail::type_validator::convertible> AR>
    void parse_args(const AR& argv_rng) {
        this->_validate_argument_configuration();
 
        std::vector<std::string> unknown_args;
        this->_parse_args_impl(this->_tokenize(argv_rng), unknown_args);
 
        if (not unknown_args.empty())
            throw parsing_failure::argument_deduction_failure(unknown_args);
 
        if (not this->_are_required_args_bypassed()) {
            this->_verify_required_args();
            this->_verify_nvalues();
        }
    }
 
    void try_parse_args(int argc, char* argv[]) {
        this->try_parse_args(std::span(argv + 1, static_cast<std::size_t>(argc - 1)));
    }
 
    template <detail::c_range_of<std::string, detail::type_validator::convertible> AR>
    void try_parse_args(const AR& argv_rng) {
        try {
            this->parse_args(argv_rng);
        }
        catch (const ap::argument_parser_exception& err) {
            std::cerr << "[ERROR] : " << err.what() << std::endl << *this << std::endl;
            std::exit(EXIT_FAILURE);
        }
    }
 
    std::vector<std::string> parse_known_args(int argc, char* argv[]) {
        return this->parse_known_args(std::span(argv + 1, static_cast<std::size_t>(argc - 1)));
    }
 
    template <detail::c_range_of<std::string, detail::type_validator::convertible> AR>
    std::vector<std::string> parse_known_args(const AR& argv_rng) {
        this->_validate_argument_configuration();
 
        std::vector<std::string> unknown_args;
        this->_parse_args_impl(this->_tokenize(argv_rng), unknown_args, false);
 
        if (not this->_are_required_args_bypassed()) {
            this->_verify_required_args();
            this->_verify_nvalues();
        }
 
        return unknown_args;
    }
 
    std::vector<std::string> try_parse_known_args(int argc, char* argv[]) {
        return this->try_parse_known_args(std::span(argv + 1, static_cast<std::size_t>(argc - 1)));
    }
 
    template <detail::c_range_of<std::string, detail::type_validator::convertible> AR>
    std::vector<std::string> try_parse_known_args(const AR& argv_rng) {
        try {
            return this->parse_known_args(argv_rng);
        }
        catch (const ap::argument_parser_exception& err) {
            std::cerr << "[ERROR] : " << err.what() << std::endl << *this << std::endl;
            std::exit(EXIT_FAILURE);
        }
    }
 
    // clang-format off
 
    [[deprecated("The default help argument now uses the `print_config` on-flag action")]]
    void handle_help_action() const noexcept {
        if (this->value<bool>("help")) {
            std::cout << *this << std::endl;
            std::exit(EXIT_SUCCESS);
        }
    }
 
    // clang-format on
 
    [[nodiscard]] bool has_value(std::string_view arg_name) const noexcept {
        const auto arg_opt = this->_get_argument(arg_name);
        return arg_opt ? arg_opt->get().has_value() : false;
    }
 
    [[nodiscard]] std::size_t count(std::string_view arg_name) const noexcept {
        const auto arg_opt = this->_get_argument(arg_name);
        return arg_opt ? arg_opt->get().count() : 0ull;
    }
 
    template <detail::c_argument_value_type T = std::string>
    [[nodiscard]] T value(std::string_view arg_name) const {
        const auto arg_opt = this->_get_argument(arg_name);
        if (not arg_opt)
            throw lookup_failure::argument_not_found(arg_name);
 
        const auto& arg_value = arg_opt->get().value();
        try {
            return std::any_cast<T>(arg_value);
        }
        catch (const std::bad_any_cast&) {
            throw type_error::invalid_value_type<T>(arg_opt->get().name());
        }
    }
 
    template <detail::c_argument_value_type T = std::string, std::convertible_to<T> U>
    [[nodiscard]] T value_or(std::string_view arg_name, U&& fallback_value) const {
        const auto arg_opt = this->_get_argument(arg_name);
        if (not arg_opt)
            throw lookup_failure::argument_not_found(arg_name);
 
        try {
            const auto& arg_value = arg_opt->get().value();
            return std::any_cast<T>(arg_value);
        }
        catch (const std::logic_error&) {
            // positional: no value parsed
            // optional: no value parsed + no predefined value
            return T{std::forward<U>(fallback_value)};
        }
        catch (const std::bad_any_cast&) {
            throw type_error::invalid_value_type<T>(arg_opt->get().name());
        }
    }
 
    template <detail::c_argument_value_type T = std::string>
    [[nodiscard]] std::vector<T> values(std::string_view arg_name) const {
        const auto arg_opt = this->_get_argument(arg_name);
        if (not arg_opt)
            throw lookup_failure::argument_not_found(arg_name);
 
        const auto& arg = arg_opt->get();
 
        try {
            if (not arg.has_parsed_values() and arg.has_value())
                return std::vector<T>{std::any_cast<T>(arg.value())};
 
            std::vector<T> values;
            // TODO: use std::ranges::to after transition to C++23
            std::ranges::copy(
                std::views::transform(
                    arg.values(), [](const std::any& value) { return std::any_cast<T>(value); }
                ),
                std::back_inserter(values)
            );
            return values;
        }
        catch (const std::bad_any_cast&) {
            throw type_error::invalid_value_type<T>(arg.name());
        }
    }
 
    void print_config(const bool verbose, std::ostream& os = std::cout) const noexcept {
        if (this->_program_name) {
            os << "Program: " << this->_program_name.value();
            if (this->_program_version)
                os << " (" << this->_program_version.value() << ')';
            os << '\n';
        }
 
        if (this->_program_description)
            os << '\n'
               << std::string(this->_indent_width, ' ') << this->_program_description.value()
               << '\n';
 
        if (not this->_positional_args.empty()) {
            os << "\nPositional arguments:\n";
            this->_print(os, this->_positional_args, verbose);
        }
 
        if (not this->_optional_args.empty()) {
            os << "\nOptional arguments:\n";
            this->_print(os, this->_optional_args, verbose);
        }
    }
 
    friend std::ostream& operator<<(std::ostream& os, const argument_parser& parser) noexcept {
        parser.print_config(parser._verbose, os);
        return os;
    }
 
#ifdef AP_TESTING
    friend struct ::ap_testing::argument_parser_test_fixture;
#endif
 
private:
    using arg_ptr_t = std::unique_ptr<detail::argument_base>;
    using arg_ptr_list_t = std::vector<arg_ptr_t>;
    using arg_ptr_list_iter_t = typename arg_ptr_list_t::iterator;
    using arg_ptr_opt_t = detail::uptr_opt_t<detail::argument_base>;
    using arg_opt_t = std::optional<std::reference_wrapper<detail::argument_base>>;
    using const_arg_opt_t = std::optional<std::reference_wrapper<const detail::argument_base>>;
 
    using arg_token_list_t = std::vector<detail::argument_token>;
    using arg_token_list_iterator_t = typename arg_token_list_t::const_iterator;
 
    void _verify_arg_name_pattern(const std::string_view arg_name) const {
        if (arg_name.empty())
            throw invalid_configuration::invalid_argument_name(
                arg_name, "An argument name cannot be empty."
            );
 
        if (detail::contains_whitespaces(arg_name))
            throw invalid_configuration::invalid_argument_name(
                arg_name, "An argument name cannot contain whitespaces."
            );
 
        if (arg_name.front() == this->_flag_prefix_char)
            throw invalid_configuration::invalid_argument_name(
                arg_name,
                std::format(
                    "An argument name cannot begin with a flag prefix character ({}).",
                    this->_flag_prefix_char
                )
            );
 
        if (std::isdigit(arg_name.front()))
            throw invalid_configuration::invalid_argument_name(
                arg_name, "An argument name cannot begin with a digit."
            );
    }
 
    [[nodiscard]] auto _name_match_predicate(
        const std::string_view arg_name,
        const detail::argument_name::match_type m_type = detail::argument_name::m_any
    ) const noexcept {
        return [=](const arg_ptr_t& arg) { return arg->name().match(arg_name, m_type); };
    }
 
    [[nodiscard]] auto _name_match_predicate(
        const detail::argument_name& arg_name,
        const detail::argument_name::match_type m_type = detail::argument_name::m_any
    ) const noexcept {
        return [&arg_name, m_type](const arg_ptr_t& arg) {
            return arg->name().match(arg_name, m_type);
        };
    }
 
    [[nodiscard]] bool _is_arg_name_used(
        const detail::argument_name& arg_name,
        const detail::argument_name::match_type m_type = detail::argument_name::m_any
    ) const noexcept {
        const auto predicate = this->_name_match_predicate(arg_name, m_type);
 
        if (std::ranges::find_if(this->_positional_args, predicate) != this->_positional_args.end())
            return true;
 
        if (std::ranges::find_if(this->_optional_args, predicate) != this->_optional_args.end())
            return true;
 
        return false;
    }
 
    void _validate_argument_configuration() const {
        // step 1
        const_arg_opt_t non_required_arg = std::nullopt;
        for (const auto& arg : this->_positional_args) {
            if (not arg->is_required()) {
                non_required_arg = std::ref(*arg);
                continue;
            }
 
            if (non_required_arg and arg->is_required())
                throw invalid_configuration::positional::required_after_non_required(
                    arg->name(), non_required_arg->get().name()
                );
        }
    }
 
    template <detail::c_sized_range_of<std::string_view, detail::type_validator::convertible> AR>
    [[nodiscard]] arg_token_list_t _tokenize(const AR& arg_range) {
        const auto n_args = std::ranges::size(arg_range);
        if (n_args == 0ull)
            return arg_token_list_t{};
 
        arg_token_list_t toks;
        toks.reserve(n_args);
        std::ranges::for_each(
            arg_range, std::bind_front(&argument_parser::_tokenize_arg, this, std::ref(toks))
        );
        return toks;
    }
 
    void _tokenize_arg(arg_token_list_t& toks, const std::string_view arg_value) {
        auto tok = this->_build_token(arg_value);
 
        if (not tok.is_flag_token() or this->_validate_flag_token(tok)) {
            toks.emplace_back(std::move(tok));
            return;
        }
 
        // invalid flag - check for compound secondary flag
        const auto compound_toks = this->_try_split_compound_flag(tok);
        if (not compound_toks.empty()) { // not a valid compound flag
            toks.insert(toks.end(), compound_toks.begin(), compound_toks.end());
            return;
        }
 
#ifdef AP_UNKNOWN_FLAGS_AS_VALUES
        toks.emplace_back(detail::argument_token::t_value, std::string(arg_value));
#else
        toks.emplace_back(std::move(tok));
#endif
    }
 
    [[nodiscard]] detail::argument_token _build_token(const std::string_view arg_value
    ) const noexcept {
        if (detail::contains_whitespaces(arg_value))
            return {.type = detail::argument_token::t_value, .value = std::string(arg_value)};
 
        if (arg_value.starts_with(this->_flag_prefix))
            return {
                .type = detail::argument_token::t_flag_primary,
                .value = std::string(arg_value.substr(this->_primary_flag_prefix_length))
            };
 
        if (arg_value.starts_with(this->_flag_prefix_char))
            return {
                .type = detail::argument_token::t_flag_secondary,
                .value = std::string(arg_value.substr(this->_secondary_flag_prefix_length))
            };
 
        return {.type = detail::argument_token::t_value, .value = std::string(arg_value)};
    }
 
    [[nodiscard]] bool _validate_flag_token(detail::argument_token& tok) noexcept {
        const auto opt_arg_it = this->_find_opt_arg(tok);
        if (opt_arg_it == this->_optional_args.end())
            return false;
 
        tok.arg.emplace(*opt_arg_it);
        return true;
    }
 
    [[nodiscard]] std::vector<detail::argument_token> _try_split_compound_flag(
        const detail::argument_token& tok
    ) noexcept {
        std::vector<detail::argument_token> compound_toks;
        compound_toks.reserve(tok.value.size());
 
        if (tok.type != detail::argument_token::t_flag_secondary)
            return compound_toks;
 
        for (const char c : tok.value) {
            detail::argument_token ctok{
                detail::argument_token::t_flag_secondary, std::string(1ull, c)
            };
            if (not this->_validate_flag_token(ctok)) {
                compound_toks.clear();
                return compound_toks;
            }
            compound_toks.emplace_back(std::move(ctok));
        }
 
        return compound_toks;
    }
 
    [[nodiscard]] std::string _unstripped_token_value(const detail::argument_token& tok
    ) const noexcept {
        switch (tok.type) {
        case detail::argument_token::t_flag_primary:
            return std::format("{}{}", this->_flag_prefix, tok.value);
        case detail::argument_token::t_flag_secondary:
            return std::format("{}{}", this->_flag_prefix_char, tok.value);
        default:
            return tok.value;
        }
    }
 
    void _parse_args_impl(
        const arg_token_list_t& arg_tokens,
        std::vector<std::string>& unknown_args,
        const bool handle_unknown = true
    ) {
        arg_token_list_iterator_t token_it = arg_tokens.begin();
        this->_parse_positional_args(token_it, arg_tokens.end());
        this->_parse_optional_args(token_it, arg_tokens.end(), unknown_args, handle_unknown);
    }
 
    void _parse_positional_args(
        arg_token_list_iterator_t& token_it, const arg_token_list_iterator_t& tokens_end
    ) noexcept {
        for (const auto& pos_arg : this->_positional_args) {
            if (token_it == tokens_end)
                return;
 
            if (token_it->type != detail::argument_token::t_value)
                return;
 
            pos_arg->set_value(token_it->value);
            ++token_it;
        }
    }
 
    void _parse_optional_args(
        arg_token_list_iterator_t& token_it,
        const arg_token_list_iterator_t& tokens_end,
        std::vector<std::string>& unknown_args,
        const bool handle_unknown = true
    ) {
        arg_ptr_opt_t curr_opt_arg;
 
        while (token_it != tokens_end) {
            switch (token_it->type) {
            case detail::argument_token::t_flag_primary:
                [[fallthrough]];
            case detail::argument_token::t_flag_secondary: {
                if (not token_it->is_valid_flag_token()) {
                    if (handle_unknown) {
                        throw parsing_failure::unknown_argument(
                            this->_unstripped_token_value(*token_it)
                        );
                    }
                    else {
                        unknown_args.emplace_back(this->_unstripped_token_value(*token_it));
                        curr_opt_arg.reset();
                        break;
                    }
                }
 
                if (token_it->arg->get()->mark_used())
                    curr_opt_arg = token_it->arg;
                else
                    curr_opt_arg.reset();
 
                break;
            }
            case detail::argument_token::t_value: {
                if (not curr_opt_arg) {
                    unknown_args.emplace_back(token_it->value);
                    break;
                }
 
                if (not curr_opt_arg->get()->set_value(token_it->value))
                    curr_opt_arg.reset();
 
                break;
            }
            }
 
            ++token_it;
        }
    }
 
    [[nodiscard]] bool _are_required_args_bypassed() const noexcept {
        // TODO: use std::views::join after the transition to C++23
        return std::ranges::any_of(
                   this->_positional_args,
                   [](const arg_ptr_t& arg) {
                       return arg->is_used() and arg->bypass_required_enabled();
                   }
               )
            or std::ranges::any_of(this->_optional_args, [](const arg_ptr_t& arg) {
                   return arg->is_used() and arg->bypass_required_enabled();
               });
    }
 
    void _verify_required_args() const {
        // TODO: use std::views::join after the transition to C++23
        for (const auto& arg : this->_positional_args)
            if (arg->is_required() and not arg->has_value())
                throw parsing_failure::required_argument_not_parsed(arg->name());
 
        for (const auto& arg : this->_optional_args)
            if (arg->is_required() and not arg->has_value())
                throw parsing_failure::required_argument_not_parsed(arg->name());
    }
 
    void _verify_nvalues() const {
        // TODO: use std::views::join after the transition to C++23
        for (const auto& arg : this->_positional_args)
            if (const auto nv_ord = arg->nvalues_ordering(); not std::is_eq(nv_ord))
                throw parsing_failure::invalid_nvalues(arg->name(), nv_ord);
 
        for (const auto& arg : this->_optional_args)
            if (const auto nv_ord = arg->nvalues_ordering(); not std::is_eq(nv_ord))
                throw parsing_failure::invalid_nvalues(arg->name(), nv_ord);
    }
 
    arg_opt_t _get_argument(std::string_view arg_name) const noexcept {
        const auto predicate = this->_name_match_predicate(arg_name);
 
        if (auto pos_arg_it = std::ranges::find_if(this->_positional_args, predicate);
            pos_arg_it != this->_positional_args.end()) {
            return std::ref(**pos_arg_it);
        }
 
        if (auto opt_arg_it = std::ranges::find_if(this->_optional_args, predicate);
            opt_arg_it != this->_optional_args.end()) {
            return std::ref(**opt_arg_it);
        }
 
        return std::nullopt;
    }
 
    [[nodiscard]] arg_ptr_list_iter_t _find_opt_arg(const detail::argument_token& flag_tok
    ) noexcept {
        switch (flag_tok.type) {
        case detail::argument_token::t_flag_primary:
            return std::ranges::find(this->_optional_args, flag_tok.value, [](const auto& arg_ptr) {
                return arg_ptr->name().primary;
            });
        case detail::argument_token::t_flag_secondary:
            return std::ranges::find(this->_optional_args, flag_tok.value, [](const auto& arg_ptr) {
                return arg_ptr->name().secondary;
            });
        default:
            return this->_optional_args.end();
        }
    }
 
    void _print(std::ostream& os, const arg_ptr_list_t& args, const bool verbose) const noexcept {
        auto visible_args =
            std::views::filter(args, [](const auto& arg) { return not arg->is_hidden(); });
 
        if (verbose) {
            for (const auto& arg : visible_args)
                os << '\n' << arg->desc(verbose).get(this->_indent_width) << '\n';
        }
        else {
            std::vector<detail::argument_descriptor> descriptors;
            descriptors.reserve(args.size());
 
            for (const auto& arg : visible_args)
                descriptors.emplace_back(arg->desc(verbose));
 
            std::size_t max_arg_name_length = 0ull;
            for (const auto& desc : descriptors)
                max_arg_name_length = std::max(max_arg_name_length, desc.name.length());
 
            for (const auto& desc : descriptors)
                os << '\n' << desc.get_basic(this->_indent_width, max_arg_name_length);
 
            os << '\n';
        }
    }
 
    std::optional<std::string> _program_name;
    std::optional<std::string> _program_version;
    std::optional<std::string> _program_description;
    bool _verbose = false;
 
    arg_ptr_list_t _positional_args;
    arg_ptr_list_t _optional_args;
 
    static constexpr uint8_t _primary_flag_prefix_length = 2u;
    static constexpr uint8_t _secondary_flag_prefix_length = 1u;
    static constexpr char _flag_prefix_char = '-';
    static constexpr std::string_view _flag_prefix = "--";
    static constexpr uint8_t _indent_width = 2;
};
 
namespace detail {
 
inline void add_default_argument(
    const argument::default_positional arg_discriminator, argument_parser& arg_parser
) noexcept {
    switch (arg_discriminator) {
    case argument::default_positional::input:
        arg_parser.add_positional_argument("input")
            .action<action_type::observe>(action::check_file_exists())
            .help("Input file path");
        break;
 
    case argument::default_positional::output:
        arg_parser.add_positional_argument("output").help("Output file path");
        break;
    }
}
 
inline void add_default_argument(
    const argument::default_optional arg_discriminator, argument_parser& arg_parser
) noexcept {
    switch (arg_discriminator) {
    case argument::default_optional::help:
        arg_parser.add_flag("help", "h")
            .action<action_type::on_flag>(action::print_config(arg_parser, EXIT_SUCCESS))
            .nargs(0ull)
            .help("Display the help message");
        break;
 
    case argument::default_optional::input:
        arg_parser.add_optional_argument("input", "i")
            .required()
            .nargs(1ull)
            .action<action_type::observe>(action::check_file_exists())
            .help("Input file path");
        break;
 
    case argument::default_optional::output:
        arg_parser.add_optional_argument("output", "o").required().nargs(1).help("Output file path");
        break;
 
    case argument::default_optional::multi_input:
        arg_parser.add_optional_argument("input", "i")
            .required()
            .nargs(ap::nargs::at_least(1ull))
            .action<action_type::observe>(action::check_file_exists())
            .help("Input files paths");
        break;
 
    case argument::default_optional::multi_output:
        arg_parser.add_optional_argument("output", "o")
            .required()
            .nargs(ap::nargs::at_least(1ull))
            .help("Output files paths");
        break;
    }
}
 
} // namespace detail
 
} // namespace ap