policy.hpp

// Copyright (C) 2022 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/dynamic_token_adapter.hpp"
#include "arg_router/parsing/parse_target.hpp"
#include "arg_router/utility/compile_time_optional.hpp"
 
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/bind.hpp>
 
#include <type_traits>
 
namespace arg_router::policy
{
template <typename T, typename... Args>
struct is_policy : std::false_type {
};
 
template <typename T>
constexpr auto is_policy_v = is_policy<T>::value;
 
template <typename Tuple>
struct is_all_policies : boost::mp11::mp_all_of<Tuple, is_policy> {
};
 
template <typename Tuple>
constexpr auto is_all_policies_v = is_all_policies<Tuple>::value;
 
template <typename T>
struct has_pre_parse_phase_method {
    static_assert(policy::is_policy_v<T>, "T must be a policy");
 
    template <typename U>
    using type = decltype(  //
        std::declval<const U&>().template pre_parse_phase<>(
            std::declval<parsing::dynamic_token_adapter&>(),
            std::declval<utility::compile_time_optional<void>>(),
            std::declval<parsing::parse_target&>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr static bool has_pre_parse_phase_method_v = has_pre_parse_phase_method<T>::value;
 
template <typename T, typename ValueType>
struct has_parse_phase_method {
    static_assert(policy::is_policy_v<T>, "T must be a policy");
 
    template <typename U>
    using type = decltype(  //
        std::declval<const U&>().template parse_phase<ValueType>(std::declval<std::string_view>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T, typename ValueType>
constexpr static bool has_parse_phase_method_v = has_parse_phase_method<T, ValueType>::value;
 
template <typename T, typename ValueType>
struct has_validation_phase_method {
    static_assert(policy::is_policy_v<T>, "T must be a policy");
 
    template <typename U>
    using type1 = decltype(  //
        std::declval<const U&>().template validation_phase<ValueType>(
            std::declval<const ValueType&>()));
 
    template <typename U>
    using type2 = decltype(  //
        std::declval<const U&>().validation_phase(std::declval<const ValueType&>()));
 
    constexpr static bool value =
        boost::mp11::mp_valid<type1, T>::value || boost::mp11::mp_valid<type2, T>::value;
};
 
template <typename T, typename ValueType>
constexpr static bool has_validation_phase_method_v =
    has_validation_phase_method<T, ValueType>::value;
 
template <typename T>
struct has_routing_phase_method {
    static_assert(policy::is_policy_v<T>, "T must be a policy");
 
    template <typename U>
    using type = decltype(std::declval<const U&>().template routing_phase<>());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr static bool has_routing_phase_method_v = has_routing_phase_method<T>::value;
 
template <typename T, typename ValueType>
struct has_missing_phase_method {
    static_assert(policy::is_policy_v<T>, "T must be a policy");
 
    template <typename U>
    using type = decltype(  //
        std::declval<const U&>().template missing_phase<ValueType>());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T, typename ValueType>
constexpr static bool has_missing_phase_method_v = has_missing_phase_method<T, ValueType>::value;
 
template <typename T>
struct has_priority {
    static_assert(policy::is_policy_v<T>, "T must be a policy");
 
    template <typename U>
    using type = decltype(U::priority);
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr static bool has_priority_v = has_priority<T>::value;
 
template <typename ParentsTuple>
class nearest_mode_like
{
    template <typename Parent>
    struct policy_finder {
        constexpr static bool value =
            boost::mp11::mp_find_if_q<
                typename Parent::policies_type,
                boost::mp11::mp_bind<has_routing_phase_method, boost::mp11::_1>>::value !=
            std::tuple_size_v<typename Parent::policies_type>;
    };
 
public:
    using index = boost::mp11::mp_find_if<ParentsTuple, policy_finder>;
 
    using type = boost::mp11::mp_eval_if_c<index::value == std::tuple_size_v<ParentsTuple>,
                                           void,
                                           boost::mp11::mp_at,
                                           ParentsTuple,
                                           index>;
};
}  // namespace arg_router::policy