TypeTraits.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_TYPE_TRAITS_HPP
#define MIMICPP_TYPE_TRAITS_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/utilities/TypeList.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <cstddef>
    #include <cstdint>
    #include <tuple>
    #include <type_traits>
#endif
 
namespace mimicpp::detail
{
    template <typename Signature>
    struct has_default_call_convention
        : public std::false_type
    {
    };
 
    template <typename Signature>
    inline constexpr bool has_default_call_convention_v = has_default_call_convention<Signature>::value;
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...)>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...)>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) const>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) const>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) const noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) const noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...)&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...)&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) & noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) & noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) const&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) const&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) const & noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) const & noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) &&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) &&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) && noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) && noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) const&&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) const&&>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params...) const && noexcept>
        : public std::true_type
    {
    };
 
    template <typename Return, typename... Params>
    struct has_default_call_convention<Return(Params..., ...) const && noexcept>
        : public std::true_type
    {
    };
 
    struct default_call_convention
    {
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{

    template <typename Signature>
    concept has_default_call_convention = detail::has_default_call_convention_v<Signature>;


    template <has_default_call_convention Signature>
    struct signature_call_convention<Signature>
    {
        using type = detail::default_call_convention;
    };



    template <>
    struct call_convention_traits<detail::default_call_convention>
    {
        using tag_t = detail::default_call_convention;
 
        template <typename Signature>
        using remove_call_convention_t = std::type_identity_t<Signature>;
 
        template <typename Signature>
        using add_call_convention_t = std::type_identity_t<Signature>;
 
        template <typename Derived, typename Signature>
        using call_interface_t = detail::DefaultCallInterface<Derived, Signature>;
    };


 
    template <typename Signature>
    struct signature_remove_call_convention
    {
        using type = typename call_convention_traits<
            signature_call_convention_t<Signature>>::template remove_call_convention_t<Signature>;
    };

 
    namespace detail
    {

        template <
            typename Signature,
            template <typename> typename Trait,
            typename CallConvTrait = call_convention_traits<signature_call_convention_t<Signature>>,
            typename Applied = Trait<typename CallConvTrait::template remove_call_convention_t<Signature>>>
        struct signature_apply_trait
            : public std::bool_constant<Applied::value>
        {
            using type = typename CallConvTrait::template add_call_convention_t<typename Applied::type>;
        };
    }

 
    namespace detail
    {
        template <typename Signature>
        struct signature_remove_noexcept;
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...)>
            : public std::false_type
        {
            using type = Return(Params...);
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...)>
            : public std::false_type
        {
            using type = Return(Params..., ...);
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) noexcept>
            : public std::true_type
        {
            using type = Return(Params...);
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) noexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...);
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) const>
            : public std::false_type
        {
            using type = Return(Params...) const;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) const>
            : public std::false_type
        {
            using type = Return(Params..., ...) const;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) const noexcept>
            : public std::true_type
        {
            using type = Return(Params...) const;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) const noexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...)&>
            : public std::false_type
        {
            using type = Return(Params...) &;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...)&>
            : public std::false_type
        {
            using type = Return(Params..., ...) &;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) & noexcept>
            : public std::true_type
        {
            using type = Return(Params...) &;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) & noexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) &;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) const&>
            : public std::false_type
        {
            using type = Return(Params...) const&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) const&>
            : public std::false_type
        {
            using type = Return(Params..., ...) const&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) const & noexcept>
            : public std::true_type
        {
            using type = Return(Params...) const&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) const & noexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) &&>
            : public std::false_type
        {
            using type = Return(Params...) &&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) &&>
            : public std::false_type
        {
            using type = Return(Params..., ...) &&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) && noexcept>
            : public std::true_type
        {
            using type = Return(Params...) &&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) && noexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) &&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) const&&>
            : public std::false_type
        {
            using type = Return(Params...) const&&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) const&&>
            : public std::false_type
        {
            using type = Return(Params..., ...) const&&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params...) const && noexcept>
            : public std::true_type
        {
            using type = Return(Params...) const&&;
        };
 
        template <typename Return, typename... Params>
        struct signature_remove_noexcept<Return(Params..., ...) const && noexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const&&;
        };
    }
 
    template <typename Signature>
    struct signature_remove_noexcept
        : public detail::signature_apply_trait<Signature, detail::signature_remove_noexcept>
    {
    };


 
    namespace detail
    {
        template <typename Signature>
        struct signature_add_noexcept;
 
        template <typename Signature>
            requires signature_remove_noexcept<Signature>::value
        struct signature_add_noexcept<Signature>
            : public std::false_type
        {
            using type = Signature;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params...)>
            : public std::true_type
        {
            using type = Return(Params...) noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params..., ...)>
            : public std::true_type
        {
            using type = Return(Params..., ...) noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params...) const>
            : public std::true_type
        {
            using type = Return(Params...) const noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params..., ...) const>
            : public std::true_type
        {
            using type = Return(Params..., ...) const noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params...)&>
            : public std::true_type
        {
            using type = Return(Params...) & noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params..., ...)&>
            : public std::true_type
        {
            using type = Return(Params..., ...) & noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params...) const&>
            : public std::true_type
        {
            using type = Return(Params...) const& noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params..., ...) const&>
            : public std::true_type
        {
            using type = Return(Params..., ...) const& noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params...) &&>
            : public std::true_type
        {
            using type = Return(Params...) && noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params..., ...) &&>
            : public std::true_type
        {
            using type = Return(Params..., ...) && noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params...) const&&>
            : public std::true_type
        {
            using type = Return(Params...) const&& noexcept;
        };
 
        template <typename Return, typename... Params>
        struct signature_add_noexcept<Return(Params..., ...) const&&>
            : public std::true_type
        {
            using type = Return(Params..., ...) const&& noexcept;
        };
    }
 
    template <typename Signature>
    struct signature_add_noexcept
        : public detail::signature_apply_trait<Signature, detail::signature_add_noexcept>
    {
    };


 
    template <typename Signature>
    struct signature_is_noexcept
        : public std::bool_constant<signature_remove_noexcept<Signature>::value>
    {
    };


 
    namespace detail
    {
        template <typename Signature, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl;
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params...), isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params..., ...), isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params...) const, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params..., ...) const, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params...)&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params..., ...)&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params...) const&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params..., ...) const&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params...)&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params..., ...)&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params...) const&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_ref_qualifier_impl<Return(Params..., ...) const&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const noexcept(isNoexcept);
        };
 
        // Todo: When msvc some day supports deducing noexcept, we can further simplify this.
        template <typename Signature, typename Trait = signature_remove_noexcept<Signature>>
        struct signature_remove_ref_qualifier_
            : public signature_remove_ref_qualifier_impl<typename Trait::type, Trait::value>
        {
        };
 
        template <typename Signature>
        using signature_remove_ref_qualifier = signature_remove_ref_qualifier_<Signature>;
    }
 
    template <typename Signature>
    struct signature_remove_ref_qualifier
        : public detail::signature_apply_trait<Signature, detail::signature_remove_ref_qualifier>
    {
    };


 
    namespace detail
    {
        template <typename Signature, bool isNoexcept>
        struct signature_remove_const_qualifier_impl;
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params...), isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params...) const, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params..., ...), isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params..., ...) const, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params...)&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params...) const&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params..., ...)&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params..., ...) const&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params...)&&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params...) const&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params..., ...)&&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_remove_const_qualifier_impl<Return(Params..., ...) const&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) && noexcept(isNoexcept);
        };
 
        // Todo: When msvc some day supports deducing noexcept, we can further simplify this.
        template <typename Signature, typename Trait = signature_remove_noexcept<Signature>>
        struct signature_remove_const_qualifier_
            : public signature_remove_const_qualifier_impl<typename Trait::type, Trait::value>
        {
        };
 
        template <typename Signature>
        using signature_remove_const_qualifier = signature_remove_const_qualifier_<Signature>;
    }
 
    template <typename Signature>
    struct signature_remove_const_qualifier
        : public detail::signature_apply_trait<Signature, detail::signature_remove_const_qualifier>
    {
    };


 
    namespace detail
    {
        template <typename Signature, bool isNoexcept>
        struct signature_add_const_qualifier_impl;
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_const_qualifier_impl<Return(Params...), isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_const_qualifier_impl<Return(Params..., ...), isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_const_qualifier_impl<Return(Params...)&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) const& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_const_qualifier_impl<Return(Params..., ...)&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_const_qualifier_impl<Return(Params...)&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) const&& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_const_qualifier_impl<Return(Params..., ...)&&, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const&& noexcept(isNoexcept);
        };
 
        // Todo: When msvc some day supports deducing noexcept, we can further simplify this.
        template <typename Signature, typename Trait = signature_remove_noexcept<Signature>>
        struct signature_add_const_qualifier_
            : public signature_add_const_qualifier_impl<typename Trait::type, Trait::value>
        {
        };
 
        template <typename Signature>
            requires signature_remove_const_qualifier<Signature>::value
        struct signature_add_const_qualifier_<Signature>
            : public std::false_type
        {
            using type = Signature;
        };
 
        template <typename Signature>
        using signature_add_const_qualifier = signature_add_const_qualifier_<Signature>;
    }
 
    template <typename Signature>
    struct signature_add_const_qualifier
        : public detail::signature_apply_trait<Signature, detail::signature_add_const_qualifier>
    {
    };


 
    namespace detail
    {
        template <typename Signature, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl;
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params...), isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params..., ...), isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params...) const, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) const& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params..., ...) const, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params...)&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params..., ...)&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params...) const&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) const& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_lvalue_ref_qualifier_impl<Return(Params..., ...) const&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) const& noexcept(isNoexcept);
        };
 
        // Todo: When msvc some day supports deducing noexcept, we can further simplify this.
        template <typename Signature, typename Trait = signature_remove_noexcept<Signature>>
        struct signature_add_lvalue_ref_qualifier_
            : public signature_add_lvalue_ref_qualifier_impl<typename Trait::type, Trait::value>
        {
        };
 
        template <typename Signature>
        using signature_add_lvalue_ref_qualifier = signature_add_lvalue_ref_qualifier_<Signature>;
    }
 
    template <typename Signature>
    struct signature_add_lvalue_ref_qualifier
        : public detail::signature_apply_trait<Signature, detail::signature_add_lvalue_ref_qualifier>
    {
    };


 
    namespace detail
    {
        template <typename Signature, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl;
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params...), isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params..., ...), isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params...) const, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params...) const&& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params..., ...) const, isNoexcept>
            : public std::true_type
        {
            using type = Return(Params..., ...) const&& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params...)&&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params..., ...)&&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params...) const&&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params...) const&& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, bool isNoexcept>
        struct signature_add_rvalue_ref_qualifier_impl<Return(Params..., ...) const&&, isNoexcept>
            : public std::false_type
        {
            using type = Return(Params..., ...) const&& noexcept(isNoexcept);
        };
 
        // Todo: When msvc some day supports deducing noexcept, we can further simplify this.
        template <typename Signature, typename Trait = signature_remove_noexcept<Signature>>
        struct signature_add_rvalue_ref_qualifier_
            : public signature_add_rvalue_ref_qualifier_impl<typename Trait::type, Trait::value>
        {
        };
 
        template <typename Signature>
        using signature_add_rvalue_ref_qualifier = signature_add_rvalue_ref_qualifier_<Signature>;
    }
 
    template <typename Signature>
    struct signature_add_rvalue_ref_qualifier
        : public detail::signature_apply_trait<Signature, detail::signature_add_rvalue_ref_qualifier>
    {
    };


 
    template <typename Signature>
    struct signature_decay
    {
        using type =
            typename detail::signature_remove_ref_qualifier_impl<
                typename detail::signature_remove_const_qualifier_impl<
                    typename detail::signature_remove_noexcept<
                        signature_remove_call_convention_t<Signature>>::type,
                    false>::type,
                false>::type;
    };


 
    template <typename Signature>
    struct signature_return_type
        : public signature_return_type<signature_decay_t<Signature>>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_return_type<Return(Params...)>
    {
        using type = Return;
    };
 
    template <typename Return, typename... Params>
    struct signature_return_type<Return(Params..., ...)>
    {
        using type = Return;
    };


 
    template <std::size_t index, typename Signature>
    struct signature_param_type
        : public signature_param_type<
              index,
              signature_decay_t<Signature>>
    {
    };
 
    template <std::size_t index, typename Return, typename... Params>
    struct signature_param_type<index, Return(Params...)>
        : public std::tuple_element<index, std::tuple<Params...>>
    {
    };


 
    template <typename Signature>
    struct signature_const_qualification
        : public std::integral_constant<
              Constness,
              signature_remove_const_qualifier<Signature>::value
                  ? Constness::as_const
                  : Constness::non_const>
    {
    };


 
    template <typename Signature>
    struct signature_ref_qualification
        : public signature_ref_qualification<
              signature_remove_noexcept_t<
                  signature_remove_const_qualifier_t<
                      signature_remove_call_convention_t<Signature>>>>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_ref_qualification<Return(Params...)>
        : public std::integral_constant<
              ValueCategory,
              ValueCategory::any>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_ref_qualification<Return(Params..., ...)>
        : public std::integral_constant<
              ValueCategory,
              ValueCategory::any>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_ref_qualification<Return(Params...)&>
        : public std::integral_constant<
              ValueCategory,
              ValueCategory::lvalue>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_ref_qualification<Return(Params..., ...)&>
        : public std::integral_constant<
              ValueCategory,
              ValueCategory::lvalue>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_ref_qualification<Return(Params...) &&>
        : public std::integral_constant<
              ValueCategory,
              ValueCategory::rvalue>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_ref_qualification<Return(Params..., ...) &&>
        : public std::integral_constant<
              ValueCategory,
              ValueCategory::rvalue>
    {
    };


 
    template <typename Signature>
    struct signature_param_list
        : public signature_param_list<
              signature_decay_t<Signature>>
    {
    };
 
    template <typename Return, typename... Params>
    struct signature_param_list<Return(Params...)>
    {
        using type = util::type_list<Params...>;
    };


 
    namespace detail
    {
        template <typename Signature, typename T, bool isNoexcept>
        struct signature_prepend_param_impl;
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params...), T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params..., ...), T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params..., ...) noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params...)&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params..., ...)&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params..., ...) & noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params...)&&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params..., ...)&&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params..., ...) && noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params...) const, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params..., ...) const, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params..., ...) const noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params...) const&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params...) const& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params..., ...) const&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params..., ...) const& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params...) const&&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params...) const&& noexcept(isNoexcept);
        };
 
        template <typename Return, typename... Params, typename T, bool isNoexcept>
        struct signature_prepend_param_impl<Return(Params..., ...) const&&, T, isNoexcept>
            : public std::true_type
        {
            using type = Return(T, Params..., ...) const&& noexcept(isNoexcept);
        };
 
        // Todo: When msvc some day supports deducing noexcept, we can further simplify this.
        template <typename Signature, typename T, typename Trait = signature_remove_noexcept<Signature>>
        struct signature_prepend_param_
            : public signature_prepend_param_impl<typename Trait::type, T, Trait::value>
        {
        };
 
        template <typename T>
        struct signature_prepend_param
        {
            template <typename Signature>
            using type = signature_prepend_param_<Signature, T>;
        };
    }
 
    template <typename Signature, typename T>
    struct signature_prepend_param
        : public detail::signature_apply_trait<Signature, detail::signature_prepend_param<T>::template type>
    {
    };

}
 
namespace mimicpp::detail
{
    template <typename First, typename Second, bool reversed = false>
    struct is_overloadable_with
        : public std::conditional_t<
              reversed,
              std::false_type,
              is_overloadable_with<Second, First, true>>
    {
    };
 
    template <typename First, typename Second>
        requires(
            !std::same_as<
                signature_param_list_t<signature_decay_t<First>>,
                signature_param_list_t<signature_decay_t<Second>>>)
    struct is_overloadable_with<First, Second, false>
        : public std::true_type
    {
    };
 
    template <typename Return1, typename Return2, typename... Params, bool reversed>
    struct is_overloadable_with<Return1(Params...), Return2(Params...) const, reversed>
        : public std::true_type
    {
    };
 
    template <typename Return1, typename Return2, typename... Params, bool reversed>
    struct is_overloadable_with<Return1(Params...)&, Return2(Params...) const&, reversed>
        : public std::true_type
    {
    };
 
    template <typename Return1, typename Return2, typename... Params, bool reversed>
    struct is_overloadable_with<Return1(Params...)&, Return2(Params...)&&, reversed>
        : public std::true_type
    {
    };
 
    template <typename Return1, typename Return2, typename... Params, bool reversed>
    struct is_overloadable_with<Return1(Params...)&, Return2(Params...) const&&, reversed>
        : public std::true_type
    {
    };
 
    template <typename Return1, typename Return2, typename... Params, bool reversed>
    struct is_overloadable_with<Return1(Params...) const&, Return2(Params...)&&, reversed>
        : public std::true_type
    {
    };
 
    template <typename Return1, typename Return2, typename... Params, bool reversed>
    struct is_overloadable_with<Return1(Params...) const&, Return2(Params...) const&&, reversed>
        : public std::true_type
    {
    };
 
    template <typename Return1, typename Return2, typename... Params, bool reversed>
    struct is_overloadable_with<Return1(Params...)&&, Return2(Params...) const&&, reversed>
        : public std::true_type
    {
    };
 
    template <typename Signature>
    using normalize_overload_t = signature_remove_noexcept_t<
        signature_remove_call_convention_t<Signature>>;
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
 
    template <typename First, typename Second>
    struct is_overloadable_with
        : public detail::is_overloadable_with<
              detail::normalize_overload_t<First>,
              detail::normalize_overload_t<Second>>
    {
    };

 
    namespace detail
    {
        template <typename First, typename... Others>
        [[nodiscard]]
        consteval bool is_overload_set() noexcept
        {
            if constexpr (0 == sizeof...(Others))
            {
                return true;
            }
            else
            {
                return (... && is_overloadable_with<First, Others>::value)
                    && is_overload_set<Others...>();
            }
        }
    }

 
    template <typename First, typename... Others>
    struct is_overload_set
        : public std::bool_constant<
              detail::is_overload_set<detail::normalize_overload_t<First>, detail::normalize_overload_t<Others>...>()>
    {
    };



    template <>
    struct uint_with_size<1u>
    {
        using type = std::uint8_t;
    };

    template <>
    struct uint_with_size<2u>
    {
        using type = std::uint16_t;
    };

    template <>
    struct uint_with_size<4u>
    {
        using type = std::uint32_t;
    };

    template <>
    struct uint_with_size<8u>
    {
        using type = std::uint64_t;
    };

}
 
#endif