parsing.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/traits.hpp"
#include "arg_router/utility/result.hpp"
 
namespace arg_router::parsing
{
enum class pre_parse_action : std::uint8_t {
    skip_node,
    valid_node,
    skip_node_but_use_sub_targets
};
 
using pre_parse_result = utility::result<pre_parse_action, multi_lang_exception>;
 
template <typename T>
[[nodiscard]] constexpr bool match(token_type token) noexcept
{
    using namespace std::string_literals;
 
    if constexpr (traits::has_long_name_method_v<T>) {
        if ((token.prefix == prefix_type::long_) && (token.name == T::long_name())) {
            return true;
        }
    }
    if constexpr (traits::has_short_name_method_v<T>) {
        if ((token.prefix == prefix_type::short_) && (token.name == T::short_name())) {
            return true;
        }
    }
    if constexpr (traits::has_none_name_method_v<T>) {
        if ((token.prefix == prefix_type::none) && (token.name == T::none_name())) {
            return true;
        }
    }
 
    return false;
}
 
template <typename Node>
[[nodiscard]] constexpr token_type node_token_type() noexcept
{
    if constexpr (traits::has_error_name_method_v<Node>) {
        return {prefix_type::none, Node::error_name()};
    } else if constexpr (traits::has_display_name_method_v<Node>) {
        return {prefix_type::none, Node::display_name()};
    } else if constexpr (traits::has_long_name_method_v<Node>) {
        return {prefix_type::long_, Node::long_name()};
    } else if constexpr (traits::has_short_name_method_v<Node>) {
        return {prefix_type::short_, Node::short_name()};
    } else if constexpr (traits::has_none_name_method_v<Node>) {
        return {prefix_type::none, Node::none_name()};
    } else {
        static_assert(traits::always_false_v<Node>, "Node does not have a name");
    }
}
 
template <typename BaseNode, typename... DerivedAndParents>
[[nodiscard]] constexpr auto clean_node_ancestry_list(
    const BaseNode& base_node,
    const DerivedAndParents&... derived_and_parents)
{
    // Iterate along the ancestry until you hit a node type that is _not_ a base of Node, then
    // remove the elements up to that element
    using parents_tuple = std::tuple<std::decay_t<DerivedAndParents>...>;
 
    constexpr auto remove_n = boost::mp11::mp_find_if_q<
        parents_tuple,
        boost::mp11::mp_not_fn_q<
            boost::mp11::mp_bind<std::is_base_of, std::decay_t<BaseNode>, boost::mp11::_1>>>::value;
    if constexpr (remove_n == 0) {
        return std::tuple{std::cref(base_node), std::cref(derived_and_parents)...};
    } else {
        return algorithm::tuple_drop<remove_n - 1>(std::tuple{std::cref(derived_and_parents)...});
    }
}
 
template <typename Node, typename... Parents>
[[nodiscard]] bool is_runtime_disabled(const Node& node, const Parents&... parents) noexcept
{
    auto any_disabled = false;
    utility::tuple_iterator(
        [&]([[maybe_unused]] auto i, auto entry) {
            using entry_type = typename std::decay_t<decltype(entry)>::type;
 
            if constexpr (traits::has_runtime_enabled_method_v<entry_type>) {
                any_disabled = any_disabled || !entry.get().runtime_enabled();
            }
        },
        std::tuple{std::cref(node), std::cref(parents)...});
 
    return any_disabled;
}
}  // namespace arg_router::parsing