tree_recursor.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/tree_node.hpp"
#include "arg_router/utility/tuple_iterator.hpp"
 
namespace arg_router::utility
{
namespace detail
{
struct always_false {
    template <typename...>
    [[nodiscard]] constexpr static bool fn() noexcept
    {
        return false;
    }
};
 
template <typename Visitor, typename Current, typename... Parents>
constexpr void tree_recursor_impl(Visitor& visitor,
                                  const Current& current,
                                  const Parents&... parents)
{
    visitor(current, parents...);
 
    tuple_iterator(
        [&](auto /*i*/, const auto& child) {
            tree_recursor_impl(visitor, child, current, parents...);
        },
        current.children());
}
 
template <typename Visitor, typename SkipFn, typename Current, typename... Parents>
constexpr void tree_type_recursor_impl()
{
    if constexpr (!SkipFn::template fn<Current, Parents...>()) {
        Visitor::template fn<Current, Parents...>();
 
        if constexpr (is_tree_node_v<Current>) {
            using policies_and_children_tuple =
                boost::mp11::mp_append<typename Current::policies_type,
                                       typename Current::children_type>;
 
            tuple_type_iterator<policies_and_children_tuple>([](auto i) {
                using next_type = std::tuple_element_t<i, policies_and_children_tuple>;
                tree_type_recursor_impl<Visitor, SkipFn, next_type, Current, Parents...>();
            });
        }
    }
}
 
template <template <typename...> typename Visitor, typename Current, typename... Parents>
struct tree_type_recursor_collector_impl {
    template <typename ChildOrPolicy>
    using recurse =
        typename tree_type_recursor_collector_impl<Visitor, ChildOrPolicy, Current, Parents...>::
            type;
 
    template <typename T>
    using get_children_type = typename T::children_type;
    template <typename T>
    using get_policies_type = typename T::policies_type;
 
    using children_type = boost::mp11::
        mp_eval_if_c<!is_tree_node_v<Current>, std::tuple<>, get_children_type, Current>;
    using policies_type = boost::mp11::
        mp_eval_if_c<!is_tree_node_v<Current>, std::tuple<>, get_policies_type, Current>;
 
    using type =
        boost::mp11::mp_eval_if_c<!is_tree_node_v<Current>,
                                  std::tuple<typename Visitor<Current, Parents...>::type>,
                                  boost::mp11::mp_push_back,
                                  boost::mp11::mp_flatten<boost::mp11::mp_transform<
                                      recurse,
                                      boost::mp11::mp_append<children_type, policies_type>>>,
                                  typename Visitor<Current, Parents...>::type>;
};
}  // namespace detail
 
template <typename Visitor, typename Root>
constexpr void tree_recursor(Visitor visitor, const Root& root)
{
    detail::tree_recursor_impl(visitor, root);
}
 
template <typename Visitor, typename SkipFn, typename Root>
constexpr void tree_type_recursor()
{
    detail::tree_type_recursor_impl<Visitor, SkipFn, Root>();
}
 
template <typename Visitor, typename Root>
constexpr void tree_type_recursor()
{
    detail::tree_type_recursor_impl<Visitor, detail::always_false, Root>();
}
 
template <template <typename...> typename Visitor, typename Root>
struct tree_type_recursor_collector {
    using type = typename detail::tree_type_recursor_collector_impl<Visitor, Root>::type;
};
 
template <template <typename...> typename Visitor, typename Root>
using tree_type_recursor_collector_t = typename tree_type_recursor_collector<Visitor, Root>::type;
}  // namespace arg_router::utility