one_of.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 one_of_t : public detail::basic_one_of_t<AR_STRING("One of: "), Params...>
{
    using parent_type = detail::basic_one_of_t<AR_STRING("One of: "), Params...>;
 
    static_assert(boost::mp11::mp_none_of<typename parent_type::children_type,
                                          policy::has_multi_stage_value>::value,
                  "one_of children must not use a multi_stage_value policy");
 
    using variant_type =
        boost::mp11::mp_rename<typename parent_type::basic_value_type, std::variant>;
 
    static_assert(
        !parent_type::template any_phases_v<variant_type, policy::has_validation_phase_method>,
        "one_of does not support policies with validation phases; as it delegates those to its "
        "children");
 
public:
    using typename parent_type::children_type;
    using typename parent_type::policies_type;
 
    using value_type = std::conditional_t<(std::variant_size_v<variant_type> == 1),
                                          std::variant_alternative_t<0, variant_type>,
                                          variant_type>;
 
    template <bool Flatten>
    class help_data_type
    {
    public:
        using label = AR_STRING_SV(parent_type::display_name());
        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 one_of_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
    {
        // We need to wrap the pre_parse_data validator so that we can catch child type mismatches
        // before the caller's validation, otherwise the user can get misleading error messages
        const auto validator = [&](const auto& child, const auto&... parents) {
            using child_type = std::decay_t<decltype(child)>;
 
            auto type_hash = utility::type_hash<child_type>();
            if (last_typeid_) {
                if (type_hash != *last_typeid_) {
                    throw multi_lang_exception{error_code::one_of_selected_type_mismatch,
                                               parsing::node_token_type<one_of_t>()};
                }
            } else {
                last_typeid_ = type_hash;
            }
 
            return pre_parse_data.validator()(child, parents...);
        };
        auto wrapper =
            std::optional<parsing::pre_parse_data<std::decay_t<decltype(validator)>, HasTarget>>{};
        if constexpr (pre_parse_data.has_target) {
            wrapper =
                parsing::pre_parse_data{pre_parse_data.args(), pre_parse_data.target(), validator};
        } else {
            wrapper = parsing::pre_parse_data{pre_parse_data.args(), validator};
        }
 
        auto found = std::optional<parsing::parse_target>{};
        utility::tuple_iterator(
            [&](auto /*i*/, const auto& child) {
                if (!found) {
                    found = child.pre_parse(*wrapper, parents...);
                    if (found) {
                        // There is no requirement to use pre_parse_data validation, so we also
                        // need to manually check here
                        validator(child, parents...);
                    }
                }
            },
            this->children());
 
        return found;
    }
 
private:
    mutable std::optional<std::size_t> last_typeid_;
};
 
template <typename... Params>
[[nodiscard]] constexpr auto one_of(Params... params) noexcept
{
    return one_of_t{std::move(params)...};
}
}  // namespace arg_router::dependency