tree_node.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/algorithm.hpp"
#include "arg_router/config.hpp"
#include "arg_router/list.hpp"
#include "arg_router/parsing/global_parser.hpp"
#include "arg_router/parsing/parsing.hpp"
#include "arg_router/parsing/pre_parse_data.hpp"
#include "arg_router/policy/min_max_count.hpp"
#include "arg_router/policy/policy.hpp"
#include "arg_router/utility/compile_time_string.hpp"
#include "arg_router/utility/tuple_iterator.hpp"
 
namespace arg_router
{
template <typename... Params>
class tree_node :
    public traits::unpack_and_derive<  //
        boost::mp11::mp_filter<policy::is_policy, std::tuple<std::decay_t<Params>...>>>
{
    template <typename LHS, typename RHS>
    struct priority_order {
        template <typename T>
        struct get_priority_or_default {
            constexpr static std::size_t value = []() {
                if constexpr (policy::has_priority_v<T>) {
                    return T::priority;
                } else {
                    return 0;
                }
            }();
        };
 
        constexpr static auto value =
            get_priority_or_default<LHS>::value > get_priority_or_default<RHS>::value;
    };
 
public:
    using parameters_type = std::tuple<std::decay_t<Params>...>;
 
    using policies_type = boost::mp11::mp_filter<policy::is_policy, parameters_type>;
 
    using priority_ordered_policies_type = boost::mp11::mp_sort<policies_type, priority_order>;
 
    using children_type = boost::mp11::mp_filter<
        is_tree_node,
        std::decay_t<decltype(list_expander(std::declval<std::decay_t<Params>>()...))>>;
 
    static_assert(
        (std::tuple_size_v<children_type> + std::tuple_size_v<policies_type>) ==
            std::tuple_size_v<
                std::decay_t<decltype(list_expander(std::declval<std::decay_t<Params>>()...))>>,
        "tree_node constructor can only accept other tree_nodes and policies");
 
    constexpr static auto is_named = traits::has_short_name_method_v<tree_node> ||
                                     traits::has_long_name_method_v<tree_node> ||
                                     traits::has_none_name_method_v<tree_node>;
 
    template <template <typename...> typename PolicyChecker, typename... Args>
    struct phase_finder {
        using finder = boost::mp11::mp_bind<PolicyChecker, boost::mp11::_1, Args...>;
 
        using type =
            boost::mp11::mp_eval_if_c<boost::mp11::mp_find_if_q<policies_type, finder>::value ==
                                          std::tuple_size_v<policies_type>,
                                      void,
                                      boost::mp11::mp_at,
                                      policies_type,
                                      boost::mp11::mp_find_if_q<policies_type, finder>>;
    };
 
    template <template <typename...> typename PolicyChecker, typename... Args>
    using phase_finder_t = typename phase_finder<PolicyChecker, Args...>::type;
 
    template <typename ValueType, template <typename...> typename... PolicyCheckers>
    class any_phases
    {
        template <template <typename...> typename PolicyChecker>
        struct checker {
            constexpr static bool value = []() {
                // This is shonky but I can't think of an easy arity test for a class template
                if constexpr (std::tuple_size_v<policies_type> == 0) {
                    return false;
                } else if constexpr (boost::mp11::mp_valid<PolicyChecker,
                                                           boost::mp11::mp_first<policies_type>,
                                                           ValueType>::value) {
                    return !std::is_void_v<phase_finder_t<PolicyChecker, ValueType>>;
                } else {
                    return !std::is_void_v<phase_finder_t<PolicyChecker>>;
                }
            }();
        };
 
    public:
        constexpr static bool value = boost::mp11::mp_any_of<std::tuple<checker<PolicyCheckers>...>,
                                                             boost::mp11::mp_to_bool>::value;
    };
 
    template <typename ValueType, template <typename...> typename... PolicyCheckers>
    constexpr static bool any_phases_v = any_phases<ValueType, PolicyCheckers...>::value;
 
    [[nodiscard]] children_type& children() noexcept { return children_; }
 
    [[nodiscard]] constexpr const children_type& children() const noexcept { return children_; }
 
protected:
    template <bool Flatten>
    class default_leaf_help_data_type
    {
        template <typename Child>
        using child_help_getter = typename Child::template help_data_type<Flatten>;
 
        template <typename Child>
        using child_help = boost::mp11::
            mp_eval_if_c<!traits::has_help_data_type_v<Child>, void, child_help_getter, Child>;
 
        constexpr static auto num_policies = std::tuple_size_v<policies_type>;
 
    public:
        [[nodiscard]] constexpr static auto value_suffix() noexcept
        {
            constexpr auto has_min_value = traits::has_minimum_value_method_v<tree_node>;
            constexpr auto has_max_value = traits::has_maximum_value_method_v<tree_node>;
 
            if constexpr (has_min_value || has_max_value) {
                // This pointless-looking way of invoking a lambda and providing a null tree_node
                // type is all to get round an MSVC bug whereby the false constexpr if branch was
                // being evaluated
                constexpr auto min_value = [](auto* type_ptr) {
                    using node_type = std::remove_pointer_t<decltype(type_ptr)>;
 
                    if constexpr (has_min_value) {
                        constexpr auto value = node_type::minimum_value();
                        return utility::convert_integral_to_cts_t<static_cast<
                            traits::underlying_type_t<std::decay_t<decltype(value)>>>(value)>{};
                    } else {
                        // If we have got this far, then we must have a maximum value, we can use
                        // that type to determine if the lowest bound is 0 or -N depending on
                        // whether or not the type is signed
                        using max_value_type = traits::underlying_type_t<
                            std::decay_t<decltype(node_type::maximum_value())>>;
                        if constexpr (std::is_unsigned_v<max_value_type>) {
                            return AR_STRING("0"){};
                        } else {
                            return AR_STRING("-N"){};
                        }
                    }
                }(static_cast<tree_node*>(nullptr));
 
                constexpr auto max_value = [](auto* type_ptr) {
                    using node_type = std::remove_pointer_t<decltype(type_ptr)>;
 
                    if constexpr (has_max_value) {
                        constexpr auto value = node_type::maximum_value();
                        return utility::convert_integral_to_cts_t<static_cast<
                            traits::underlying_type_t<std::decay_t<decltype(value)>>>(value)>{};
                    } else {
                        return AR_STRING("N"){};
                    }
                }(static_cast<tree_node*>(nullptr));
 
                return AR_STRING("<"){} + min_value + AR_STRING("-"){} + max_value +
                       AR_STRING(">"){};
            } else {
                return AR_STRING(""){};
            }
        }
 
        [[nodiscard]] constexpr static auto value_separator_suffix()
        {
            [[maybe_unused]] constexpr bool fixed_count_of_one = []() {
                if constexpr (traits::has_minimum_count_method_v<tree_node> &&
                              traits::has_maximum_count_method_v<tree_node>) {
                    return (tree_node::minimum_count() == tree_node::maximum_count()) &&
                           (tree_node::minimum_count() == 1);
                }
 
                return false;
            }();
 
            [[maybe_unused]] constexpr auto value_str = []() {
                constexpr auto min_max_str = value_suffix();
                if constexpr (std::is_same_v<std::decay_t<decltype(min_max_str)>, AR_STRING("")>) {
                    return AR_STRING("<Value>"){};
                } else {
                    return min_max_str;
                }
            }();
 
            [[maybe_unused]] constexpr auto has_separator =
                boost::mp11::mp_find_if<policies_type, traits::has_value_separator_method>::value !=
                num_policies;
 
            if constexpr (has_separator) {
                return AR_STRING_SV(tree_node::value_separator()){} + value_str;
            } else if constexpr (fixed_count_of_one) {
                return AR_STRING(" "){} + value_str;
            } else {
                return AR_STRING(""){};
            }
        }
 
        [[nodiscard]] constexpr static auto label_generator() noexcept
        {
            [[maybe_unused]] constexpr auto has_long_name =
                boost::mp11::mp_find_if<policies_type, traits::has_long_name_method>::value !=
                num_policies;
            [[maybe_unused]] constexpr auto has_short_name =
                boost::mp11::mp_find_if<policies_type, traits::has_short_name_method>::value !=
                num_policies;
            [[maybe_unused]] constexpr auto has_none_name =
                boost::mp11::mp_find_if<policies_type, traits::has_none_name_method>::value !=
                num_policies;
 
            if constexpr (has_long_name && has_short_name) {
                return AR_STRING_SV(config::long_prefix){} +
                       AR_STRING_SV(tree_node::long_name()){} + AR_STRING(","){} +
                       AR_STRING_SV(config::short_prefix){} +
                       AR_STRING_SV(tree_node::short_name()){} + value_separator_suffix();
            } else if constexpr (has_long_name) {
                return AR_STRING_SV(config::long_prefix){} +
                       AR_STRING_SV(tree_node::long_name()){} + value_separator_suffix();
            } else if constexpr (has_short_name) {
                return AR_STRING_SV(config::short_prefix){} +
                       AR_STRING_SV(tree_node::short_name()){} + value_separator_suffix();
            } else if constexpr (has_none_name) {
                return AR_STRING_SV(tree_node::none_name()){} + value_separator_suffix();
            } else {
                return AR_STRING(""){};
            }
        }
 
        [[nodiscard]] constexpr static auto description_generator() noexcept
        {
            [[maybe_unused]] constexpr auto has_description =
                boost::mp11::mp_find_if<policies_type, traits::has_description_method>::value !=
                num_policies;
 
            if constexpr (has_description) {
                return AR_STRING_SV(tree_node::description()){};
            } else {
                return AR_STRING(""){};
            }
        }
 
        [[nodiscard]] constexpr static auto count_suffix() noexcept
        {
            [[maybe_unused]] constexpr bool fixed_count = []() {
                if constexpr (traits::has_minimum_count_method_v<tree_node> &&
                              traits::has_maximum_count_method_v<tree_node>) {
                    return tree_node::minimum_count() == tree_node::maximum_count();
                }
 
                return false;
            }();
 
            constexpr auto prefix = AR_STRING("["){};
 
            if constexpr (fixed_count) {
                return prefix + utility::convert_integral_to_cts_t<tree_node::minimum_count()>{} +
                       AR_STRING("]"){};
            } else {
                constexpr auto min_count = []() {
                    if constexpr (traits::has_minimum_count_method_v<tree_node>) {
                        return utility::convert_integral_to_cts_t<tree_node::minimum_count()>{};
                    } else {
                        return AR_STRING("0"){};
                    }
                }();
 
                constexpr auto max_count = []() {
                    if constexpr (traits::has_maximum_count_method_v<tree_node>) {
                        if constexpr (tree_node::maximum_count() ==
                                      decltype(policy::min_count<0>)::maximum_count()) {
                            return AR_STRING("N"){};
                        } else {
                            return utility::convert_integral_to_cts_t<tree_node::maximum_count()>{};
                        }
                    } else {
                        return AR_STRING("N"){};
                    }
                }();
 
                return prefix + min_count + AR_STRING(","){} + max_count + AR_STRING("]"){};
            }
        }
 
        template <typename OwnerNode, typename FilterFn>
        [[nodiscard]] static vector<runtime_help_data> runtime_children(const OwnerNode& owner,
                                                                        FilterFn&& f)
        {
            auto result = vector<runtime_help_data>{};
            utility::tuple_iterator(
                [&](auto, auto& child) {
                    using child_type = std::decay_t<decltype(child)>;
                    if constexpr (traits::has_help_data_type_v<child_type>) {
                        using child_help_data_type =
                            typename child_type::template help_data_type<Flatten>;
 
                        static_assert(child_help_data_type::description::get().find('\t') ==
                                          std::string_view::npos,
                                      "Help descriptions cannot contain tabs");
 
                        if (f(child)) {
                            auto child_result = vector<runtime_help_data>{};
                            if constexpr (traits::has_runtime_children_method_v<
                                              child_help_data_type>) {
                                child_result = child_help_data_type::runtime_children(child, f);
                            } else {
                                child_result = runtime_children(child, f);
                            }
 
                            result.push_back(
                                runtime_help_data{child_help_data_type::label::get(),
                                                  child_help_data_type::description::get(),
                                                  std::move(child_result)});
                        }
                    }
                },
                owner.children());
            return result;
        }
 
        using all_children_help =
            boost::mp11::mp_remove_if<boost::mp11::mp_transform<child_help, children_type>,
                                      std::is_void>;
 
        using label = std::decay_t<decltype(label_generator())>;
 
        using description = std::decay_t<decltype(description_generator())>;
 
        using children = std::tuple<>;
    };
 
    constexpr explicit tree_node(Params... params) noexcept :
        traits::unpack_and_derive<policies_type>{common_filter<policy::is_policy>(params...)},
        children_(common_filter_tuple<is_tree_node>(list_expander(std::move(params)...)))
    {
    }
 
    template <typename Validator, bool HasTarget, typename Node, typename... Parents>
    [[nodiscard]] std::optional<parsing::parse_target> pre_parse(
        parsing::pre_parse_data<Validator, HasTarget> pre_parse_data,
        const Node& node,
        const Parents&... parents) const
    {
        return std::apply(
            [&](auto&&... ancestors) { return pre_parse_impl(pre_parse_data, ancestors.get()...); },
            parsing::clean_node_ancestry_list(node, parents...));
    }
 
    template <typename ValueType, typename Node, typename... Parents>
    [[nodiscard]] auto parse(std::string_view token,
                             const Node& node,
                             const Parents&... parents) const
    {
        return std::apply(
            [&](auto&&... ancestors) { return parse_impl<ValueType>(token, ancestors.get()...); },
            parsing::clean_node_ancestry_list(node, parents...));
    }
 
private:
    static_assert((boost::mp11::mp_count_if_q<
                       policies_type,
                       typename phase_finder<policy::has_routing_phase_method>::finder>::value <=
                   1),
                  "Only zero or one policies supporting a routing phase is supported");
 
    template <template <typename...> typename Fn, typename... ExpandedParams>
    [[nodiscard]] constexpr static auto common_filter(ExpandedParams&... expanded_params) noexcept
    {
        // Send references to the filter method so we don't copy anything unnecessarily
        using ref_tuple = std::tuple<std::reference_wrapper<ExpandedParams>...>;
 
        // We have to wrap Fn because we're now giving it a std::reference_wrapper
        using ref_fn =
            boost::mp11::mp_bind<Fn, boost::mp11::mp_bind<traits::get_type, boost::mp11::_1>>;
 
        // We have our result tuple, but it only contains references so we now have to move
        // construct them into the 'real' types
        auto ref_result = algorithm::tuple_filter_and_construct<ref_fn::template fn>(
            ref_tuple{expanded_params...});
 
        using ref_result_t = std::decay_t<decltype(ref_result)>;
        using result_t = boost::mp11::mp_transform<traits::get_type, ref_result_t>;
 
        // Converting move-constructor of std::tuple
        return result_t{std::move(ref_result)};
    }
 
    template <template <typename...> typename Fn, typename Tuple>
    [[nodiscard]] constexpr static auto common_filter_tuple(Tuple&& tuple_params) noexcept
    {
        // std::apply does not like templates, so we have to wrap in a lambda
        return std::apply(
            [](auto&... args) { return common_filter<Fn>(std::forward<decltype(args)>(args)...); },
            tuple_params);
    }
 
    template <typename Validator, bool HasTarget>
    [[nodiscard]] constexpr auto extract_parent_target(
        [[maybe_unused]] parsing::pre_parse_data<Validator, HasTarget> pre_parse_data)
        const noexcept
    {
        if constexpr (HasTarget) {
            return utility::compile_time_optional{std::cref(pre_parse_data.target())};
        } else {
            return utility::compile_time_optional{};
        }
    }
 
    template <typename Validator, bool HasTarget, typename Node, typename... Parents>
    [[nodiscard]] std::optional<parsing::parse_target> pre_parse_impl(
        parsing::pre_parse_data<Validator, HasTarget> pre_parse_data,
        const Node& node,
        const Parents&... parents) const
    {
        auto result = vector<parsing::token_type>{};
        auto tmp_args = pre_parse_data.args();
        auto adapter = parsing::dynamic_token_adapter{result, tmp_args};
 
        // At this stage, the target is only for collecting sub-targets
        auto target = parsing::parse_target{node, parents...};
 
        auto match = parsing::pre_parse_result{parsing::pre_parse_action::valid_node};
        utility::tuple_type_iterator<priority_ordered_policies_type>([&](auto i) {
            using policy_type = std::tuple_element_t<i, priority_ordered_policies_type>;
            if constexpr (policy::has_pre_parse_phase_method_v<policy_type>) {
                if (!match || (match == parsing::pre_parse_action::skip_node)) {
                    return;
                }
 
                // Keep the skip_node_but_use_sub_targets state if later policies return valid_node
                const auto use_subs =
                    match == parsing::pre_parse_action::skip_node_but_use_sub_targets;
                match = this->policy_type::pre_parse_phase(adapter,
                                                           extract_parent_target(pre_parse_data),
                                                           target,
                                                           node,
                                                           parents...);
                if (use_subs && (match == parsing::pre_parse_action::valid_node)) {
                    match = parsing::pre_parse_action::skip_node_but_use_sub_targets;
                }
            }
        });
 
        // If we have a result and it is false, then exit early.  We need to wait until after name
        // checking is (possibly) performed to throw an exception, otherwise a parse-stopping
        // exception could be thrown when the target of the token isn't even this node
        if (match == parsing::pre_parse_action::skip_node) {
            return {};
        }
 
        if constexpr (is_named) {
            // Check the first token against the names (if the node is named of course)
            if (match != parsing::pre_parse_action::skip_node_but_use_sub_targets) {
                // If the node is named but there are no tokens, then take the first from args.
                // If args is empty, then return false
                if (result.empty()) {
                    if (tmp_args.empty()) {
                        return {};
                    }
                    result.push_back(tmp_args.front());
                    tmp_args.erase(tmp_args.begin());
                }
 
                // The first token may not have been processed, so convert
                auto& first_token = result.front();
                if (first_token.prefix == parsing::prefix_type::none) {
                    first_token = parsing::get_token_type(*this, first_token.name);
                }
 
                // And then test it is correct unless we are skipping
                if (!parsing::match<tree_node>(first_token)) {
                    return {};
                }
            }
        }
 
        // Exit early if the caller doesn't want this node
        if (!pre_parse_data.validator()(node, parents...)) {
            return {};
        }
 
        // If the policy checking returned an exception, now is the time to throw it
        match.throw_exception();
 
        // Update the unprocessed args
        pre_parse_data.args() = tmp_args;
 
        // Update the target with the pre-parsed tokens.  Remove the label token if present
        if constexpr (is_named) {
            if (!result.empty()) {
                result.erase(result.begin());
            }
        }
        target.tokens(std::move(result));
 
        return target;
    }
 
    template <typename ValueType, typename... Parents>
    [[nodiscard]] auto parse_impl(std::string_view token, const Parents&... parents) const
    {
        using finder_type = phase_finder<policy::has_parse_phase_method, ValueType>;
        using policy_type = typename finder_type::type;
 
#ifdef MSVC_1936_WORKAROUND
        static_assert(
            (boost::mp11::mp_count_if<policies_type, finder_type::finder::fn>::value <= 1),
            "Only zero or one policies supporting a parse phase is supported");
        static_assert(
            (boost::mp11::mp_count_if<
                 policies_type,
                 phase_finder<policy::has_missing_phase_method, ValueType>::finder::fn>::value <=
             1),
            "Only zero or one policies supporting a missing phase is "
            "supported");
#else
        static_assert(
            (boost::mp11::mp_count_if_q<policies_type, typename finder_type::finder>::value <= 1),
            "Only zero or one policies supporting a parse phase is supported");
        static_assert(
            (boost::mp11::mp_count_if_q<policies_type,
                                        typename phase_finder<policy::has_missing_phase_method,
                                                              ValueType>::finder>::value <= 1),
            "Only zero or one policies supporting a missing phase is "
            "supported");
#endif
 
        if constexpr (std::is_void_v<policy_type>) {
            return parser<ValueType>::parse(token);
        } else {
            return this->policy_type::template parse_phase<ValueType>(token, parents...);
        }
    }
 
    children_type children_;
};
}  // namespace arg_router