parse_target.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/parsing/token_type.hpp"
#include "arg_router/tree_node_fwd.hpp"
#include "arg_router/utility/type_hash.hpp"
#include "arg_router/utility/unsafe_any.hpp"
 
#include <boost/mp11/algorithm.hpp>
 
#include <functional>
 
namespace arg_router
{
namespace parsing
{
class parse_target
{
public:
    template <typename Node, typename... Parents>
    parse_target(vector<token_type> tokens, const Node& node, const Parents&... parents) noexcept :
        node_type_{utility::type_hash<std::decay_t<Node>>()}, tokens_(std::move(tokens))
    {
        static_assert(is_tree_node_v<Node>, "Target must be a tree_node");
 
        parse_ = [&node, &parents...](parse_target target) -> utility::unsafe_any {
            if constexpr (std::is_void_v<decltype(node.parse(std::move(target), parents...))>) {
                node.parse(std::move(target), parents...);
                return {};
            } else {
                return node.parse(std::move(target), parents...);
            }
        };
    }
 
    template <typename Node, typename... Parents>
    // https://github.com/llvm/llvm-project/issues/37250
    // NOLINTNEXTLINE(*-member-init)
    explicit parse_target(const Node& node,  //
                          const Parents&... parents) noexcept :
        parse_target(vector<token_type>{}, node, parents...)
    {
    }
 
    [[nodiscard]] vector<token_type>& tokens() noexcept { return tokens_; }
 
    [[nodiscard]] const vector<token_type>& tokens() const noexcept { return tokens_; }
 
    [[nodiscard]] vector<parse_target>& sub_targets() noexcept { return sub_targets_; }
 
    [[nodiscard]] const vector<parse_target>& sub_targets() const noexcept { return sub_targets_; }
 
    [[nodiscard]] explicit operator bool() const noexcept { return static_cast<bool>(parse_); }
 
    [[nodiscard]] std::size_t node_type() const noexcept { return node_type_; }
 
    void add_sub_target(parse_target target) { sub_targets_.push_back(std::move(target)); }
 
    void tokens(vector<token_type> tokens) { tokens_ = std::move(tokens); }
 
    utility::unsafe_any operator()()
    {
        if (parse_) {
            auto parse = std::move(parse_);
            parse_ = nullptr;
            return parse(std::move(*this));
        }
 
        return {};
    }
 
private:
    std::size_t node_type_;
    vector<token_type> tokens_;
    vector<parse_target> sub_targets_;
    std::function<utility::unsafe_any(parse_target)> parse_;
};
}  // namespace parsing
 
namespace traits
{
template <typename T>
struct has_parse_method {
    static_assert(is_tree_node_v<T>, "T must be node");
 
    template <typename U>
    using type = decltype(  //
        std::declval<const U&>().template parse<>(std::declval<parsing::parse_target>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr static bool has_parse_method_v = has_parse_method<T>::value;
}  // namespace traits
}  // namespace arg_router