MtFmt: inc/mm_type.hpp 源文件

浏览该文件的文档.
// SPDX-License-Identifier: LGPL-3.0
#if !defined(_INCLUDE_MM_TYPE_HPP_)
#define _INCLUDE_MM_TYPE_HPP_ 1
#include "mm_cfg.h"
#include <cstddef>
#include <exception>
#include <tuple>
#include <type_traits>
#include <utility>
namespace mtfmt
{
namespace details
{
struct unit_t
{
    constexpr bool operator==(unit_t) noexcept
    {
        return true;
    }
 
    constexpr bool operator!=(unit_t) noexcept
    {
        return false;
    }
 
    constexpr bool operator<(unit_t) noexcept
    {
        return false;
    }
 
    constexpr bool operator>(unit_t) noexcept
    {
        return false;
    }
 
    constexpr bool operator<=(unit_t) noexcept
    {
        return true;
    }
 
    constexpr bool operator>=(unit_t) noexcept
    {
        return true;
    }
};
 
template <typename Ret, typename... Args> struct function_traits_base
{
    using return_type_t = Ret;
    static constexpr size_t NArgs = sizeof...(Args);
    using arg_tuple_t = std::tuple<Args...>;
};
 
template <typename F> struct function_trait_impl;
 
template <typename F>
struct function_trait_impl<std::reference_wrapper<F>>
    : public function_trait_impl<F>
{
};
 
// for: function pointer
template <typename Ret, typename... Args>
struct function_trait_impl<Ret (*)(Args...)>
    : public function_traits_base<Ret, Args...>
{
};
 
// for: member function pointer
template <typename Ret, typename Cl, typename... Args>
struct function_trait_impl<Ret (Cl::*)(Args...)>
    : public function_traits_base<Ret, Args...>
{
};
 
// for: const member function pointer
template <typename Ret, typename Cl, typename... Args>
struct function_trait_impl<Ret (Cl::*)(Args...) const>
    : public function_traits_base<Ret, Args...>
{
};
 
// 除去如上三种情况的case
template <typename F>
struct function_trait_impl
    : public function_trait_impl<decltype(&F::operator())>
{
};
 
template <typename F>
struct function_trait
    : public function_trait_impl<typename std::decay<F>::type>
{
};
 
template <typename F>
using function_return_type_t =
    typename function_trait<F>::return_type_t;
 
template <typename F>
using function_arg_tuple_t = typename function_trait<F>::arg_tuple_t;
 
template <typename F> struct function_arg_count
{
    static constexpr std::size_t N = function_trait<F>::NArgs;
};
 
template <template <typename...> typename Tt, typename Ti>
struct is_instance_of
{
    static constexpr bool value = false;
};
 
// 判断Ti是否为模板Tt的实例化
template <template <typename...> typename Tt, typename... Ti>
struct is_instance_of<Tt, Tt<Ti...>>
{
    static constexpr bool value = true;
};
 
template <typename F, std::size_t N> struct function_has_n_args
{
    static constexpr bool value = function_arg_count<F>::N == N;
};
 
template <typename F, std::size_t N, typename T>
struct function_args_hold_type
{
    static constexpr bool value = std::is_same<
        // 取得第n个参数
        typename std::tuple_element<N, function_arg_tuple_t<F>>::type,
        // 并检查其拥有的类型
        T>::value;
};
 
template <typename F, typename R, typename... T> struct holds_prototype
{
    using _Ret = details::function_return_type_t<F>;
    using _Args = details::function_arg_tuple_t<F>;
    using Targs = std::tuple<typename std::decay<T>::type...>;
 
    static constexpr bool value =
        function_has_n_args<F, sizeof...(T)>::value &&
        std::is_same<_Ret, R>::value &&
        std::is_same<_Args, Targs>::value;
};
 
template <bool cond, typename T>
using enable_if_t = typename std::enable_if<cond, T>::type;
 
template <std::size_t A1, std::size_t... An> struct max_value;
 
template <std::size_t A1> struct max_value<A1>
{
    static constexpr size_t value = A1;
};
 
template <std::size_t A1, std::size_t A2, std::size_t... An>
struct max_value<A1, A2, An...>
{
    static constexpr size_t value = A1 >= A2 ?
                                        max_value<A1, An...>::value :
                                        max_value<A2, An...>::value;
};
 
template <bool A1, bool... An> struct disjunction;
 
template <bool A1> struct disjunction<A1>
{
    static constexpr bool value = A1;
};
 
template <bool A1, bool A2, bool... An>
struct disjunction<A1, A2, An...>
{
    static constexpr bool value = A1 && disjunction<A2, An...>::value;
};
 
} // namespace details
} // namespace mtfmt
#endif // _INCLUDE_MM_TYPE_HPP_