traits.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/tree_node_fwd.hpp"
 
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/bind.hpp>
#include <boost/mp11/utility.hpp>
 
#include <algorithm>
#include <functional>
#include <optional>
#include <ostream>
#include <tuple>
#include <type_traits>
 
// Surprised this is not already done somewhere in mp11, without it using
// std::tuple and mp_list in generic situations doesn't work
namespace std
{
template <typename... T>
struct tuple_size<boost::mp11::mp_list<T...>> : std::integral_constant<std::size_t, sizeof...(T)> {
};
 
template <std::size_t I, typename... T>
struct tuple_element<I, boost::mp11::mp_list<T...>> {
    using type = boost::mp11::mp_at_c<boost::mp11::mp_list<T...>, I>;
};
}  // namespace std
 
namespace arg_router
{
class multi_lang_exception;
 
namespace traits
{
template <typename... T>
struct always_false : std::false_type {
};
 
template <typename... T>
constexpr bool always_false_v = always_false<T...>::value;
 
template <typename T>
using get_type = typename T::type;
 
template <typename T>
using get_value_type = typename T::value_type;
 
template <typename T>
struct has_value_type {
    constexpr static bool value = boost::mp11::mp_valid<get_value_type, T>::value;
};
 
template <typename T>
constexpr bool has_value_type_v = has_value_type<T>::value;
 
template <typename T, typename Enable = void>
struct underlying_type {
    using type = T;
};
 
template <typename T>
struct underlying_type<T, std::enable_if_t<std::is_enum_v<T>>> {
    using type = std::underlying_type_t<T>;
};
 
template <typename T>
using underlying_type_t = typename underlying_type<T>::type;
 
template <typename T, typename = void>
struct is_tuple_like : std::false_type {
};
 
template <typename T>
struct is_tuple_like<T, std::void_t<typename std::tuple_size<T>::type>> : std::true_type {
};
 
template <typename T>
constexpr bool is_tuple_like_v = is_tuple_like<T>::value;
 
template <typename T>
struct is_specialisation : std::false_type {
};
 
template <template <typename...> typename U, typename... Args>
struct is_specialisation<U<Args...>> : std::true_type {
};
 
template <typename T>
constexpr bool is_specialisation_v = is_specialisation<T>::value;
 
template <typename T, template <typename...> typename U>
struct is_specialisation_of : std::false_type {
};
 
template <template <typename...> typename U, typename... Args>
struct is_specialisation_of<U<Args...>, U> : std::true_type {
};
 
template <typename T, template <typename...> typename U>
constexpr bool is_specialisation_of_v = is_specialisation_of<T, U>::value;
 
template <typename T, typename U, typename... Args>
struct is_same_when_despecialised : std::false_type {
};
 
template <template <typename...> typename T, typename U, typename... Args>
struct is_same_when_despecialised<T<Args...>, U> : is_specialisation_of<U, T> {
};
 
template <typename T, typename U>
constexpr bool is_same_when_despecialised_v = is_same_when_despecialised<T, U>::value;
 
template <auto Value>
using integral_constant = std::integral_constant<decltype(Value), Value>;
 
template <typename T>
struct add_optional {
    using type = std::optional<T>;
};
 
template <typename T>
using add_optional_t = typename add_optional<T>::type;
 
template <typename T>
class unpack_and_derive
{
    static_assert(always_false_v<T>, "T must be a tuple-like type");
};
 
template <template <typename...> typename T, typename... Params>
class unpack_and_derive<T<Params...>> : public Params...
{
    // When are we going to get language-level tuple unpacking!?
    template <std::size_t... I>
    constexpr explicit unpack_and_derive(
        T<Params...> params,
        [[maybe_unused]] std::integer_sequence<std::size_t, I...> Is) noexcept :
        Params{std::get<I>(std::move(params))}...
    {
    }
 
    // This empty tuple overload is just to prevent an
    // -Werror=unused-but-set-parameter on the params parameter
    template <std::size_t... I>
    constexpr explicit unpack_and_derive(
        [[maybe_unused]] T<Params...> t,
        [[maybe_unused]] std::integer_sequence<std::size_t> Is) noexcept
    {
    }
 
public:
    constexpr explicit unpack_and_derive(T<Params...> params) noexcept :
        unpack_and_derive{std::move(params), std::make_index_sequence<sizeof...(Params)>{}}
    {
    }
};
 
template <typename From, typename To>
struct supports_static_cast_conversion {
    template <typename F, typename T>
    using type = decltype(static_cast<T>(std::declval<F>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, From, To>::value;
};
 
template <typename From, typename To>
constexpr bool supports_static_cast_conversion_v = supports_static_cast_conversion<From, To>::value;
 
template <typename T>
struct has_long_name_method {
    template <typename U>
    using type = decltype(U::long_name());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_long_name_method_v = has_long_name_method<T>::value;
 
template <typename T>
struct has_short_name_method {
    template <typename U>
    using type = decltype(U::short_name());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_short_name_method_v = has_short_name_method<T>::value;
 
template <typename T>
struct has_display_name_method {
    template <typename U>
    using type = decltype(U::display_name());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_display_name_method_v = has_display_name_method<T>::value;
 
template <typename T>
struct has_none_name_method {
    template <typename U>
    using type = decltype(U::none_name());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_none_name_method_v = has_none_name_method<T>::value;
 
template <typename T>
struct has_error_name_method {
    template <typename U>
    using type = decltype(U::error_name());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_error_name_method_v = has_error_name_method<T>::value;
 
template <typename T>
struct has_description_method {
    template <typename U>
    using type = decltype(U::description());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_description_method_v = has_description_method<T>::value;
 
template <typename T>
struct has_value_separator_method {
    template <typename U>
    using type = decltype(U::value_separator());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_value_separator_method_v = has_value_separator_method<T>::value;
 
template <typename T>
struct has_token_end_marker_method {
    template <typename U>
    using type = decltype(U::token_end_marker());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_token_end_marker_method_v = has_token_end_marker_method<T>::value;
 
template <typename T>
struct has_maximum_count_method {
    template <typename U>
    using type = decltype(U::maximum_count());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_maximum_count_method_v = has_maximum_count_method<T>::value;
 
template <typename T>
struct has_minimum_count_method {
    template <typename U>
    using type = decltype(U::minimum_count());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_minimum_count_method_v = has_minimum_count_method<T>::value;
 
template <typename T>
struct has_minimum_value_method {
    template <typename U>
    using type = decltype(U::minimum_value());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_minimum_value_method_v = has_minimum_value_method<T>::value;
 
template <typename T>
struct has_maximum_value_method {
    template <typename U>
    using type = decltype(U::maximum_value());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_maximum_value_method_v = has_maximum_value_method<T>::value;
 
template <typename T>
struct has_push_back_method {
    template <typename U>
    using type = decltype(std::declval<U&>().push_back(std::declval<typename U::value_type>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_push_back_method_v = has_push_back_method<T>::value;
 
template <typename T>
struct has_help_data_type {
    template <typename U>
    using type = typename U::template help_data_type<false>;
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_help_data_type_v = has_help_data_type<T>::value;
 
template <typename T>
class has_runtime_children_method
{
    struct fake_tree_node {
        [[nodiscard]] const std::tuple<>& children() const { return children_; }
 
        std::tuple<> children_;
    };
 
    template <typename U>
    using type =
        decltype(U::runtime_children(std::declval<const fake_tree_node&>(),
                                     std::declval<std::function<bool(const fake_tree_node&)>>()));
 
public:
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_runtime_children_method_v = has_runtime_children_method<T>::value;
 
template <typename T>
struct has_generate_help_method {
    template <typename U>
    using type = decltype(U::template generate_help<U, U, false>(std::declval<std::ostream&>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_generate_help_method_v = has_generate_help_method<T>::value;
 
template <typename T>
struct has_runtime_generate_help_method {
    template <typename U>
    using type =
        decltype(U::template generate_help<U, U, false>(std::declval<std::ostream&>(),
                                                        std::declval<const runtime_help_data&>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_runtime_generate_help_method_v = has_runtime_generate_help_method<T>::value;
 
template <typename T>
struct has_generate_runtime_help_data_method {
    template <typename U>
    using type = decltype(std::declval<const T&>().template generate_runtime_help_data<true, U>(
        std::declval<const U&>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_generate_runtime_help_data_method_v =
    has_generate_runtime_help_data_method<T>::value;
 
template <typename T>
struct has_runtime_enabled_method {
    template <typename U>
    using type = decltype(std::declval<const U&>().runtime_enabled());
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr bool has_runtime_enabled_method_v = has_runtime_enabled_method<T>::value;
 
template <typename T>
struct has_translate_exception_method {
    template <typename U>
    using type = decltype(U::translate_exception(std::declval<const multi_lang_exception&>()));
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr static bool has_translate_exception_method_v = has_translate_exception_method<T>::value;
 
template <typename T>
struct has_error_code_translations_type {
    template <typename U>
    using type = typename U::error_code_translations;
 
    constexpr static bool value = boost::mp11::mp_valid<type, T>::value;
};
 
template <typename T>
constexpr static bool has_error_code_translations_type_v =
    has_error_code_translations_type<T>::value;
 
template <typename T>
struct arg_extractor  : arg_extractor<decltype(&T::operator())>  {
};
 
template <typename R, typename... Args>
struct arg_extractor<R (*)(Args...)> {
    using type = std::tuple<R, Args...>;
};
template <typename R, typename C, typename... Args>
struct arg_extractor<R (C::*)(Args...)> {
    using type = std::tuple<R, Args...>;
};
template <typename R, typename C, typename... Args>
struct arg_extractor<R (C::*)(Args...) const> {
    using type = std::tuple<R, Args...>;
};
template <typename R, typename C, typename... Args>
struct arg_extractor<R (C::*)(Args...) noexcept> {
    using type = std::tuple<R, Args...>;
};
template <typename R, typename C, typename... Args>
struct arg_extractor<R (C::*)(Args...) const noexcept> {
    using type = std::tuple<R, Args...>;
};
 
template <typename T>
using arg_extractor_t = typename arg_extractor<T>::type;
 
template <typename T>
constexpr std::size_t arity_v = std::tuple_size_v<arg_extractor_t<T>> - 1;
 
template <typename T, std::size_t I>
using arg_type_at_index = std::tuple_element_t<I + 1, arg_extractor_t<T>>;
}  // namespace traits
}  // namespace arg_router