value_separator.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/parse_target.hpp"
#include "arg_router/parsing/parsing.hpp"
#include "arg_router/policy/policy.hpp"
#include "arg_router/utility/compile_time_optional.hpp"
#include "arg_router/utility/compile_time_string.hpp"
 
namespace arg_router::policy
{
template <typename S>
class value_separator_t
{
    static_assert(utility::utf8::count(S::get()) == 1,
                  "Value separator must only be one character");
    static_assert(!utility::utf8::is_whitespace(S::get()),
                  "Value separator character must not be whitespace");
 
public:
    using string_type = S;
 
    constexpr static auto priority = std::size_t{1000};
 
    constexpr explicit value_separator_t([[maybe_unused]] S str = {}) noexcept {}
 
    [[nodiscard]] constexpr static std::string_view value_separator() 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 value_separator_t");
 
        using owner_type = boost::mp11::mp_first<std::tuple<Parents...>>;
 
        static_assert(traits::has_minimum_count_method_v<owner_type> &&
                          traits::has_maximum_count_method_v<owner_type>,
                      "Value separator support requires an owning node to have "
                      "minimum and maximum count policies");
        static_assert((owner_type::minimum_count() == 1) && (owner_type::maximum_count() == 1),
                      "Value separator support requires an owning node to have "
                      "a fixed count of 1");
 
        if (tokens.empty()) {
            return parsing::pre_parse_action::valid_node;
        }
 
        auto first = tokens.begin();
        const auto first_token = *first;
 
        // Find the separator
        const auto separator_index = first_token.name.find_first_of(value_separator());
        if (separator_index == std::string_view::npos) {
            // If we can't find the separator but the token matches the parent node name, then we
            // need to throw as the user has just forgotten the separator and needs to be told
            auto processed_token = first_token;
            if (first_token.prefix == parsing::prefix_type::none) {
                processed_token = parsing::get_token_type(first_token.name);
            }
            if (parsing::match<owner_type>(processed_token)) {
                return multi_lang_exception{error_code::missing_value_separator,
                                            parsing::node_token_type<owner_type>()};
            }
 
            return parsing::pre_parse_action::skip_node;
        }
 
        const auto value_arg = first_token.name.substr(separator_index + S::get().size());
        if (value_arg.empty()) {
            return parsing::pre_parse_action::skip_node;
        }
 
        // Insert value token after the label one
        tokens.insert(first + 1, {parsing::prefix_type::none, value_arg});
 
        // Remove the value and separator part of the label token
        const auto label_arg = first_token.name.substr(0, separator_index);
        first.set({first_token.prefix, label_arg});
 
        return parsing::pre_parse_action::valid_node;
    }
};
 
template <char S>
constexpr auto value_separator = value_separator_t<AR_STRING(S)>{};
 
template <typename S>
constexpr auto value_separator_utf8 = value_separator_t<S>{};
 
template <typename S>
struct is_policy<value_separator_t<S>> : std::true_type {
};
}  // namespace arg_router::policy