runtime_enable.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/required.hpp"
 
namespace arg_router::policy
{
template <typename T = void>
class runtime_enable
{
public:
    constexpr static auto priority = std::size_t{800};
 
    explicit runtime_enable(bool enable) noexcept : enabled_{enable} {}
 
    [[nodiscard]] bool runtime_enabled() const noexcept { return enabled_; }
 
    template <typename ProcessedTarget, typename... Parents>
    [[nodiscard]] parsing::pre_parse_result pre_parse_phase(
        [[maybe_unused]] 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, "Runtime enable requires at least 1 parent");
        using node_type = boost::mp11::mp_first<std::tuple<Parents...>>;
        static_assert(!policy::is_required_v<node_type>,
                      "Runtime enable must not be used with policy::required");
 
        return runtime_enabled() ? parsing::pre_parse_action::valid_node :
                                   parsing::pre_parse_action::skip_node;
    }
 
protected:
    bool enabled_;
};
 
template <typename T>
struct is_policy<runtime_enable<T>> : std::true_type {
};
 
template <typename T>
class runtime_enable_required : public runtime_enable<T>
{
public:
    using runtime_enable<T>::pre_parse_phase;
 
    using value_type = T;
 
    explicit runtime_enable_required(bool enable, T default_value = {}) noexcept :
        runtime_enable<T>{enable}, default_value_{std::move(default_value)}
    {
    }
 
    template <typename ValueType, typename... Parents>
    [[nodiscard]] ValueType missing_phase([[maybe_unused]] const Parents&... parents) const
    {
        if (this->enabled_) {
            static_assert(sizeof...(Parents) >= 1, "Runtime enable requires at least 1 parent");
            using node_type = boost::mp11::mp_first<std::tuple<Parents...>>;
 
            throw multi_lang_exception{error_code::missing_required_argument,
                                       parsing::node_token_type<node_type>()};
        }
 
        return default_value_;
    }
 
private:
    value_type default_value_;
};
 
template <typename T>
struct is_policy<runtime_enable_required<T>> : std::true_type {
};
}  // namespace arg_router::policy