positional_arg.hpp

// Copyright (C) 2022-2023 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/multi_arg_base.hpp"
#include "arg_router/policy/description.hpp"
#include "arg_router/policy/display_name.hpp"
#include "arg_router/utility/string_to_policy.hpp"
 
namespace arg_router
{
template <typename T, typename... Policies>
class positional_arg_t : public multi_arg_base_t<T, 0, Policies...>
{
    using parent_type = multi_arg_base_t<T, 0, Policies...>;
 
    static_assert(traits::has_display_name_method_v<positional_arg_t>,
                  "Positional arg must have a display name policy");
    static_assert(!traits::has_long_name_method_v<positional_arg_t>,
                  "Positional arg must not have a long name policy");
    static_assert(!traits::has_short_name_method_v<positional_arg_t>,
                  "Positional arg must not have a short name policy");
    static_assert(!traits::has_none_name_method_v<positional_arg_t>,
                  "Positional arg must not have a none name policy");
 
public:
    using typename parent_type::policies_type;
 
    using value_type = T;
 
    template <bool Flatten>
    class help_data_type
    {
        [[nodiscard]] constexpr static auto label_generator() noexcept
        {
            constexpr auto name_index =
                boost::mp11::mp_find_if<policies_type, traits::has_display_name_method>::value;
            using name_type = typename std::tuple_element_t<name_index, policies_type>::string_type;
 
            return AR_STRING("<"){} + name_type{} + AR_STRING("> "){} +
                   parent_type::template default_leaf_help_data_type<Flatten>::count_suffix();
        }
 
    public:
        using label = std::decay_t<decltype(label_generator())>;
        using description =
            typename parent_type::template default_leaf_help_data_type<Flatten>::description;
        using children = std::tuple<>;
    };
 
    constexpr explicit positional_arg_t(Policies... policies) noexcept :
        parent_type{std::move(policies)...}
    {
    }
 
    template <typename Validator, bool HasTarget, typename... Parents>
    [[nodiscard]] std::optional<parsing::parse_target> pre_parse(
        parsing::pre_parse_data<Validator, HasTarget> pre_parse_data,
        const Parents&... parents) const
    {
        return parent_type::pre_parse(pre_parse_data, *this, parents...);
    }
 
    template <typename... Parents>
    [[nodiscard]] value_type parse(parsing::parse_target target, const Parents&... parents) const
    {
        return parent_type::parse(target, *this, parents...);
    }
 
private:
    static_assert(!parent_type::template any_phases_v<value_type, policy::has_routing_phase_method>,
                  "Positional arg does not support policies with routing phases "
                  "(e.g. router)");
};
 
template <typename T, typename... Policies>
[[nodiscard]] constexpr auto positional_arg(Policies... policies) noexcept
{
    return std::apply(
        [](auto... converted_policies) {
            return positional_arg_t<T, std::decay_t<decltype(converted_policies)>...>{
                std::move(converted_policies)...};
        },
        utility::string_to_policy::convert<
            utility::string_to_policy::first_text_mapper<policy::display_name_t>,
            utility::string_to_policy::second_text_mapper<policy::description_t>>(
            std::move(policies)...));
}
}  // namespace arg_router