alias_group.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/dependency/detail.hpp"
#include "arg_router/policy/multi_stage_value.hpp"
 
namespace arg_router::dependency
{
template <typename... Params>
class alias_group_t : public detail::basic_one_of_t<AR_STRING("Alias Group: "), Params...>
{
    using parent_type = detail::basic_one_of_t<AR_STRING("Alias Group: "), Params...>;
 
public:
    using typename parent_type::children_type;
    using typename parent_type::policies_type;
 
    using value_type = boost::mp11::mp_first<typename parent_type::basic_value_type>;
 
    static_assert(
        std::tuple_size_v<boost::mp11::mp_unique<typename parent_type::basic_value_type>> == 1,
        "All children of alias_group must have the same value_type, or use "
        "policy::no_result_value");
 
private:
    template <typename Child>
    struct multi_stage_with_result_and_validation {
        constexpr static auto value =
            policy::has_multi_stage_value_v<Child> && !policy::has_no_result_value_v<Child> &&
            Child::template any_phases_v<value_type, policy::has_validation_phase_method>;
    };
 
public:
    // If any of the children are multi_stage_values, not no_result_value, and have a validation
    // phase; then fail as the policy that implements needs to be moved into this node otherwise
    // they won't be called
    static_assert(
        boost::mp11::mp_none_of<children_type, multi_stage_with_result_and_validation>::value,
        "Multi-stage value supporting alias_group children (e.g. "
        "counting_flag) cannot have a validation phase as they won't be "
        "executed, move the implementing policies into the alias_group");
 
    template <bool Flatten>
    class help_data_type
    {
    public:
        using label =
            decltype(AR_STRING_SV(parent_type::display_name()){} +
                     parent_type::template default_leaf_help_data_type<Flatten>::value_suffix());
        using description = AR_STRING("");
        using children = typename parent_type::template  //
            children_help_data_type<Flatten>::children;
 
        template <typename OwnerNode, typename FilterFn>
        [[nodiscard]] static vector<runtime_help_data> runtime_children(const OwnerNode& owner,
                                                                        FilterFn&& f)
        {
            return parent_type::template children_help_data_type<Flatten>::runtime_children(
                owner,
                std::forward<FilterFn>(f));
        }
    };
 
    constexpr explicit alias_group_t(Params... params) noexcept : parent_type{std::move(params)...}
    {
    }
 
    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
    {
        auto found = std::optional<parsing::parse_target>{};
        utility::tuple_iterator(
            [&](auto /*i*/, const auto& child) {
                if (!found) {
                    found = child.pre_parse(pre_parse_data, parents...);
                }
            },
            this->children());
 
        return found;
    }
};
 
template <typename... Params>
[[nodiscard]] constexpr auto alias_group(Params... params) noexcept
{
    return alias_group_t{std::move(params)...};
}
}  // namespace arg_router::dependency