token_end_marker.hpp

// Copyright (C) 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/parsing.hpp"
#include "arg_router/policy/multi_stage_value.hpp"
 
namespace arg_router::policy
{
template <typename S>
class token_end_marker_t
{
public:
    using string_type = S;
 
    constexpr static auto priority = std::size_t{760};
 
    constexpr explicit token_end_marker_t([[maybe_unused]] S str = {}) noexcept {}
 
    [[nodiscard]] constexpr static std::string_view token_end_marker() noexcept { return S::get(); }
 
    template <typename ProcessedTarget, typename... Parents>
    [[nodiscard]] parsing::pre_parse_result pre_parse_phase(
        parsing::dynamic_token_adapter& tokens,
        [[maybe_unused]] utility::compile_time_optional<ProcessedTarget> processed_target,
        [[maybe_unused]] parsing::parse_target& target,
        [[maybe_unused]] const Parents&... parents) const
    {
        static_assert((sizeof...(Parents) >= 1),
                      "At least one parent needed for token_end_marker_t");
 
        using owner_type = boost::mp11::mp_first<std::tuple<Parents...>>;
 
        constexpr auto has_count = traits::has_minimum_count_method_v<owner_type> &&
                                   traits::has_maximum_count_method_v<owner_type>;
        static_assert(has_count, "Token end marker can only be used in variable list length nodes");
 
        if constexpr (has_count) {
            static_assert((owner_type::minimum_count() != owner_type::maximum_count()) &&
                              !policy::has_multi_stage_value_v<owner_type>,
                          "Token end marker can only be used in variable list length nodes");
        }
 
        // Transfer the tokens up to the end marker.  If not found then the whole token list is
        // used.  If found, the token is removed as it should be in the parsed results
        const auto it = std::find_if(tokens.begin() + (owner_type::is_named ? 1 : 0),
                                     tokens.end(),
                                     [](auto&& token) { return token.name == token_end_marker(); });
        tokens.transfer(it);
        tokens.erase(it);
 
        return parsing::pre_parse_action::valid_node;
    }
 
private:
    static_assert(utility::utf8::count(token_end_marker()) > 0,
                  "Token end markers must not be an empty string");
    static_assert(!utility::utf8::contains_whitespace(token_end_marker()),
                  "Token end markers cannot contain whitespace");
};
 
template <typename S>
constexpr auto token_end_marker = token_end_marker_t<S>{};
 
template <typename S>
struct is_policy<token_end_marker_t<S>> : std::true_type {
};
}  // namespace arg_router::policy